Support persisting the remainder item for the nutritional liquifier (mekanism/Mekanism-Feature-Requests#479)

Author: pupnewfster

build.gradle

@@ -391,8 +391,7 @@ dependencies {
 
     def crt = "com.blamejared.crafttweaker:CraftTweaker-neoforge-${minecraft_version}:${crafttweaker_version}"
     compileOnly(crt)
-    //TODO: Re-enable when it updates to neo changes
-    //localRuntime(crt)
+    localRuntime(crt)
     def jeiTweaker = "com.blamejared.jeitweaker:JeiTweaker-forge-1.20.1:${jeitweaker_version}"
     compileOnly(jeiTweaker)
     //TODO: Re-enable when it updates

gradle.properties

@@ -37,7 +37,7 @@ yamlops_version=1.2.0
 
 #Mod dependencies
 cc_tweaked_version=1.111.0
-crafttweaker_version=20.0.12
+crafttweaker_version=20.0.13
 ctm_version=1.2.0+1
 curios_version=9.0.2+1.21
 emi_version=1.1.7

src/api/java/mekanism/api/recipes/ItemStackToFluidOptionalItemRecipe.java

@@ -0,0 +1,92 @@
+package mekanism.api.recipes;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Predicate;
+import mekanism.api.annotations.NothingNullByDefault;
+import mekanism.api.recipes.ingredients.ItemStackIngredient;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.SingleRecipeInput;
+import net.minecraft.world.level.Level;
+import net.neoforged.neoforge.fluids.FluidStack;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Base class for defining ItemStack to fluid recipes with an optional item output.
+ * <br>
+ * Input: ItemStack
+ * <br>
+ * Output: FluidStack, Optional ItemStack
+ *
+ * @apiNote There is currently only one type of ItemStack to FluidStack recipe type:
+ * <ul>
+ *     <li>Nutritional Liquification: These cannot currently be created, but are processed in the Nutritional Liquifier.</li>
+ * </ul>
+ *
+ * @since 10.6.3
+ */
+@NothingNullByDefault
+public abstract class ItemStackToFluidOptionalItemRecipe extends MekanismRecipe<SingleRecipeInput> implements Predicate<@NotNull ItemStack> {
+
+    @Override
+    public abstract boolean test(ItemStack itemStack);
+
+    @Override
+    public boolean matches(SingleRecipeInput input, Level level) {
+        //Don't match incomplete recipes or ones that don't match
+        return !isIncomplete() && test(input.item());
+    }
+
+    /**
+     * Gets the input ingredient.
+     */
+    public abstract ItemStackIngredient getInput();
+
+    /**
+     * Gets a new output based on the given input.
+     *
+     * @param input Specific input.
+     *
+     * @return New output.
+     *
+     * @apiNote While Mekanism does not currently make use of the input, it is important to support it and pass the proper value in case any addons define input based
+     * outputs where things like NBT may be different
+     * @implNote The passed in input should <strong>NOT</strong> be modified.
+     */
+    @Contract(value = "_ -> new", pure = true)
+    public abstract FluidOptionalItemOutput getOutput(ItemStack input);
+
+    /**
+     * For JEI, gets the output representations to display.
+     *
+     * @return Representation of the output, <strong>MUST NOT</strong> be modified.
+     */
+    public abstract List<FluidOptionalItemOutput> getOutputDefinition();
+
+    @Override
+    public boolean isIncomplete() {
+        return getInput().hasNoMatchingInstances();
+    }
+
+    /**
+     * @apiNote Fluid must be present, but the item may be empty.
+     */
+    public record FluidOptionalItemOutput(FluidStack fluid, ItemStack optionalItem) {
+
+        public FluidOptionalItemOutput {
+            Objects.requireNonNull(fluid, "Fluid output cannot be null.");
+            Objects.requireNonNull(optionalItem, "Item output cannot be null.");
+            if (fluid.isEmpty()) {
+                throw new IllegalArgumentException("Fluid output cannot be empty.");
+            }
+        }
+
+        /**
+         * Copies the backing objects of this output object.
+         */
+        public FluidOptionalItemOutput copy() {
+            return new FluidOptionalItemOutput(fluid.copy(), optionalItem.copy());
+        }
+    }
+}

src/api/java/mekanism/api/recipes/ItemStackToFluidRecipe.java

@@ -18,10 +18,7 @@
  * <br>
  * Output: FluidStack
  *
- * @apiNote There is currently only one type of ItemStack to FluidStack recipe type:
- * <ul>
- *     <li>Nutritional Liquification: These cannot currently be created, but are processed in the Nutritional Liquifier.</li>
- * </ul>
+ * @apiNote There is currently no types of ItemStack to FluidStack recipe type
  */
 @NothingNullByDefault
 public abstract class ItemStackToFluidRecipe extends MekanismRecipe<SingleRecipeInput> implements Predicate<@NotNull ItemStack> {

src/api/java/mekanism/api/recipes/basic/BasicItemStackToFluidOptionalItemRecipe.java

@@ -0,0 +1,52 @@
+package mekanism.api.recipes.basic;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import mekanism.api.annotations.NothingNullByDefault;
+import mekanism.api.recipes.ItemStackToFluidOptionalItemRecipe;
+import mekanism.api.recipes.ingredients.ItemStackIngredient;
+import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.Contract;
+
+/**
+ * Basic implementation of {@link ItemStackToFluidOptionalItemRecipe}
+ * @since 10.6.3
+ */
+@NothingNullByDefault
+public abstract class BasicItemStackToFluidOptionalItemRecipe extends ItemStackToFluidOptionalItemRecipe {
+
+    protected final ItemStackIngredient input;
+    protected final FluidOptionalItemOutput output;
+
+    /**
+     * @param input  Input.
+     * @param output Output.
+     */
+    public BasicItemStackToFluidOptionalItemRecipe(ItemStackIngredient input, FluidOptionalItemOutput output) {
+        this.input = Objects.requireNonNull(input, "Input cannot be null.");
+        Objects.requireNonNull(output, "Output cannot be null.");
+        this.output = output.copy();
+    }
+
+    @Override
+    public boolean test(ItemStack itemStack) {
+        return input.test(itemStack);
+    }
+
+    @Override
+    public ItemStackIngredient getInput() {
+        return input;
+    }
+
+    @Override
+    @Contract(value = "_ -> new", pure = true)
+    public FluidOptionalItemOutput getOutput(ItemStack input) {
+        return output.copy();
+    }
+
+    @Override
+    public List<FluidOptionalItemOutput> getOutputDefinition() {
+        return Collections.singletonList(output);
+    }
+}

src/api/java/mekanism/api/recipes/cache/OneInputCachedRecipe.java

@@ -13,6 +13,8 @@
 import mekanism.api.recipes.ElectrolysisRecipe;
 import mekanism.api.recipes.ElectrolysisRecipe.ElectrolysisRecipeOutput;
 import mekanism.api.recipes.FluidToFluidRecipe;
+import mekanism.api.recipes.ItemStackToFluidOptionalItemRecipe;
+import mekanism.api.recipes.ItemStackToFluidOptionalItemRecipe.FluidOptionalItemOutput;
 import mekanism.api.recipes.ItemStackToFluidRecipe;
 import mekanism.api.recipes.ItemStackToItemStackRecipe;
 import mekanism.api.recipes.MekanismRecipe;
@@ -35,6 +37,9 @@
 @NothingNullByDefault
 public class OneInputCachedRecipe<INPUT, OUTPUT, RECIPE extends MekanismRecipe<?> & Predicate<INPUT>> extends CachedRecipe<RECIPE> {
 
+    private static final Predicate<ElectrolysisRecipeOutput> SEPARATOR_OUTPUT_EMPTY = output -> output.left().isEmpty() || output.right().isEmpty();
+    private static final Predicate<FluidOptionalItemOutput> FLUID_OPTIONAL_ITEM_OUTPUT_EMPTY = output -> output.fluid().isEmpty();
+
     private final IInputHandler<INPUT> inputHandler;
     private final IOutputHandler<OUTPUT> outputHandler;
     private final Predicate<INPUT> inputEmptyCheck;
@@ -108,7 +113,7 @@ protected void finishProcessing(int operations) {
     public static OneInputCachedRecipe<@NotNull FluidStack, @NotNull ElectrolysisRecipeOutput, ElectrolysisRecipe> separating(ElectrolysisRecipe recipe,
           BooleanSupplier recheckAllErrors, IInputHandler<@NotNull FluidStack> inputHandler, IOutputHandler<@NotNull ElectrolysisRecipeOutput> outputHandler) {
         return new OneInputCachedRecipe<>(recipe, recheckAllErrors, inputHandler, outputHandler, recipe::getInput, recipe::getOutput, ConstantPredicates.FLUID_EMPTY,
-              ConstantPredicates.alwaysFalse());
+              SEPARATOR_OUTPUT_EMPTY);
     }
 
     /**
@@ -156,6 +161,24 @@ protected void finishProcessing(int operations) {
               ConstantPredicates.FLUID_EMPTY);
     }
 
+    /**
+     * Base implementation for handling ItemStack to Fluid with optional Item Recipes.
+     *
+     * @param recipe           Recipe.
+     * @param recheckAllErrors Returns {@code true} if processing should be continued even if an error is hit in order to gather all the errors. It is recommended to not
+     *                         do this every tick or if there is no one viewing recipes.
+     * @param inputHandler     Input handler.
+     * @param outputHandler    Output handler.
+     *
+     * @since 10.6.3
+     */
+    public static OneInputCachedRecipe<@NotNull ItemStack, @NotNull FluidOptionalItemOutput, ItemStackToFluidOptionalItemRecipe> itemToFluidOptionalItem(
+          ItemStackToFluidOptionalItemRecipe recipe, BooleanSupplier recheckAllErrors, IInputHandler<@NotNull ItemStack> inputHandler,
+          IOutputHandler<@NotNull FluidOptionalItemOutput> outputHandler) {
+        return new OneInputCachedRecipe<>(recipe, recheckAllErrors, inputHandler, outputHandler, recipe::getInput, recipe::getOutput, ConstantPredicates.ITEM_EMPTY,
+              FLUID_OPTIONAL_ITEM_OUTPUT_EMPTY);
+    }
+
     /**
      * Base implementation for handling ItemStack to Chemical Recipes.
      *

src/api/java/mekanism/api/recipes/outputs/OutputHelper.java

@@ -11,6 +11,7 @@
 import mekanism.api.inventory.IInventorySlot;
 import mekanism.api.math.MathUtils;
 import mekanism.api.recipes.ElectrolysisRecipe.ElectrolysisRecipeOutput;
+import mekanism.api.recipes.ItemStackToFluidOptionalItemRecipe.FluidOptionalItemOutput;
 import mekanism.api.recipes.PressurizedReactionRecipe.PressurizedReactionRecipeOutput;
 import mekanism.api.recipes.SawmillRecipe.ChanceOutput;
 import mekanism.api.recipes.cache.CachedRecipe.OperationTracker;
@@ -165,6 +166,40 @@ public void calculateOperationsCanSupport(OperationTracker tracker, PressurizedR
         };
     }
 
+    /**
+     * Wraps a fluid tank and an inventory slot an {@link IOutputHandler}.
+     *
+     * @param tank                    Tank to wrap.
+     * @param slot                    Slot to wrap.
+     * @param tankNotEnoughSpaceError The error to apply if the tank output causes the recipe to not be able to perform any operations.
+     * @param slotNotEnoughSpaceError The error to apply if the slot output causes the recipe to not be able to perform any operations.
+     *
+     * @since 10.6.3
+     */
+    public static IOutputHandler<@NotNull FluidOptionalItemOutput> getOutputHandler(IExtendedFluidTank tank, RecipeError tankNotEnoughSpaceError,
+          IInventorySlot slot, RecipeError slotNotEnoughSpaceError) {
+        Objects.requireNonNull(tank, "Tank cannot be null.");
+        Objects.requireNonNull(slot, "Slot cannot be null.");
+        Objects.requireNonNull(tankNotEnoughSpaceError, "Tank not enough space error cannot be null.");
+        Objects.requireNonNull(slotNotEnoughSpaceError, "Slot not enough space error cannot be null.");
+        return new IOutputHandler<>() {
+
+            @Override
+            public void handleOutput(FluidOptionalItemOutput toOutput, int operations) {
+                OutputHelper.handleOutput(tank, toOutput.fluid(), operations);
+                OutputHelper.handleOutput(slot, toOutput.optionalItem(), operations);
+            }
+
+            @Override
+            public void calculateOperationsCanSupport(OperationTracker tracker, FluidOptionalItemOutput toOutput) {
+                OutputHelper.calculateOperationsCanSupport(tracker, tankNotEnoughSpaceError, tank, toOutput.fluid());
+                if (tracker.shouldContinueChecking()) {
+                    OutputHelper.calculateOperationsCanSupport(tracker, slotNotEnoughSpaceError, slot, toOutput.optionalItem());
+                }
+            }
+        };
+    }
+
     /**
      * Wraps two gas tank into an {@link IOutputHandler}.
      *