Upon preroll, destroy ranged ingredient.

src/main/java/com/gregtechceu/gtceu/api/capability/recipe/FluidRecipeCapability.java

@@ -179,7 +179,9 @@ public int getMaxParallelByInput(IRecipeCapabilityHolder holder, GTRecipe recipe
         for (Content content : inputs) {
             FluidIngredient ing = of(content.content());
 
-            int amount = ing.getAmount();
+            int amount;
+            if (ing instanceof IRangedIngredient provider) amount = provider.getMaxRoll();
+            else amount = ing.getAmount();
 
             if (content.chance() == 0) {
                 nonConsumables.addTo(ing, amount);

src/main/java/com/gregtechceu/gtceu/api/machine/trait/RecipeLogic.java

@@ -400,7 +400,13 @@ public ActionResult handleTickRecipe(GTRecipe recipe) {
         var result = RecipeHelper.matchTickRecipe(getRLMachine(), recipe);
         if (!result.isSuccess()) return result;
 
-        recipe.doTickPrerolls(this.chanceCaches);
+        if (lastDisplayedRecipe == null) {
+            GTCEu.LOGGER.warn("Last Displayed Recipe is null! Ingredients may roll incorrectly.");
+            this.lastDisplayedRecipe = lastRecipe.copy();
+            syncDataHolder.markClientSyncFieldDirty("lastDisplayedRecipe");
+            markLastRecipeDirty();
+        }
+        recipe.doTickPrerolls(this.chanceCaches, this.lastDisplayedRecipe);
 
         result = handleTickRecipeIO(recipe, IO.IN);
         if (!result.isSuccess()) return result;

src/main/java/com/gregtechceu/gtceu/api/recipe/GTRecipe.java

@@ -235,18 +235,56 @@ public ChanceLogic getChanceLogicForCapability(RecipeCapability<?> cap, IO io, b
     }
 
     public void doPrerolls(IdentityHashMap<RecipeCapability<?>, Object2IntMap<?>> chanceCaches) {
-        var rangedContents = getFullContents();
-        for (Content item : rangedContents) {
-            if (item.content() instanceof IRangedIngredient ranged)
-                ranged.rollSampledCount();
+        for (var handler : inputs.values()) {
+            for (var iterator = handler.listIterator(); iterator.hasNext();) {
+                var content = iterator.next();
+                if (content.content() instanceof IRangedIngredient ranged) {
+                    ranged.rollSampledCount();
+                    iterator.set(new Content(ranged.collapse(), content.chance(), content.maxChance()));
+                }
+            }
+        }
+        for (var handler : outputs.values()) {
+            for (var iterator = handler.listIterator(); iterator.hasNext();) {
+                var content = iterator.next();
+                if (content.content() instanceof IRangedIngredient ranged) {
+                    ranged.rollSampledCount();
+                    iterator.set(new Content(ranged.collapse(), content.chance(), content.maxChance()));
+                }
+            }
         }
     }
 
-    public void doTickPrerolls(IdentityHashMap<RecipeCapability<?>, Object2IntMap<?>> chanceCaches) {
-        var rangedContents = getFullTickContents();
-        for (Content item : rangedContents) {
-            if (item.content() instanceof IRangedIngredient ranged)
-                ranged.rollSampledCount();
+    public void doTickPrerolls(IdentityHashMap<RecipeCapability<?>, Object2IntMap<?>> chanceCaches,
+                               GTRecipe lastDisplayedRecipe) {
+        if (!this.hasTick()) return;
+
+        this.tickInputs.clear();
+        this.tickOutputs.clear();
+
+        for (var capability : lastDisplayedRecipe.tickInputs.keySet()) {
+            var handler = lastDisplayedRecipe.tickInputs.get(capability);
+            for (var iterator = handler.listIterator(); iterator.hasNext();) {
+                var content = iterator.next();
+                if (content.content() instanceof IRangedIngredient ranged) {
+                    ranged.rollSampledCount();
+                    content = new Content(ranged.collapse(), content.chance(), content.maxChance());
+                    ranged.reset();
+                }
+                tickInputs.computeIfAbsent(capability, c -> new ArrayList<>()).add(content);
+            }
+        }
+        for (var capability : lastDisplayedRecipe.tickOutputs.keySet()) {
+            var handler = lastDisplayedRecipe.tickOutputs.get(capability);
+            for (var iterator = handler.listIterator(); iterator.hasNext();) {
+                var content = iterator.next();
+                if (content.content() instanceof IRangedIngredient ranged) {
+                    ranged.rollSampledCount();
+                    content = new Content(ranged.collapse(), content.chance(), content.maxChance());
+                    ranged.reset();
+                }
+                tickOutputs.computeIfAbsent(capability, c -> new ArrayList<>()).add(content);
+            }
         }
     }
 

src/main/java/com/gregtechceu/gtceu/api/recipe/RecipeHelper.java

@@ -11,6 +11,7 @@
 import com.gregtechceu.gtceu.api.recipe.content.Content;
 import com.gregtechceu.gtceu.api.recipe.ingredient.EnergyStack;
 import com.gregtechceu.gtceu.api.recipe.ingredient.FluidIngredient;
+import com.gregtechceu.gtceu.api.recipe.ingredient.IRangedIngredient;
 import com.gregtechceu.gtceu.config.ConfigHolder;
 import com.gregtechceu.gtceu.data.recipe.builder.GTRecipeBuilder;
 import com.gregtechceu.gtceu.utils.GTUtil;
@@ -400,6 +401,7 @@ public static int getRatioForDistillery(FluidIngredient fluidInput, FluidIngredi
     }
 
     public static boolean isFluidStackDivisibleForDistillery(FluidIngredient fluidStack, int divisor) {
-        return fluidStack.getAmount() % divisor == 0 && fluidStack.getAmount() / divisor >= 25;
+        int amount = (fluidStack instanceof IRangedIngredient ranged ? ranged.getMaxRoll() : fluidStack.getAmount());
+        return amount % divisor == 0 && amount / divisor >= 25;
     }
 }

src/main/java/com/gregtechceu/gtceu/api/recipe/ingredient/IRangedIngredient.java

@@ -1,20 +1,27 @@
 package com.gregtechceu.gtceu.api.recipe.ingredient;
 
+import com.gregtechceu.gtceu.GTCEu;
 import com.gregtechceu.gtceu.api.GTValues;
 
 import net.minecraft.util.RandomSource;
 import net.minecraft.util.valueproviders.IntProvider;
 
 import org.jetbrains.annotations.NotNull;
 
-public interface IRangedIngredient {
+public interface IRangedIngredient<T> {
 
     IntProvider getCountProvider();
 
     int getSampledCount();
 
     void setSampledCount(int count);
 
+    default T collapse() {
+        if (!isRolled())
+            GTCEu.LOGGER.warn("Ranged ingredient was collapsed without being rolled!");
+        return null;
+    }
+
     /**
      * If this ingredient has not yet had its count rolled, rolls it and returns the roll.
      * If it has, returns the existing roll.
@@ -28,8 +35,6 @@ default int rollSampledCount() {
 
     int rollSampledCount(@NotNull RandomSource random);
 
-    int getAmount();
-
     /**
      * @return the average roll of this ranged amount
      */

src/main/java/com/gregtechceu/gtceu/api/recipe/ingredient/IntProviderFluidIngredient.java

@@ -28,7 +28,7 @@
  * and either an {@link IntProvider} or {@code int, int} range bounds (inclusive).
  * Functions similarly to {@link IntProviderIngredient}.
  */
-public class IntProviderFluidIngredient extends FluidIngredient implements IRangedIngredient {
+public class IntProviderFluidIngredient extends FluidIngredient implements IRangedIngredient<FluidIngredient> {
 
     public static final Codec<IntProviderFluidIngredient> CODEC = ExtraCodecs.JSON
             .xmap(IntProviderFluidIngredient::fromJson, IntProviderFluidIngredient::toJson);
@@ -38,42 +38,38 @@ public class IntProviderFluidIngredient extends FluidIngredient implements IRang
     /**
      * The last result of {@link IntProviderFluidIngredient#getSampledCount()}. -1 if not rolled.
      */
+    @Setter
     @Getter
     protected int sampledCount = -1;
     /**
      * The {@link FluidIngredient} to have a ranged amount.
      */
     @Getter
     private final FluidIngredient inner;
-    @Setter
-    protected FluidStack[] fluidStacks = null;
 
     protected IntProviderFluidIngredient(FluidIngredient inner, IntProvider provider) {
         super(inner.values, provider.getMaxValue(), inner.nbt);
         this.inner = inner;
         this.countProvider = provider;
-        setAmount(provider.getMaxValue());
     }
 
     protected IntProviderFluidIngredient(FluidIngredient inner, IntProvider provider, int sampledCount) {
         super(inner.values, provider.getMaxValue(), inner.nbt);
         this.inner = inner;
         this.countProvider = provider;
         this.sampledCount = sampledCount;
-        setAmount(isRolled() ? sampledCount : provider.getMaxValue());
     }
 
     @Override
     public IntProviderFluidIngredient copy() {
         IntProviderFluidIngredient ipfi = new IntProviderFluidIngredient(this.inner, this.countProvider);
         ipfi.setSampledCount(this.sampledCount);
-        ipfi.setAmount(this.getAmount());
         return ipfi;
     }
 
     @Override
     public boolean isEmpty() {
-        return this.getAmount() == 0 || super.isEmpty();
+        return inner.isEmpty();
     }
 
     /**
@@ -84,23 +80,8 @@ public boolean isEmpty() {
      */
     @Override
     public FluidStack[] getStacks() {
-        if (changed || fluidStacks == null) {
-            changed = false;
-            if (!isRolled()) {
-                setAmount(rollSampledCount());
-                if (getAmount() == 0) {
-                    fluidStacks = EMPTY_STACK_ARRAY;
-                    return EMPTY_STACK_ARRAY;
-                }
-            }
-            var innerStacks = inner.getStacks();
-            this.fluidStacks = new FluidStack[innerStacks.length];
-            for (int i = 0; i < fluidStacks.length; i++) {
-                fluidStacks[i] = innerStacks[i].copy();
-                fluidStacks[i].setAmount(getAmount());
-            }
-        }
-        return fluidStacks;
+        GTCEu.LOGGER.warn("Cannot get stacks of a Ranged Fluid Ingredient!");
+        return EMPTY_STACK_ARRAY;
     }
 
     /**
@@ -127,9 +108,8 @@ public FluidStack[] getStacks() {
     public int rollSampledCount(@NotNull RandomSource random) {
         if (!isRolled()) {
             sampledCount = countProvider.sample(random);
-            this.setAmount(sampledCount);
         }
-        return getAmount();
+        return sampledCount;
     }
 
     /**
@@ -144,16 +124,12 @@ public double getMidRoll() {
      */
     public void reset() {
         sampledCount = -1;
-        super.setAmount(getMaxRoll());
-        fluidStacks = null;
     }
 
-    /**
-     * Also sets the Amount of this ingredient
-     */
-    public void setSampledCount(int count) {
-        this.sampledCount = count;
-        super.setAmount(count);
+    @Override
+    public FluidIngredient collapse() {
+        IRangedIngredient.super.collapse();
+        return new FluidIngredient(inner.values, rollSampledCount(), inner.nbt);
     }
 
     /**