obliterate RA1 (#2206)

* obliterate RA1 (1/2)

* fix wrong recipe map

* guard clauses

* null check

* spotless apply

* redo null check properly

* update BS

---------

Co-authored-by: chochem <40274384+chochem@users.noreply.github.com>

14 files changed, 522 insertions, 342 deletions

diff --git a/src/main/java/gregtech/api/util/GT_ModHandler.java b/src/main/java/gregtech/api/util/GT_ModHandler.java
index f6362a3db7..f6398bf99c 100644
--- a/src/main/java/gregtech/api/util/GT_ModHandler.java
+++ b/src/main/java/gregtech/api/util/GT_ModHandler.java
@@ -10,6 +10,9 @@ import static gregtech.api.enums.GT_Values.RA;
 import static gregtech.api.enums.GT_Values.V;
 import static gregtech.api.enums.GT_Values.W;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sAlloySmelterRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sExtractorRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sOreWasherRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 import static gregtech.api.util.GT_RecipeBuilder.TICKS;
 
 import java.util.ArrayList;
@@ -578,6 +581,7 @@ public class GT_ModHandler {
     /**
      * LiquidTransposer Recipe for both directions
      */
+    @Deprecated
     public static boolean addLiquidTransposerRecipe(ItemStack aEmptyContainer, FluidStack aLiquid,
         ItemStack aFullContainer, int aMJ) {
         return true;
@@ -586,6 +590,7 @@ public class GT_ModHandler {
     /**
      * LiquidTransposer Recipe for filling Containers
      */
+    @Deprecated
     public static boolean addLiquidTransposerFillRecipe(ItemStack aEmptyContainer, FluidStack aLiquid,
         ItemStack aFullContainer, int aMJ) {
         return true;
@@ -594,6 +599,7 @@ public class GT_ModHandler {
     /**
      * LiquidTransposer Recipe for emptying Containers
      */
+    @Deprecated
     public static boolean addLiquidTransposerEmptyRecipe(ItemStack aFullContainer, FluidStack aLiquid,
         ItemStack aEmptyContainer, int aMJ) {
         return true;
@@ -602,11 +608,19 @@ public class GT_ModHandler {
     /**
      * IC2-Extractor Recipe. Overloads old Recipes automatically
      */
+    @Deprecated
     public static boolean addExtractionRecipe(ItemStack aInput, ItemStack aOutput) {
         aOutput = GT_OreDictUnificator.get(true, aOutput);
         if (aInput == null || aOutput == null) return false;
         if (!GregTech_API.sRecipeFile.get(ConfigCategories.Machines.extractor, aInput, true)) return false;
-        RA.addExtractorRecipe(aInput, aOutput, 300, 2);
+        RA.stdBuilder()
+            .itemInputs(aInput)
+            .itemOutputs(aOutput)
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(15 * SECONDS)
+            .eut(2)
+            .addTo(sExtractorRecipes);
         return true;
     }
 
@@ -689,11 +703,13 @@ public class GT_ModHandler {
         return true;
     }
 
+    @Deprecated
     public static boolean addImmersiveEngineeringRecipe(ItemStack aInput, ItemStack aOutput1, ItemStack aOutput2,
         int aChance2, ItemStack aOutput3, int aChance3) {
         return true;
     }
 
+    @Deprecated
     public static boolean addMagneticraftRecipe(ItemStack aInput, ItemStack aOutput1, ItemStack aOutput2, int aChance2,
         ItemStack aOutput3, int aChance3) {
         return true;
@@ -702,6 +718,7 @@ public class GT_ModHandler {
     /**
      * Adds a Recipe to the Sawmills of ThermalCraft
      */
+    @Deprecated
     public static boolean addSawmillRecipe(ItemStack aInput1, ItemStack aOutput1, ItemStack aOutput2) {
         return true;
     }
@@ -709,11 +726,20 @@ public class GT_ModHandler {
     /**
      * Induction Smelter Recipes and Alloy Smelter Recipes
      */
+    @Deprecated
     public static boolean addAlloySmelterRecipe(ItemStack aInput1, ItemStack aInput2, ItemStack aOutput1, int aDuration,
         int aEUt, boolean aAllowSecondaryInputEmpty) {
         if (aInput1 == null || (aInput2 == null && !aAllowSecondaryInputEmpty) || aOutput1 == null) return false;
         aOutput1 = GT_OreDictUnificator.get(true, aOutput1);
-        return RA.addAlloySmelterRecipe(aInput1, aInput2, aOutput1, aDuration, aEUt);
+        RA.stdBuilder()
+            .itemInputs(aInput1, aInput2)
+            .itemOutputs(aOutput1)
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(aDuration)
+            .eut(aEUt)
+            .addTo(sAlloySmelterRecipes);
+        return true;
     }
 
     /**
@@ -743,61 +769,67 @@ public class GT_ModHandler {
         boolean aExcludeGTIC2Items) {
         Map<ItemStack, ItemStack> aRecipesToRemove = new HashMap<>();
         for (Entry<IRecipeInput, RecipeOutput> iRecipeInputRecipeOutputEntry : aIC2RecipeList.entrySet()) {
-            if (!iRecipeInputRecipeOutputEntry.getValue().items.isEmpty()) {
-                for (ItemStack tStack : (iRecipeInputRecipeOutputEntry.getKey()).getInputs()) {
-                    if (GT_Utility.isStackValid(tStack)) {
-                        if (aAddGTRecipe
-                            && (aGTRecipeMap.findRecipe(null, false, Long.MAX_VALUE, null, tStack) == null)) {
-                            try {
-                                if (aExcludeGTIC2Items && ((tStack.getUnlocalizedName()
-                                    .contains("gt.metaitem.01")
-                                    || tStack.getUnlocalizedName()
-                                        .contains("gt.blockores")
-                                    || tStack.getUnlocalizedName()
-                                        .contains("ic2.itemCrushed")
-                                    || tStack.getUnlocalizedName()
-                                        .contains("ic2.itemPurifiedCrushed"))))
-                                    continue;
-                                switch (aGTRecipeMap.mUnlocalizedName) {
-                                    case "gt.recipe.macerator", "gt.recipe.extractor", "gt.recipe.compressor" -> aGTRecipeMap
-                                        .addRecipe(
-                                            true,
-                                            new ItemStack[] { GT_Utility.copyAmount(
-                                                iRecipeInputRecipeOutputEntry.getKey()
-                                                    .getAmount(),
-                                                tStack) },
-                                            iRecipeInputRecipeOutputEntry.getValue().items.toArray(new ItemStack[0]),
-                                            null,
-                                            null,
-                                            null,
-                                            null,
-                                            300,
-                                            2,
-                                            0);
-                                    case "gt.recipe.thermalcentrifuge" -> aGTRecipeMap.addRecipe(
-                                        true,
-                                        new ItemStack[] { GT_Utility.copyAmount(
-                                            iRecipeInputRecipeOutputEntry.getKey()
-                                                .getAmount(),
-                                            tStack) },
-                                        iRecipeInputRecipeOutputEntry.getValue().items.toArray(new ItemStack[0]),
-                                        null,
-                                        null,
-                                        null,
-                                        null,
-                                        500,
-                                        48,
-                                        0);
-                                }
-                            } catch (Exception e) {
-                                System.err.println(e);
-                            }
+            if (iRecipeInputRecipeOutputEntry.getValue().items.isEmpty()) {
+                continue;
+            }
+
+            for (ItemStack tStack : (iRecipeInputRecipeOutputEntry.getKey()).getInputs()) {
+                if (!GT_Utility.isStackValid(tStack)) {
+                    continue;
+                }
+
+                if (aAddGTRecipe && (aGTRecipeMap.findRecipe(null, false, Long.MAX_VALUE, null, tStack) == null)) {
+                    try {
+                        if (aExcludeGTIC2Items && ((tStack.getUnlocalizedName()
+                            .contains("gt.metaitem.01")
+                            || tStack.getUnlocalizedName()
+                                .contains("gt.blockores")
+                            || tStack.getUnlocalizedName()
+                                .contains("ic2.itemCrushed")
+                            || tStack.getUnlocalizedName()
+                                .contains("ic2.itemPurifiedCrushed"))))
+                            continue;
+                        switch (aGTRecipeMap.mUnlocalizedName) {
+                            case "gt.recipe.macerator", "gt.recipe.extractor", "gt.recipe.compressor" -> aGTRecipeMap
+                                .addRecipe(
+                                    true,
+                                    new ItemStack[] { GT_Utility.copyAmount(
+                                        iRecipeInputRecipeOutputEntry.getKey()
+                                            .getAmount(),
+                                        tStack) },
+                                    iRecipeInputRecipeOutputEntry.getValue().items.toArray(new ItemStack[0]),
+                                    null,
+                                    null,
+                                    null,
+                                    null,
+                                    300,
+                                    2,
+                                    0);
+                            case "gt.recipe.thermalcentrifuge" -> aGTRecipeMap.addRecipe(
+                                true,
+                                new ItemStack[] { GT_Utility.copyAmount(
+                                    iRecipeInputRecipeOutputEntry.getKey()
+                                        .getAmount(),
+                                    tStack) },
+                                iRecipeInputRecipeOutputEntry.getValue().items.toArray(new ItemStack[0]),
+                                null,
+                                null,
+                                null,
+                                null,
+                                500,
+                                48,
+                                0);
                         }
-                        if (aRemoveIC2Recipe)
-                            aRecipesToRemove.put(tStack, iRecipeInputRecipeOutputEntry.getValue().items.get(0));
+                    } catch (Exception e) {
+                        System.err.println(e);
                     }
                 }
+                if (aRemoveIC2Recipe) {
+                    aRecipesToRemove.put(tStack, iRecipeInputRecipeOutputEntry.getValue().items.get(0));
+                }
+
             }
+
         }
         GT_Utility.bulkRemoveSimpleIC2MachineRecipe(aRecipesToRemove, aIC2RecipeList);
     }
@@ -894,46 +926,48 @@ public class GT_ModHandler {
     public static boolean addOreWasherRecipe(ItemStack aInput, int[] aChances, int aWaterAmount, Object... aOutput) {
         if (aInput == null || aOutput == null || aOutput.length == 0 || aOutput[0] == null) return false;
         if (!GregTech_API.sRecipeFile.get(ConfigCategories.Machines.orewashing, aInput, true)) return false;
-        RA.addOreWasherRecipe(
-            aInput,
-            (ItemStack) aOutput[0],
-            (ItemStack) aOutput[1],
-            (ItemStack) aOutput[2],
-            GT_ModHandler.getWater(aWaterAmount),
-            aChances,
-            500,
-            16);
-        RA.addOreWasherRecipe(
-            aInput,
-            (ItemStack) aOutput[0],
-            (ItemStack) aOutput[1],
-            (ItemStack) aOutput[2],
-            GT_ModHandler.getDistilledWater(aWaterAmount / 5),
-            aChances,
-            300,
-            16);
+        RA.stdBuilder()
+            .itemInputs(aInput)
+            .itemOutputs((ItemStack) aOutput[0], (ItemStack) aOutput[1], (ItemStack) aOutput[2])
+            .outputChances(aChances)
+            .fluidInputs(GT_ModHandler.getWater(aWaterAmount))
+            .noFluidOutputs()
+            .duration(25 * SECONDS)
+            .eut(16)
+            .addTo(sOreWasherRecipes);
+
+        RA.stdBuilder()
+            .itemInputs(aInput)
+            .itemOutputs((ItemStack) aOutput[0], (ItemStack) aOutput[1], (ItemStack) aOutput[2])
+            .outputChances(aChances)
+            .fluidInputs(GT_ModHandler.getDistilledWater(aWaterAmount / 5))
+            .noFluidOutputs()
+            .duration(15 * SECONDS)
+            .eut(16)
+            .addTo(sOreWasherRecipes);
         return true;
     }
 
     public static boolean addOreWasherRecipe(ItemStack aInput, int aWaterAmount, Object... aOutput) {
         if (aInput == null || aOutput == null || aOutput.length == 0 || aOutput[0] == null) return false;
         if (!GregTech_API.sRecipeFile.get(ConfigCategories.Machines.orewashing, aInput, true)) return false;
-        RA.addOreWasherRecipe(
-            aInput,
-            (ItemStack) aOutput[0],
-            (ItemStack) aOutput[1],
-            (ItemStack) aOutput[2],
-            GT_ModHandler.getWater(aWaterAmount),
-            500,
-            16);
-        RA.addOreWasherRecipe(
-            aInput,
-            (ItemStack) aOutput[0],
-            (ItemStack) aOutput[1],
-            (ItemStack) aOutput[2],
-            GT_ModHandler.getDistilledWater(aWaterAmount / 5),
-            300,
-            16);
+        RA.stdBuilder()
+            .itemInputs(aInput)
+            .itemOutputs((ItemStack) aOutput[0], (ItemStack) aOutput[1], (ItemStack) aOutput[2])
+            .fluidInputs(GT_ModHandler.getWater(aWaterAmount))
+            .noFluidOutputs()
+            .duration(25 * SECONDS)
+            .eut(16)
+            .addTo(sOreWasherRecipes);
+
+        RA.stdBuilder()
+            .itemInputs(aInput)
+            .itemOutputs((ItemStack) aOutput[0], (ItemStack) aOutput[1], (ItemStack) aOutput[2])
+            .fluidInputs(GT_ModHandler.getDistilledWater(aWaterAmount / 5))
+            .noFluidOutputs()
+            .duration(15 * SECONDS)
+            .eut(16)
+            .addTo(sOreWasherRecipes);
         return true;
     }
 
diff --git a/src/main/java/gregtech/api/util/GT_RecipeRegistrator.java b/src/main/java/gregtech/api/util/GT_RecipeRegistrator.java
index 6afa40e17f..feefa32909 100644
--- a/src/main/java/gregtech/api/util/GT_RecipeRegistrator.java
+++ b/src/main/java/gregtech/api/util/GT_RecipeRegistrator.java
@@ -19,6 +19,7 @@ import static gregtech.api.enums.Materials.Steel;
 import static gregtech.api.enums.Materials.Steeleaf;
 import static gregtech.api.enums.Materials.Thaumium;
 import static gregtech.api.enums.Materials.Void;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sFluidExtractionRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sHammerRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sWiremillRecipes;
@@ -213,24 +214,35 @@ public class GT_RecipeRegistrator {
                 || tData.mPrefix == OrePrefixes.block | tData.mPrefix == OrePrefixes.plate)) {
             tHide = true;
         }
-        RA.addFluidSmelterRecipe(
-            GT_Utility.copyAmount(1, aStack),
-            aByproduct
-                == null
-                    ? null
-                    : aByproduct.mMaterial.contains(SubTag.NO_SMELTING) || !aByproduct.mMaterial.contains(SubTag.METAL)
-                        ? aByproduct.mMaterial.contains(SubTag.FLAMMABLE)
-                            ? GT_OreDictUnificator.getDust(Materials.Ash, aByproduct.mAmount / 2)
-                            : aByproduct.mMaterial.contains(SubTag.UNBURNABLE)
-                                ? GT_OreDictUnificator
-                                    .getDustOrIngot(aByproduct.mMaterial.mSmeltInto, aByproduct.mAmount)
-                                : null
-                        : GT_OreDictUnificator.getIngotOrDust(aByproduct.mMaterial.mSmeltInto, aByproduct.mAmount),
-            aMaterial.mSmeltInto.getMolten((L * aMaterialAmount) / (M * aStack.stackSize)),
-            10000,
-            (int) Math.max(1, (24 * aMaterialAmount) / M),
-            Math.max(8, (int) Math.sqrt(2 * aMaterial.mSmeltInto.mStandardMoltenFluid.getTemperature())),
-            tHide);
+
+        ItemStack recipeOutput = aByproduct == null ? null
+            : aByproduct.mMaterial.contains(SubTag.NO_SMELTING) || !aByproduct.mMaterial.contains(SubTag.METAL)
+                ? aByproduct.mMaterial.contains(SubTag.FLAMMABLE)
+                    ? GT_OreDictUnificator.getDust(Materials.Ash, aByproduct.mAmount / 2)
+                    : aByproduct.mMaterial.contains(SubTag.UNBURNABLE)
+                        ? GT_OreDictUnificator.getDustOrIngot(aByproduct.mMaterial.mSmeltInto, aByproduct.mAmount)
+                        : null
+                : GT_OreDictUnificator.getIngotOrDust(aByproduct.mMaterial.mSmeltInto, aByproduct.mAmount);
+
+        if (recipeOutput != null) {
+            RA.stdBuilder()
+                .itemInputs(GT_Utility.copyAmount(1, aStack))
+                .itemOutputs(recipeOutput)
+                .noFluidInputs()
+                .fluidOutputs(aMaterial.mSmeltInto.getMolten((L * aMaterialAmount) / (M * aStack.stackSize)))
+                .duration((int) Math.max(1, (24 * aMaterialAmount) / M))
+                .eut(Math.max(8, (int) Math.sqrt(2 * aMaterial.mSmeltInto.mStandardMoltenFluid.getTemperature())))
+                .addTo(sFluidExtractionRecipes);
+        } else {
+            RA.stdBuilder()
+                .itemInputs(GT_Utility.copyAmount(1, aStack))
+                .noItemOutputs()
+                .noFluidInputs()
+                .fluidOutputs(aMaterial.mSmeltInto.getMolten((L * aMaterialAmount) / (M * aStack.stackSize)))
+                .duration((int) Math.max(1, (24 * aMaterialAmount) / M))
+                .eut(Math.max(8, (int) Math.sqrt(2 * aMaterial.mSmeltInto.mStandardMoltenFluid.getTemperature())))
+                .addTo(sFluidExtractionRecipes);
+        }
     }
 
     /**
diff --git a/src/main/java/gregtech/common/GT_Proxy.java b/src/main/java/gregtech/common/GT_Proxy.java
index 2da2b883ca..087e450c69 100644
--- a/src/main/java/gregtech/common/GT_Proxy.java
+++ b/src/main/java/gregtech/common/GT_Proxy.java
@@ -31,6 +31,8 @@ import static gregtech.api.enums.Mods.ThaumicBoots;
 import static gregtech.api.enums.Mods.ThaumicTinkerer;
 import static gregtech.api.enums.Mods.TwilightForest;
 import static gregtech.api.enums.Mods.WitchingGadgets;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCrackingRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCutterRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sWiremillRecipes;
 import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 import static gregtech.api.util.GT_RecipeConstants.UniversalChemical;
@@ -2001,12 +2003,15 @@ public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler, IG
                                                             .eut(2)
                                                             .addTo(sWiremillRecipes);
                                                     }
-                                                    GT_Values.RA.addCutterRecipe(
-                                                        new ItemStack(aEvent.Ore.getItem(), 1, 3),
-                                                        new ItemStack(aEvent.Ore.getItem(), 16, 4),
-                                                        null,
-                                                        400,
-                                                        8);
+
+                                                    GT_Values.RA.stdBuilder()
+                                                        .itemInputs(new ItemStack(aEvent.Ore.getItem(), 1, 3))
+                                                        .itemOutputs(new ItemStack(aEvent.Ore.getItem(), 16, 4))
+                                                        .noFluidInputs()
+                                                        .noFluidOutputs()
+                                                        .duration(20 * SECONDS)
+                                                        .eut(8)
+                                                        .addTo(sCutterRecipes);
                                                 }
                                     }
                                     default -> {}
@@ -2577,13 +2582,14 @@ public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler, IG
                 .asFluid();
 
             int hydrogenAmount = 2 * i + 2;
-            GT_Values.RA.addCrackingRecipe(
-                i + 1,
-                new FluidStack(uncrackedFluid, 1000),
-                Materials.Hydrogen.getGas(hydrogenAmount * 800),
-                new FluidStack(crackedFluids[i], 1000),
-                20 + 20 * i,
-                240);
+            GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.getIntegratedCircuit(i + 1))
+                .noItemOutputs()
+                .fluidInputs(new FluidStack(uncrackedFluid, 1000), Materials.Hydrogen.getGas(hydrogenAmount * 800))
+                .fluidOutputs(new FluidStack(crackedFluids[i], 1000))
+                .duration((1 + i) * SECONDS)
+                .eut(240)
+                .addTo(sCrackingRecipes);
 
             GT_Values.RA.stdBuilder()
                 .itemInputs(Materials.Hydrogen.getCells(hydrogenAmount), GT_Utility.getIntegratedCircuit(i + 1))
@@ -2629,13 +2635,14 @@ public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler, IG
                     ItemList.Cell_Empty.get(1L))
                 .asFluid();
 
-            GT_Values.RA.addCrackingRecipe(
-                i + 1,
-                new FluidStack(uncrackedFluid, 1000),
-                GT_ModHandler.getSteam(1000),
-                new FluidStack(crackedFluids[i], 1200),
-                20 + 20 * i,
-                240);
+            GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.getIntegratedCircuit(i + 1))
+                .noItemOutputs()
+                .fluidInputs(new FluidStack(uncrackedFluid, 1000), GT_ModHandler.getSteam(1000))
+                .fluidOutputs(new FluidStack(crackedFluids[i], 1200))
+                .duration((1 + i) * SECONDS)
+                .eut(240)
+                .addTo(sCrackingRecipes);
 
             GT_Values.RA.stdBuilder()
                 .itemInputs(GT_ModHandler.getIC2Item("steamCell", 1L), GT_Utility.getIntegratedCircuit(i + 1))
diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java
index b3046616b5..ed9127bf62 100644
--- a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java
+++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java
@@ -9,8 +9,10 @@ import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_WIRELESS_ITEM_DETEC
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_WIRELESS_MAINTENANCE_DETECTOR;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sAssemblerRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCompressorRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
 import static gregtech.api.util.GT_RecipeBuilder.MINUTES;
 import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.WILDCARD;
 
 import net.minecraft.dispenser.IBlockSource;
 import net.minecraft.enchantment.Enchantment;
@@ -2634,63 +2636,106 @@ public class GT_MetaGenerated_Item_02 extends GT_MetaGenerated_Item_X32 {
                 .addTo(sCompressorRecipes);
         }
 
-        GT_ModHandler.addPulverisationRecipe(
-            ItemList.Food_Sliced_Cheese.get(1L),
-            GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Cheese, 1L));
-        GT_ModHandler.addPulverisationRecipe(
-            ItemList.Dye_Cocoa.get(1L),
-            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cocoa, 1L));
-        GT_ModHandler.addPulverisationRecipe(
-            ItemList.Crop_Drop_Tine.get(1L),
-            GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Wood, 2L));
-        GT_ModHandler.addPulverisationRecipe(
-            new ItemStack(Blocks.melon_block, 1, 0),
-            new ItemStack(Items.melon, 8, 0),
-            new ItemStack(Items.melon_seeds, 1),
-            80,
-            false);
-        GT_ModHandler.addPulverisationRecipe(
-            new ItemStack(Blocks.pumpkin, 1, 0),
-            new ItemStack(Items.pumpkin_seeds, 4, 0),
-            null,
-            0,
-            false);
-        GT_ModHandler.addPulverisationRecipe(
-            new ItemStack(Items.melon, 1, 0),
-            new ItemStack(Items.melon_seeds, 1, 0),
-            null,
-            0,
-            false);
-        GT_ModHandler.addPulverisationRecipe(
-            new ItemStack(Items.wheat, 1, 0),
-            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wheat, 1L),
-            null,
-            0,
-            false);
-        GT_ModHandler.addPulverisationRecipe(
-            GT_ModHandler.getIC2Item("crop", 1L),
-            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L),
-            null,
-            0,
-            false);
-        GT_ModHandler.addPulverisationRecipe(
-            new ItemStack(Items.stick, 1),
-            GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Wood, 2L),
-            null,
-            0,
-            false);
-        GT_ModHandler.addPulverisationRecipe(
-            new ItemStack(Blocks.wool, 1, 32767),
-            new ItemStack(Items.string, 2),
-            new ItemStack(Items.string, 1),
-            50,
-            false);
-        GT_ModHandler.addPulverisationRecipe(
-            ItemList.Tesseract.get(1),
-            new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.TranscendentMetal, 8L) },
-            new int[] { 10000 },
-            32_000_000,
-            100);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Food_Sliced_Cheese.get(1L))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Cheese, 1L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Dye_Cocoa.get(1L))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cocoa, 1L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Crop_Drop_Tine.get(1L))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Wood, 2L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Blocks.melon_block, 1, 0))
+            .itemOutputs(new ItemStack(Items.melon, 8, 0), new ItemStack(Items.melon_seeds, 1))
+            .outputChances(10000, 8000)
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Blocks.pumpkin, 1, 0))
+            .itemOutputs(new ItemStack(Items.pumpkin_seeds, 4, 0))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Items.melon, 1, 0))
+            .itemOutputs(new ItemStack(Items.melon_seeds, 1, 0))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Items.wheat, 1, 0))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wheat, 1L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_ModHandler.getIC2Item("crop", 1L))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Items.stick, 1))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Wood, 2L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Blocks.wool, 1, WILDCARD))
+            .itemOutputs(new ItemStack(Items.string, 2), new ItemStack(Items.string, 1))
+            .outputChances(10000, 5000)
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Tesseract.get(1))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.TranscendentMetal, 8L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(5 * SECONDS)
+            .eut(32_000_000)
+            .addTo(sMaceratorRecipes);
         try {
             CropCard tCrop;
             GT_Utility.getField(tCrop = Crops.instance.getCropList()[13], "mDrop")
diff --git a/src/main/java/gregtech/loaders/load/GT_ItemIterator.java b/src/main/java/gregtech/loaders/load/GT_ItemIterator.java
index 0e10d2a7de..828b1d330a 100644
--- a/src/main/java/gregtech/loaders/load/GT_ItemIterator.java
+++ b/src/main/java/gregtech/loaders/load/GT_ItemIterator.java
@@ -1,6 +1,7 @@
 package gregtech.loaders.load;
 
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCannerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
 import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 import static gregtech.api.util.GT_RecipeConstants.FUEL_TYPE;
 import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE;
@@ -36,79 +37,91 @@ public class GT_ItemIterator implements Runnable {
     @Override
     public void run() {
         GT_Log.out.println("GT_Mod: Scanning for certain kinds of compatible Machineblocks.");
-        ItemStack tStack2;
-        ItemStack tStack;
-        if (null != (tStack = GT_ModHandler.getRecipeOutput(
-            tStack2 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Bronze, 1L),
-            tStack2,
-            tStack2,
-            tStack2,
-            null,
-            tStack2,
-            tStack2,
-            tStack2,
-            tStack2))) {
-            GT_ModHandler.addPulverisationRecipe(
-                tStack,
-                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bronze, 8L),
-                null,
-                0,
-                false);
+        ItemStack tStack2 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Bronze, 1L);
+        ItemStack tStack = GT_ModHandler
+            .getRecipeOutput(tStack2, tStack2, tStack2, tStack2, null, tStack2, tStack2, tStack2, tStack2);
+
+        if (null != tStack) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(tStack)
+                .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bronze, 8L))
+                .noFluidInputs()
+                .noFluidOutputs()
+                .duration(20 * SECONDS)
+                .eut(2)
+                .addTo(sMaceratorRecipes);
+
             GT_ModHandler.addSmeltingRecipe(tStack, GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Bronze, 8L));
         }
-        if (null != (tStack = GT_ModHandler.getRecipeOutput(
-            tStack2 = GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Bronze, 1L),
-            tStack2,
-            tStack2,
-            tStack2,
-            null,
-            tStack2,
-            tStack2,
-            tStack2,
-            tStack2))) {
+        tStack2 = GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Bronze, 1L);
+        tStack = GT_ModHandler
+            .getRecipeOutput(tStack2, tStack2, tStack2, tStack2, null, tStack2, tStack2, tStack2, tStack2);
+
+        if (null != tStack) {
             GT_OreDictUnificator.registerOre(OreDictNames.craftingRawMachineTier00, tStack);
-            GT_ModHandler.addPulverisationRecipe(
-                tStack,
-                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bronze, 8L),
-                null,
-                0,
-                false);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(tStack)
+                .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bronze, 8L))
+                .noFluidInputs()
+                .noFluidOutputs()
+                .duration(20 * SECONDS)
+                .eut(2)
+                .addTo(sMaceratorRecipes);
             GT_ModHandler.addSmeltingRecipe(tStack, GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Bronze, 8L));
         }
-        ItemStack tStack3;
-        if (null != (tStack = GT_ModHandler.getRecipeOutput(
-            tStack2 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Iron, 1L),
-            tStack3 = new ItemStack(Blocks.glass, 1, 0),
+
+        ItemStack tStack3 = new ItemStack(Blocks.glass, 1, 0);
+        tStack2 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Iron, 1L);
+        tStack = GT_ModHandler.getRecipeOutput(
+            tStack2,
+            tStack3,
             tStack2,
             tStack3,
             GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Gold, 1L),
             tStack3,
             tStack2,
             tStack3,
-            tStack2))) {
-            GT_ModHandler.addPulverisationRecipe(
-                tStack,
-                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Iron, 4L),
-                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Gold, 1L),
-                0,
-                false);
+            tStack2);
+
+        if (null != (tStack)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(tStack)
+                .itemOutputs(
+                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Iron, 4L),
+                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Gold, 1L))
+                .outputChances(10000, 1000)
+                .noFluidInputs()
+                .noFluidOutputs()
+                .duration(20 * SECONDS)
+                .eut(2)
+                .addTo(sMaceratorRecipes);
         }
-        if (null != (tStack = GT_ModHandler.getRecipeOutput(
-            tStack2 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 1L),
-            tStack3 = new ItemStack(Blocks.glass, 1, 0),
+
+        tStack2 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 1L);
+        tStack3 = new ItemStack(Blocks.glass, 1, 0);
+        tStack = GT_ModHandler.getRecipeOutput(
+            tStack2,
+            tStack3,
             tStack2,
             tStack3,
             GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Gold, 1L),
             tStack3,
             tStack2,
             tStack3,
-            tStack2))) {
-            GT_ModHandler.addPulverisationRecipe(
-                tStack,
-                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Steel, 4L),
-                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Gold, 1L),
-                0,
-                false);
+            tStack2);
+        if (null != tStack) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(tStack)
+                .itemOutputs(
+                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Steel, 4L),
+                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Gold, 1L))
+                .outputChances(10000, 1000)
+                .noFluidInputs()
+                .noFluidOutputs()
+                .duration(20 * SECONDS)
+                .eut(2)
+                .addTo(sMaceratorRecipes);
         }
         GT_Log.out.println("GT_Mod: Registering various Tools to be usable on GregTech Machines");
         GregTech_API.registerScrewdriver(
@@ -247,15 +260,21 @@ public class GT_ItemIterator implements Runnable {
                                 .addTo(GT_RecipeConstants.Fuel);
                         }
                         if (tName.equals("tile.TFRoots")) {
-                            GT_ModHandler.addPulverisationRecipe(
-                                new ItemStack(tItem, 1, 0),
-                                new ItemStack(Items.stick, 2),
-                                new ItemStack(Items.stick, 1),
-                                30);
+                            GT_Values.RA.stdBuilder()
+                                .itemInputs(new ItemStack(tItem, 1, 0))
+                                .itemOutputs(new ItemStack(Items.stick, 2), new ItemStack(Items.stick, 1))
+                                .outputChances(10000, 3000)
+                                .noFluidInputs()
+                                .noFluidOutputs()
+                                .duration(20 * SECONDS)
+                                .eut(2)
+                                .addTo(sMaceratorRecipes);
+
                             GT_ModHandler.addSawmillRecipe(
                                 new ItemStack(tItem, 1, 0),
                                 new ItemStack(Items.stick, 4),
                                 new ItemStack(Items.stick, 2));
+
                             GT_Values.RA.stdBuilder()
                                 .itemInputs(new ItemStack(tItem, 1, 1))
                                 .itemOutputs(new ItemStack(Items.stick, 4))
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java
index 9e57768273..ce14d1b180 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java
@@ -1,10 +1,13 @@
 package gregtech.loaders.oreprocessing;
 
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+
 import net.minecraft.item.ItemStack;
 
+import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.OrePrefixes;
-import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_OreDictUnificator;
 import gregtech.api.util.GT_Utility;
 
@@ -17,8 +20,15 @@ public class ProcessingBeans implements gregtech.api.interfaces.IOreRecipeRegist
     @Override
     public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName,
         ItemStack aStack) {
-        if (aOreDictName.equals("beansCocoa")) GT_ModHandler.addPulverisationRecipe(
-            GT_Utility.copyAmount(1L, aStack),
-            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cocoa, 1L));
+        if (aOreDictName.equals("beansCocoa")) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cocoa, 1L))
+                .noFluidInputs()
+                .noFluidOutputs()
+                .duration(20 * SECONDS)
+                .eut(2)
+                .addTo(sMaceratorRecipes);
+        }
     }
 }
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedOre.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedOre.java
index 2b519a48a9..5f16a07830 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedOre.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedOre.java
@@ -1,6 +1,7 @@
 package gregtech.loaders.oreprocessing;
 
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sHammerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sSifterRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes;
 import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
@@ -11,7 +12,6 @@ import net.minecraft.item.ItemStack;
 import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.OrePrefixes;
-import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_OreDictUnificator;
 import gregtech.api.util.GT_Utility;
 
@@ -34,15 +34,20 @@ public class ProcessingCrushedOre implements gregtech.api.interfaces.IOreRecipeR
                     .eut(16)
                     .addTo(sHammerRecipes);
 
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L),
-                    GT_OreDictUnificator.get(
-                        OrePrefixes.dust,
-                        GT_Utility.selectItemInList(2, aMaterial.mMacerateInto, aMaterial.mOreByProducts),
-                        1L),
-                    10,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L),
+                        GT_OreDictUnificator.get(
+                            OrePrefixes.dust,
+                            GT_Utility.selectItemInList(2, aMaterial.mMacerateInto, aMaterial.mOreByProducts),
+                            1L))
+                    .outputChances(10000, 1000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
             }
             case crushedPurified -> {
                 GT_Values.RA.stdBuilder()
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java
index 7daf83504a..868b9c2451 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java
@@ -1,6 +1,8 @@
 package gregtech.loaders.oreprocessing;
 
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sHammerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 import static gregtech.api.util.GT_RecipeBuilder.TICKS;
 
 import net.minecraft.item.ItemStack;
@@ -8,7 +10,6 @@ import net.minecraft.item.ItemStack;
 import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.OrePrefixes;
-import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_OreDictUnificator;
 import gregtech.api.util.GT_Utility;
 
@@ -32,12 +33,14 @@ public class ProcessingCrystallized implements gregtech.api.interfaces.IOreRecip
                 .eut(16)
                 .addTo(sHammerRecipes);
 
-            GT_ModHandler.addPulverisationRecipe(
-                GT_Utility.copyAmount(1L, aStack),
-                GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L),
-                null,
-                10,
-                false);
+            GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L))
+                .noFluidInputs()
+                .noFluidOutputs()
+                .duration(20 * SECONDS)
+                .eut(2)
+                .addTo(sMaceratorRecipes);
         }
     }
 }
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java
index 3ca8180f6e..20eac3ec1c 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java
@@ -2,6 +2,7 @@ package gregtech.loaders.oreprocessing;
 
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sChemicalBathRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sHammerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes;
 import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 
@@ -34,19 +35,25 @@ public class ProcessingDirty implements gregtech.api.interfaces.IOreRecipeRegist
             .eut(16)
             .addTo(sHammerRecipes);
 
-        GT_ModHandler.addPulverisationRecipe(
-            GT_Utility.copyAmount(1L, aStack),
-            GT_OreDictUnificator.get(
-                OrePrefixes.dustImpure,
-                aMaterial.mMacerateInto,
-                GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L),
-                1L),
-            GT_OreDictUnificator.get(
-                OrePrefixes.dust,
-                GT_Utility.selectItemInList(0, aMaterial.mMacerateInto, aMaterial.mOreByProducts),
-                1L),
-            10,
-            false);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.copyAmount(1L, aStack))
+            .itemOutputs(
+                GT_OreDictUnificator.get(
+                    OrePrefixes.dustImpure,
+                    aMaterial.mMacerateInto,
+                    GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L),
+                    1L),
+                GT_OreDictUnificator.get(
+                    OrePrefixes.dust,
+                    GT_Utility.selectItemInList(0, aMaterial.mMacerateInto, aMaterial.mOreByProducts),
+                    1L))
+            .outputChances(10000, 1000)
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
         GT_ModHandler.addOreWasherRecipe(
             GT_Utility.copyAmount(1L, aStack),
             new int[] { 10000, 1111, 10000 },
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java
index 42bad3325d..b17ac6d071 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java
@@ -3,6 +3,7 @@ package gregtech.loaders.oreprocessing;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sBlastRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sHammerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
 import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT;
 
@@ -206,23 +207,28 @@ public class ProcessingOre implements gregtech.api.interfaces.IOreRecipeRegistra
                 .eut(16)
                 .addTo(sHammerRecipes);
 
-            GT_ModHandler.addPulverisationRecipe(
-                aOreStack,
-                GT_Utility.mul(2L, tCrushed),
-                tMaterial.contains(SubTag.PULVERIZING_CINNABAR)
-                    ? GT_OreDictUnificator.get(
+            int chanceOre2 = tPrimaryByProduct == null ? 0
+                : tPrimaryByProduct.stackSize * 10 * aMultiplier * aMaterial.mByProductMultiplier;
+            chanceOre2 = 100 * chanceOre2; // converting to the GT format, 100% is 10000
+            GT_Values.RA.stdBuilder()
+                .itemInputs(aOreStack)
+                .itemOutputs(
+                    GT_Utility.mul(2L, tCrushed),
+                    tMaterial.contains(SubTag.PULVERIZING_CINNABAR) ? GT_OreDictUnificator.get(
                         OrePrefixes.crystal,
                         Materials.Cinnabar,
                         GT_OreDictUnificator
                             .get(OrePrefixes.gem, tPrimaryByMaterial, GT_Utility.copyAmount(1L, tPrimaryByProduct), 1L),
                         1L)
-                    : GT_OreDictUnificator
-                        .get(OrePrefixes.gem, tPrimaryByMaterial, GT_Utility.copyAmount(1L, tPrimaryByProduct), 1L),
-                tPrimaryByProduct == null ? 0
-                    : tPrimaryByProduct.stackSize * 10 * aMultiplier * aMaterial.mByProductMultiplier,
-                GT_OreDictUnificator.getDust(aPrefix.mSecondaryMaterial),
-                50,
-                true);
+                        : GT_OreDictUnificator
+                            .get(OrePrefixes.gem, tPrimaryByMaterial, GT_Utility.copyAmount(1L, tPrimaryByProduct), 1L),
+                    GT_OreDictUnificator.getDust(aPrefix.mSecondaryMaterial))
+                .outputChances(10000, chanceOre2, 5000)
+                .noFluidInputs()
+                .noFluidOutputs()
+                .duration(20 * SECONDS)
+                .eut(2)
+                .addTo(sMaceratorRecipes);
         }
         return true;
     }
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java
index 6c43ceb135..a365c09f51 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java
@@ -1,6 +1,8 @@
 package gregtech.loaders.oreprocessing;
 
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sHammerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 
 import net.minecraft.item.ItemStack;
 
@@ -48,15 +50,22 @@ public class ProcessingOrePoor implements gregtech.api.interfaces.IOreRecipeRegi
                 .eut(16)
                 .addTo(sHammerRecipes);
 
-            GT_ModHandler.addPulverisationRecipe(
-                GT_Utility.copyAmount(1L, aStack),
-                GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 2 * aMultiplier),
-                GT_OreDictUnificator
-                    .get(OrePrefixes.dustTiny, GT_Utility.selectItemInList(0, aMaterial, aMaterial.mOreByProducts), 1L),
-                5 * aMultiplier,
-                GT_OreDictUnificator.getDust(aPrefix.mSecondaryMaterial),
-                100,
-                true);
+            GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                .itemOutputs(
+                    GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 2 * aMultiplier),
+                    GT_OreDictUnificator.get(
+                        OrePrefixes.dustTiny,
+                        GT_Utility.selectItemInList(0, aMaterial, aMaterial.mOreByProducts),
+                        1L),
+                    GT_OreDictUnificator.getDust(aPrefix.mSecondaryMaterial))
+                .outputChances(10000, 100 * 5 * aMultiplier, 10000)
+                .noFluidInputs()
+                .noFluidOutputs()
+                .duration(20 * SECONDS)
+                .eut(2)
+                .addTo(sMaceratorRecipes);
+
             if (aMaterial.contains(SubTag.NO_SMELTING)) GT_ModHandler.addSmeltingRecipe(
                 GT_Utility.copyAmount(1L, aStack),
                 GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial.mDirectSmelting, aMultiplier));
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPure.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPure.java
index e4875e15e7..a8dae7f284 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPure.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPure.java
@@ -1,13 +1,14 @@
 package gregtech.loaders.oreprocessing;
 
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sHammerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 
 import net.minecraft.item.ItemStack;
 
 import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.OrePrefixes;
-import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_OreDictUnificator;
 import gregtech.api.util.GT_Utility;
 
@@ -29,18 +30,23 @@ public class ProcessingPure implements gregtech.api.interfaces.IOreRecipeRegistr
             .eut(16)
             .addTo(sHammerRecipes);
 
-        GT_ModHandler.addPulverisationRecipe(
-            GT_Utility.copyAmount(1L, aStack),
-            GT_OreDictUnificator.get(
-                OrePrefixes.dustPure,
-                aMaterial.mMacerateInto,
-                GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L),
-                1L),
-            GT_OreDictUnificator.get(
-                OrePrefixes.dust,
-                GT_Utility.selectItemInList(1, aMaterial.mMacerateInto, aMaterial.mOreByProducts),
-                1L),
-            10,
-            false);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.copyAmount(1L, aStack))
+            .itemOutputs(
+                GT_OreDictUnificator.get(
+                    OrePrefixes.dustPure,
+                    aMaterial.mMacerateInto,
+                    GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L),
+                    1L),
+                GT_OreDictUnificator.get(
+                    OrePrefixes.dust,
+                    GT_Utility.selectItemInList(1, aMaterial.mMacerateInto, aMaterial.mOreByProducts),
+                    1L))
+            .outputChances(10000, 1000)
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
     }
 }
diff --git a/src/main/java/gregtech/loaders/postload/chains/GT_BauxiteRefineChain.java b/src/main/java/gregtech/loaders/postload/chains/GT_BauxiteRefineChain.java
index cbb92ee128..d90902d9c0 100644
--- a/src/main/java/gregtech/loaders/postload/chains/GT_BauxiteRefineChain.java
+++ b/src/main/java/gregtech/loaders/postload/chains/GT_BauxiteRefineChain.java
@@ -2,6 +2,7 @@ package gregtech.loaders.postload.chains;
 
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sChemicalBathRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCrackingRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMixerRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes;
 import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
@@ -47,13 +48,14 @@ public class GT_BauxiteRefineChain {
             .eut(TierEU.RECIPE_MV)
             .addTo(sMixerRecipes);
 
-        GT_Values.RA.addCrackingRecipe(
-            1,
-            MaterialsOreAlum.BauxiteSlurry.getFluid(32000),
-            GT_ModHandler.getSteam(2000),
-            MaterialsOreAlum.HeatedBauxiteSlurry.getFluid(32000),
-            160,
-            400);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .noItemOutputs()
+            .fluidInputs(MaterialsOreAlum.BauxiteSlurry.getFluid(32000), GT_ModHandler.getSteam(2000))
+            .fluidOutputs(MaterialsOreAlum.HeatedBauxiteSlurry.getFluid(32000))
+            .duration(8 * SECONDS)
+            .eut(400)
+            .addTo(sCrackingRecipes);
 
         GT_Values.RA.stdBuilder()
             .itemInputs(Materials.Aluminiumhydroxide.getDust(1))
diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java b/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java
index 056ebadca9..9f35cf94d5 100644
--- a/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java
+++ b/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java
@@ -11,9 +11,11 @@ import static gregtech.api.enums.Mods.Thaumcraft;
 import static gregtech.api.enums.Mods.TwilightForest;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sFluidCannerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes;
 import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 import static gregtech.api.util.GT_RecipeBuilder.TICKS;
+import static gregtech.api.util.GT_RecipeBuilder.WILDCARD;
 
 import java.util.Locale;
 
@@ -2070,30 +2072,43 @@ public class GT_Loader_Item_Block_And_Fluid implements Runnable {
                 }
             }
         }
-        GT_ModHandler.addPulverisationRecipe(
-            new ItemStack(Blocks.cobblestone, 1, 32767),
-            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L),
-            null,
-            0,
-            false);
-        GT_ModHandler.addPulverisationRecipe(
-            new ItemStack(Blocks.gravel, 1, 32767),
-            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L),
-            new ItemStack(Items.flint, 1),
-            10,
-            false);
-        GT_ModHandler.addPulverisationRecipe(
-            new ItemStack(Blocks.furnace, 1, 32767),
-            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 8L),
-            null,
-            0,
-            false);
-        GT_ModHandler.addPulverisationRecipe(
-            new ItemStack(Blocks.lit_furnace, 1, 32767),
-            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 8L),
-            null,
-            0,
-            false);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Blocks.cobblestone, 1, WILDCARD))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Blocks.gravel, 1, WILDCARD))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L), new ItemStack(Items.flint, 1))
+            .outputChances(10000, 1000)
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Blocks.furnace, 1, WILDCARD))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 8L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Blocks.lit_furnace, 1, WILDCARD))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 8L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(2)
+            .addTo(sMaceratorRecipes);
 
         GT_OreDictUnificator.set(
             OrePrefixes.ingot,