Fix Recycling Reloading Removing other Recipes, add Decomposition Rep…

…lacing

src/main/groovy-tests/recipeRecyclingTests.groovy

@@ -54,4 +54,7 @@ createRecipe(metaitem('battery_buffer.uhv.8'), [
         [null, null, null]])
 
 // Add / Change recycling to a stack
-changeStackRecycling(metaitem('battery_buffer.uhv.16'), [metaitem('battery_buffer.uv.16'), metaitem('charger.uv')])
+changeStackRecycling(metaitem('battery_buffer.uhv.16'), [metaitem('battery_buffer.uv.16'), metaitem('charger.uv')])
+
+// Remove recycling to a stack
+removeStackRecycling(metaitem('item_collector.hv'))

src/main/groovy-tests/replaceDecompositionTests.groovy

@@ -0,0 +1,52 @@
+// Imports all Static Functions from the decomposition section of the groovy helpers
+
+import static com.nomiceu.nomilabs.groovy.GroovyHelpers.ReplaceDecompositionHelpers.*
+
+// Replace Decomposition (changes chemical formula and decomp recipe)
+// This only changes DECOMPOSITION recipes, not the recipes that make it, such as ABS, Mixer, Blast Furnace, etc.
+// Decomp recipes are either centrifuge or electrolyzer recipes.
+// You cannot enable them, if the material already has them disabled.
+// Chemical Formula Changes are not recursive.
+// However, changes will apply if you first change the inner materials before the outer.
+
+// Having the target material be a Material Stack changes nothing.
+// Having the component list be an item stack will grab the material, then use the stack's amount as the material amount.
+// Having the component list be an fluid stack will grab the material, then use the fluid amount / 1000.
+// You cannot have fractional components.
+// You can have materials with only liquid forms (fluorine, mercury, etc.), as both inputs and outputs.
+
+// Don't have recursive components! This will throw a Stack Overflow Error.
+
+// How to specify a Material Stack
+println("Material Stack of 1 Pyrite | " + materialstack('pyrite')) // Material Stack of 1 Pyrite
+println("Material Stack of 6 Pyrite | " + materialstack('pyrite') * 6) // Material Stack of 6 Pyrite
+
+println("Material Stack of 1 Pyrite | " + material('pyrite') * 1) // Material Stack of 1 Pyrite
+println("Material Stack of 6 Pyrite | " + material('pyrite') * 6) // Material Stack of 6 Pyrite
+
+// How not to specify a Material Stack
+println("Material: Pyrite | " + material('pyrite')) // MATERIAL, not Material Stack! This will throw an error!
+
+// Replace/Add Decomposition by Material
+replaceDecomposition(material('pyrite'), [materialstack('nomilabs:pulsating_iron') * 5, fluid('fluorine') * 2000, metaitem('ingotNaquadahAlloy') * 10])
+
+// Replace/Add Decomposition by Material Stack
+replaceDecomposition(materialstack('redstone'), [material('nomilabs:lead_metasilicate') * 2, materialstack('pyrite') * 6, materialstack('ruby') * 2, materialstack('mercury') * 4])
+
+// Replace/Add Decomposition by Item Stack
+replaceDecomposition(metaitem('ingotEnrichedNaquadahTriniumEuropiumDuranide'), [metaitem('ingotTrinaquadalloy')])
+
+// Replace/Add Decomposition by Fluid Stack
+replaceDecomposition(fluid('hexafluorosilicic_acid'), [metaitem('item_collector.hv'), item('minecraft:bucket')])
+
+// Remove Decomposition by Material
+removeDecomposition(material('osmiridium'))
+
+// Remove Decomposition by Material Stack
+removeDecomposition(materialstack('red_alloy') * 10)
+
+// Remove Decomposition by Item Stack
+removeDecomposition(metaitem('ingotTrinaquadalloy'))
+
+// Remove Decomposition by Fluid Stack
+removeDecomposition(fluid('dioxygen_difluoride'))

src/main/java/com/nomiceu/nomilabs/config/LabsConfig.java

@@ -165,6 +165,11 @@ public static class ModIntegration {
         @Config.RequiresMcRestart
         public boolean enableAdvancedRocketryIntegration = true;
 
+        @Config.Comment({"Whether to enable GroovyScript Hand Additions.",
+                "[default: true]"})
+        @Config.LangKey("config.nomilabs.mod_integration.groovy_hand")
+        public boolean enableGroovyHandAdditions = true;
+
         public static class DraconicEvolutionIntegration {
             @Config.Comment({"Whether to enable Draconic Evolution Integration, which adds many features, such as:",
                     "Allowing GregTech Draconium and Awakened Draconium in the reactor and energy core.",

src/main/java/com/nomiceu/nomilabs/event/CommonProxy.java

@@ -1,19 +1,21 @@
 package com.nomiceu.nomilabs.event;
 
+import com.cleanroommc.groovyscript.event.GsHandEvent;
 import com.nomiceu.nomilabs.LabsValues;
 import com.nomiceu.nomilabs.block.registry.LabsBlocks;
-import com.nomiceu.nomilabs.fluid.FluidRegistryMixinHelper;
-import com.nomiceu.nomilabs.gregtech.LabsSounds;
-import com.nomiceu.nomilabs.gregtech.block.registry.LabsMetaBlocks;
 import com.nomiceu.nomilabs.config.LabsConfig;
 import com.nomiceu.nomilabs.creativetab.registry.LabsCreativeTabs;
+import com.nomiceu.nomilabs.fluid.FluidRegistryMixinHelper;
 import com.nomiceu.nomilabs.fluid.registry.LabsFluids;
 import com.nomiceu.nomilabs.gregtech.LabsRecipeMaps;
+import com.nomiceu.nomilabs.gregtech.LabsSounds;
+import com.nomiceu.nomilabs.gregtech.block.registry.LabsMetaBlocks;
 import com.nomiceu.nomilabs.gregtech.material.registry.LabsMaterials;
 import com.nomiceu.nomilabs.gregtech.multiblock.registry.LabsMultiblocks;
 import com.nomiceu.nomilabs.gregtech.prefix.LabsMaterialFlags;
 import com.nomiceu.nomilabs.gregtech.prefix.LabsOrePrefix;
 import com.nomiceu.nomilabs.gregtech.recipe.PerfectGemsCutterRecipes;
+import com.nomiceu.nomilabs.groovy.GroovyScriptHandManager;
 import com.nomiceu.nomilabs.integration.top.TOPTooltipManager;
 import com.nomiceu.nomilabs.item.registry.LabsItems;
 import com.nomiceu.nomilabs.recipe.HandFramingRecipe;
@@ -145,4 +147,9 @@ public static void missingEntityMappings(MissingMappings<EntityEntry> event) {
     public static void missingBiomeMappings(MissingMappings<Biome> event) {
         LabsRemappers.remapAndIgnoreEntries(event, Remapper.RemapTypes.BIOME);
     }
+
+    @SubscribeEvent(priority = EventPriority.LOW)
+    public static void gsHandAdditions(GsHandEvent event) {
+        GroovyScriptHandManager.addToHand(event);
+    }
 }

src/main/java/com/nomiceu/nomilabs/gregtech/AccessibleMaterial.java

@@ -0,0 +1,9 @@
+package com.nomiceu.nomilabs.gregtech;
+
+import gregtech.api.unification.stack.MaterialStack;
+
+import java.util.List;
+
+public interface AccessibleMaterial {
+    void setComponents(List<MaterialStack> components);
+}

src/main/java/com/nomiceu/nomilabs/groovy/GroovyHelpers.java

@@ -1,13 +1,19 @@
 package com.nomiceu.nomilabs.groovy;
 
+import com.cleanroommc.groovyscript.GroovyScript;
+import com.cleanroommc.groovyscript.api.GroovyLog;
 import com.cleanroommc.groovyscript.api.IIngredient;
 import com.cleanroommc.groovyscript.compat.mods.ModSupport;
 import com.cleanroommc.groovyscript.compat.mods.jei.JeiPlugin;
 import com.cleanroommc.groovyscript.helper.ingredient.IngredientHelper;
 import com.cleanroommc.groovyscript.sandbox.ClosureHelper;
 import com.nomiceu.nomilabs.integration.jei.JEIPlugin;
 import com.nomiceu.nomilabs.util.LabsTranslate;
+import gregtech.api.GregTechAPI;
+import gregtech.api.unification.OreDictUnifier;
 import gregtech.api.unification.material.Material;
+import gregtech.api.unification.material.properties.PropertyKey;
+import gregtech.api.unification.stack.MaterialStack;
 import gregtech.api.util.GTUtility;
 import gregtech.client.utils.TooltipHelper;
 import groovy.lang.Closure;
@@ -17,7 +23,11 @@
 import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fluids.FluidStack;
 
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * The interface for groovy to interact with.
@@ -91,24 +101,201 @@ private static FluidStack toFluidStack(Fluid fluid) {
             return new FluidStack(fluid, 1);
         }
     }
-    public static class RecipeRecyclingHelpers extends ReplaceRecipe {
+    public static class RecipeRecyclingHelpers {
         public static void replaceRecipeShaped(String name, ItemStack output, List<List<IIngredient>> inputs) {
             if (name.contains(":"))
                 replaceRecipeShaped(new ResourceLocation(name), output, inputs);
             else
                 replaceRecipeShaped(GTUtility.gregtechId(name), output, inputs);
         }
+
+        public static void replaceRecipeShaped(ResourceLocation name, ItemStack output, List<List<IIngredient>> inputs) {
+            ReplaceRecipe.replaceRecipeShaped(name, output, inputs);
+        }
+
+        public static void replaceRecipeShaped(ItemStack oldOutput, ItemStack newOutput, List<List<IIngredient>> inputs) {
+            ReplaceRecipe.replaceRecipeShaped(oldOutput, newOutput,inputs);
+        }
+
         public static void replaceRecipeOutput(String name, ItemStack output) {
             if (name.contains(":"))
                 replaceRecipeOutput(new ResourceLocation(name), output);
             else
                 replaceRecipeOutput(GTUtility.gregtechId(name), output);
         }
+
+        public static void replaceRecipeOutput(ResourceLocation name, ItemStack newOutput) {
+            ReplaceRecipe.replaceRecipeOutput(name, newOutput);
+        }
+
+        public static void replaceRecipeOutput(ItemStack oldOutput, ItemStack newOutput) {
+            ReplaceRecipe.replaceRecipeOutput(oldOutput, newOutput);
+        }
+
         public static void replaceRecipeInput(String name, List<List<IIngredient>> inputs) {
             if (name.contains(":"))
                 replaceRecipeInput(new ResourceLocation(name), inputs);
             else
                 replaceRecipeInput(GTUtility.gregtechId(name), inputs);
         }
+
+        public static void replaceRecipeInput(ResourceLocation name, List<List<IIngredient>> newInputs) {
+            ReplaceRecipe.replaceRecipeInput(name, newInputs);
+        }
+
+        public static void replaceRecipeInput(ItemStack oldOutput, List<List<IIngredient>> newInputs) {
+            ReplaceRecipe.replaceRecipeInput(oldOutput, newInputs);
+        }
+
+        public static void createRecipe(String name, ItemStack output, List<List<IIngredient>> input) {
+            ReplaceRecipe.createRecipe(name, output, input);
+        }
+
+        public static void createRecipe(ItemStack output, List<List<IIngredient>> input) {
+            ReplaceRecipe.createRecipe(output, input);
+        }
+
+        public static void changeStackRecycling(ItemStack output, List<IIngredient> ingredients) {
+            ReplaceRecipe.changeStackRecycling(output, ingredients);
+        }
+        public static void removeStackRecycling(ItemStack output) {
+            ReplaceRecipe.changeStackRecycling(output, Collections.emptyList());
+        }
+    }
+    public static class ReplaceDecompositionHelpers {
+        public static void replaceDecomposition(Material material, List<IIngredient> components) {
+            ReplaceDecomposition.replaceDecomposition(material, getMatFromIIngredient(components));
+        }
+
+        public static void replaceDecomposition(MaterialStack material, List<IIngredient> components) {
+            ReplaceDecomposition.replaceDecomposition(material.material, getMatFromIIngredient(components));
+        }
+
+        public static void replaceDecomposition(ItemStack stack, List<IIngredient> components) {
+            MaterialStack mat = getMatFromStack(stack);
+            if (mat == null) return;
+
+            ReplaceDecomposition.replaceDecomposition(mat.material, getMatFromIIngredient(components));
+        }
+
+        public static void replaceDecomposition(FluidStack stack, List<IIngredient> components) {
+            Material mat = getMaterialFromFluid(stack);
+            if (mat == null) return;
+
+            ReplaceDecomposition.replaceDecomposition(mat, getMatFromIIngredient(components));
+        }
+
+        public static void removeDecomposition(Material material) {
+            ReplaceDecomposition.replaceDecomposition(material, Collections.emptyList());
+        }
+
+        public static void removeDecomposition(MaterialStack material) {
+            ReplaceDecomposition.replaceDecomposition(material.material, Collections.emptyList());
+        }
+
+        public static void removeDecomposition(ItemStack stack) {
+            MaterialStack mat = getMatFromStack(stack);
+            if (mat == null) return;
+
+            ReplaceDecomposition.replaceDecomposition(mat.material, Collections.emptyList());
+        }
+
+        public static void removeDecomposition(FluidStack stack) {
+            Material mat = getMaterialFromFluid(stack);
+            if (mat == null) return;
+
+            ReplaceDecomposition.replaceDecomposition(mat, Collections.emptyList());
+        }
+
+        /* Helpers */
+        public static List<MaterialStack> getMatFromIIngredient(List<IIngredient> ingredients) {
+            List<MaterialStack> result = new ArrayList<>();
+            for (var ingredient : ingredients) {
+                //noinspection ConstantValue
+                if ((Object) ingredient instanceof ItemStack stack) {
+                    var mat = getMatFromStack(stack);
+                    result.add(mat);
+                    continue;
+                }
+                if ((Object) ingredient instanceof MaterialStack stack) {
+                    result.add(stack);
+                    continue;
+                }
+                if ((Object) ingredient instanceof FluidStack stack) {
+                    result.add(getMatFromFluid(stack));
+                    continue;
+                }
+                IllegalArgumentException e = new IllegalArgumentException("Component Specification must be an Item Stack, a Material Stack, or a Fluid Stack!");
+
+                if (!GroovyScript.getSandbox().isRunning()) throw e;
+
+                GroovyLog.get().exception(e);
+                result.add(null);
+            }
+            if (result.stream().anyMatch(Objects::isNull)) return null;
+            return result;
+        }
+
+        @Nullable
+        private static MaterialStack getMatFromStack(ItemStack stack) {
+            MaterialStack material = OreDictUnifier.getMaterial(stack);
+            if (material == null) {
+                IllegalArgumentException e = new IllegalArgumentException(
+                        String.format("Could not find Material for Stack %s @ %s, with %s.",
+                                stack.getItem().getRegistryName(), stack.getMetadata(),
+                                stack.hasTagCompound() ? "Tag " + stack.getTagCompound() : "No Tag"));
+
+                if (!GroovyScript.getSandbox().isRunning()) throw e;
+
+                GroovyLog.get().exception(e);
+                return null;
+            }
+            return material.copy(stack.getCount());
+        }
+
+        @Nullable
+        private static MaterialStack getMatFromFluid(FluidStack fluid) {
+            // Material Getting needs modid, which we don't have
+            // Recursive through all registries to find it
+            Material mat = getMaterialFromFluid(fluid);
+            if (mat == null) return null;
+
+            if (fluid.amount % 1000 != 0 || fluid.amount < 1000) {
+                IllegalArgumentException e = new IllegalArgumentException("Fluid Amount must be divisible by 1000, and be at least 1000!");
+
+                if (!GroovyScript.getSandbox().isRunning()) throw e;
+
+                GroovyLog.get().exception(e);
+                return null;
+            }
+            return new MaterialStack(mat, fluid.amount / 1000);
+        }
+
+        @Nullable
+        private static Material getMaterialFromFluid(FluidStack fluid) {
+            // Material Getting needs modid, which we don't have
+            // Recursive through all registries to find it
+            var name = fluid.getFluid().getName();
+            Material mat = null;
+            for (var registry : GregTechAPI.materialManager.getRegistries()) {
+                if (!registry.containsKey(name)) continue;
+
+                var foundMat = registry.getObject(name);
+                if (foundMat == null || !foundMat.hasProperty(PropertyKey.FLUID)) continue;
+
+                mat = foundMat;
+                break;
+            }
+            if (mat == null) {
+                IllegalArgumentException e = new IllegalArgumentException(
+                        String.format("Could not find Material for Fluid %s!", fluid.getFluid().getName()));
+
+                if (!GroovyScript.getSandbox().isRunning()) throw e;
+
+                GroovyLog.get().exception(e);
+                return null;
+            }
+            return mat;
+        }
     }
 }