Convert more recipes to RA2 (#1957)

* convert some MTE recipes to RA2

* Lens RA2

* Rotor RA2

* fixes

* Stone RA2

* Gem RA2

* fix

* ingot RA2

* stick RA2

* better time notation

7 files changed, 638 insertions, 295 deletions

diff --git a/src/main/java/gregtech/loaders/load/GT_Loader_MetaTileEntities_Recipes.java b/src/main/java/gregtech/loaders/load/GT_Loader_MetaTileEntities_Recipes.java
index 87ea45874e..8dac0b7917 100644
--- a/src/main/java/gregtech/loaders/load/GT_Loader_MetaTileEntities_Recipes.java
+++ b/src/main/java/gregtech/loaders/load/GT_Loader_MetaTileEntities_Recipes.java
@@ -1,6 +1,8 @@
 package gregtech.loaders.load;
 
 import static gregtech.api.enums.Mods.*;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sAssemblerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 
 import net.minecraft.init.Blocks;
 import net.minecraft.init.Items;
@@ -7098,16 +7100,20 @@ public class GT_Loader_MetaTileEntities_Recipes implements Runnable {
                 new Object[] { "FFF", "RHR", "MCM", 'H', ItemList.Hull_HV, 'F', ItemList.Component_Filter, 'R',
                     OrePrefixes.rotor.get(Materials.StainlessSteel), 'M', ItemList.Electric_Motor_HV, 'C',
                     OrePrefixes.circuit.get(Materials.Advanced) });
-            GT_Values.RA.addAssemblerRecipe(
-                new ItemStack[] { ItemList.Hull_HV.get(1L), ItemList.Component_Filter.get(2L),
+            GT_Values.RA.stdBuilder()
+                .itemInputs(
+                    ItemList.Hull_HV.get(1L),
+                    ItemList.Component_Filter.get(2L),
                     GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.StainlessSteel, 1L),
                     ItemList.Electric_Motor_HV.get(1L),
                     GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Advanced, 1L),
-                    GT_Utility.getIntegratedCircuit(1) },
-                Materials.StainlessSteel.getMolten(864L),
-                ItemList.Machine_Multi_Cleanroom.get(1L),
-                1200,
-                120);
+                    GT_Utility.getIntegratedCircuit(1))
+                .itemOutputs(ItemList.Machine_Multi_Cleanroom.get(1L))
+                .fluidInputs(Materials.StainlessSteel.getMolten(864L))
+                .noFluidOutputs()
+                .duration(60 * SECONDS)
+                .eut(TierEU.RECIPE_MV)
+                .addTo(sAssemblerRecipes);
         } else {
             if (NotEnoughItems.isModLoaded()) {
                 API.hideItem(ItemList.Machine_Multi_Cleanroom.get(1L));
@@ -7368,27 +7374,39 @@ public class GT_Loader_MetaTileEntities_Recipes implements Runnable {
         }
 
         // high pressure fluid pipes
-        GT_Values.RA.addAssemblerRecipe(
-            new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.pipeSmall, Materials.TungstenSteel, 1L),
-                ItemList.Electric_Pump_EV.get(1L), GT_Utility.getIntegratedCircuit(5) },
-            GT_Values.NF,
-            GT_OreDictUnificator.get(OrePrefixes.pipeSmall, Materials.Ultimate, 1L),
-            300,
-            1920);
-        GT_Values.RA.addAssemblerRecipe(
-            new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.TungstenSteel, 1L),
-                ItemList.Electric_Pump_IV.get(1L), GT_Utility.getIntegratedCircuit(5) },
-            GT_Values.NF,
-            GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Ultimate, 1L),
-            400,
-            4096);
-        GT_Values.RA.addAssemblerRecipe(
-            new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.TungstenSteel, 1L),
-                ItemList.Electric_Pump_IV.get(2L), GT_Utility.getIntegratedCircuit(5) },
-            GT_Values.NF,
-            GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.Ultimate, 1L),
-            600,
-            7680);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.pipeSmall, Materials.TungstenSteel, 1L),
+                ItemList.Electric_Pump_EV.get(1L),
+                GT_Utility.getIntegratedCircuit(5))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeSmall, Materials.Ultimate, 1L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(15 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(sAssemblerRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.TungstenSteel, 1L),
+                ItemList.Electric_Pump_IV.get(1L),
+                GT_Utility.getIntegratedCircuit(5))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Ultimate, 1L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(20 * SECONDS)
+            .eut(4096)
+            .addTo(sAssemblerRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.TungstenSteel, 1L),
+                ItemList.Electric_Pump_IV.get(2L),
+                GT_Utility.getIntegratedCircuit(5))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.Ultimate, 1L))
+            .noFluidInputs()
+            .noFluidOutputs()
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(sAssemblerRecipes);
 
         GT_ModHandler.addCraftingRecipe(
             ItemList.Automation_ChestBuffer_ULV.get(1L),
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java
index 6058abbddd..03ab6b05de 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java
@@ -6,6 +6,7 @@ import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCompressorRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sElectrolyzerRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sHammerRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sLaserEngraverRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sLatheRecipes;
 import static gregtech.api.util.GT_RecipeBuilder.MINUTES;
 import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 import static gregtech.api.util.GT_RecipeBuilder.TICKS;
@@ -183,13 +184,18 @@ public class ProcessingGem implements gregtech.api.interfaces.IOreRecipeRegistra
                 if (aNoWorking) {
                     if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
                         // Lathe recipes
-                        {
-                            GT_Values.RA.addLatheRecipe(
-                                GT_Utility.copyAmount(1L, aStack),
-                                GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L),
-                                GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 2L),
-                                (int) Math.max(aMaterialMass, 1L),
-                                calculateRecipeEU(aMaterial, 16));
+                        if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L) != null
+                            && GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L) != null) {
+                            GT_Values.RA.stdBuilder()
+                                .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                                .itemOutputs(
+                                    GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L),
+                                    GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 2L))
+                                .noFluidInputs()
+                                .noFluidOutputs()
+                                .duration(((int) Math.max(aMaterialMass, 1L)) * TICKS)
+                                .eut(calculateRecipeEU(aMaterial, 16))
+                                .addTo(sLatheRecipes);
                         }
                     }
                 } else {
@@ -287,13 +293,18 @@ public class ProcessingGem implements gregtech.api.interfaces.IOreRecipeRegistra
 
                 if (!aNoWorking) {
                     // Lathe recipes
-                    {
-                        GT_Values.RA.addLatheRecipe(
-                            GT_Utility.copyAmount(1L, aStack),
-                            GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L),
-                            GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 1L),
-                            (int) Math.max(aMaterialMass, 1L),
-                            8);
+                    if (GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L) != null
+                        && GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 1L) != null) {
+                        GT_Values.RA.stdBuilder()
+                            .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                            .itemOutputs(
+                                GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L),
+                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 1L))
+                            .noFluidInputs()
+                            .noFluidOutputs()
+                            .duration(((int) Math.max(aMaterialMass, 1L)) * TICKS)
+                            .eut(8)
+                            .addTo(sLatheRecipes);
                     }
 
                     if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) {
@@ -380,13 +391,18 @@ public class ProcessingGem implements gregtech.api.interfaces.IOreRecipeRegistra
 
                 if (!aNoWorking) {
                     // Lathe recipes
-                    {
-                        GT_Values.RA.addLatheRecipe(
-                            GT_Utility.copyAmount(1L, aStack),
-                            GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 2L),
-                            GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L),
-                            (int) Math.max(aMaterialMass, 1L),
-                            12);
+                    if (GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L) != null
+                        && GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L) != null) {
+                        GT_Values.RA.stdBuilder()
+                            .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                            .itemOutputs(
+                                GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 2L),
+                                GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L))
+                            .noFluidInputs()
+                            .noFluidOutputs()
+                            .duration(((int) Math.max(aMaterialMass, 1L)) * TICKS)
+                            .eut(12)
+                            .addTo(sLatheRecipes);
                     }
 
                     if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) {
@@ -451,14 +467,20 @@ public class ProcessingGem implements gregtech.api.interfaces.IOreRecipeRegistra
 
                 if (!aNoWorking) {
                     // Lathe recipes
-                    {
-                        GT_Values.RA.addLatheRecipe(
-                            GT_Utility.copyAmount(1L, aStack),
-                            GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L),
-                            GT_OreDictUnificator
-                                .getDust(aMaterial, aPrefix.mMaterialAmount - OrePrefixes.stickLong.mMaterialAmount),
-                            (int) Math.max(aMaterialMass * 5L, 1L),
-                            16);
+                    if (GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L) != null
+                        && GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L) != null) {
+                        GT_Values.RA.stdBuilder()
+                            .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                            .itemOutputs(
+                                GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L),
+                                GT_OreDictUnificator.getDust(
+                                    aMaterial,
+                                    aPrefix.mMaterialAmount - OrePrefixes.stickLong.mMaterialAmount))
+                            .noFluidInputs()
+                            .noFluidOutputs()
+                            .duration(((int) Math.max(aMaterialMass * 5L, 1L)) * TICKS)
+                            .eut(16)
+                            .addTo(sLatheRecipes);
                     }
 
                     if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) {
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java
index d65e48b9e9..1caef10cba 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java
@@ -1,7 +1,10 @@
 package gregtech.loaders.oreprocessing;
 
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sBenderRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sFluidSolidficationRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sHammerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
 import static gregtech.api.util.GT_Utility.calculateRecipeEU;
 
 import net.minecraft.item.ItemStack;
@@ -44,15 +47,15 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist
                 if (aMaterial.mStandardMoltenFluid != null
                     && !(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) {
                     // Fluid solidifier recipes
-                    {
-                        GT_Values.RA.addFluidSolidifierRecipe(
-                            ItemList.Shape_Mold_Ingot.get(0L),
-                            aMaterial.getMolten(144L),
-                            GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L),
-                            32,
-                            calculateRecipeEU(aMaterial, 8));
-                    }
 
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(ItemList.Shape_Mold_Ingot.get(0L))
+                        .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L))
+                        .fluidInputs(aMaterial.getMolten(144L))
+                        .noFluidOutputs()
+                        .duration(1 * SECONDS + 12 * TICKS)
+                        .eut(calculateRecipeEU(aMaterial, 8))
+                        .addTo(sFluidSolidficationRecipes);
                 }
             // Reverse recipes
             {
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingLens.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingLens.java
index 3d3b0547d9..f962c98e4f 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingLens.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingLens.java
@@ -1,7 +1,8 @@
 package gregtech.loaders.oreprocessing;
 
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCompressorRecipes;
-import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sLatheRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.MINUTES;
 
 import net.minecraft.item.ItemStack;
 
@@ -26,18 +27,27 @@ public class ProcessingLens implements gregtech.api.interfaces.IOreRecipeRegistr
         ItemStack aStack) {
         switch (aMaterial.mName) {
             case "Diamond", "Glass" -> {
-                GT_Values.RA.addLatheRecipe(
-                    GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L),
-                    1200,
-                    30);
-                GT_Values.RA.addLatheRecipe(
-                    GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 3L),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
-                    2400,
-                    16);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L))
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(1 * MINUTES)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sLatheRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1L))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 3L),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(2 * MINUTES)
+                    .eut(16)
+                    .addTo(sLatheRecipes);
             }
             case "ChromaticGlass" -> {
                 GT_Values.RA.stdBuilder()
@@ -45,23 +55,35 @@ public class ProcessingLens implements gregtech.api.interfaces.IOreRecipeRegistr
                     .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L))
                     .noFluidInputs()
                     .noFluidOutputs()
-                    .duration(600 * SECONDS)
+                    .duration(10 * MINUTES)
                     .eut(TierEU.RECIPE_UHV)
                     .addTo(sCompressorRecipes);
             }
             default -> {
-                GT_Values.RA.addLatheRecipe(
-                    GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L),
-                    1200,
-                    120);
-                GT_Values.RA.addLatheRecipe(
-                    GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 2L),
-                    2400,
-                    30);
+                if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) {
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                        .itemOutputs(
+                            GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L),
+                            GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L))
+                        .noFluidInputs()
+                        .noFluidOutputs()
+                        .duration(1 * MINUTES)
+                        .eut(TierEU.RECIPE_MV)
+                        .addTo(sLatheRecipes);
+                }
+                if (GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1L) != null) {
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1L))
+                        .itemOutputs(
+                            GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L),
+                            GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 2L))
+                        .noFluidInputs()
+                        .noFluidOutputs()
+                        .duration(2 * MINUTES)
+                        .eut(TierEU.RECIPE_LV)
+                        .addTo(sLatheRecipes);
+                }
                 final ITexture lensCoverTexture = TextureFactory
                     .of(Textures.BlockIcons.OVERLAY_LENS, aMaterial.mRGBa, false);
                 GregTech_API.registerCover(
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingRotor.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingRotor.java
index b17b48e358..a2df7f97f7 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingRotor.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingRotor.java
@@ -1,5 +1,9 @@
 package gregtech.loaders.oreprocessing;
 
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sAssemblerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sExtruderRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sFluidSolidficationRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
 import static gregtech.api.util.GT_Utility.calculateRecipeEU;
 
 import net.minecraft.item.ItemStack;
@@ -36,41 +40,58 @@ public class ProcessingRotor implements gregtech.api.interfaces.IOreRecipeRegist
                             'R', OrePrefixes.ring.get(aMaterial), 'S', OrePrefixes.screw.get(aMaterial) });
                 }
 
-                GT_Values.RA.addAssemblerRecipe(
-                    new ItemStack[] { tPlate.copy(), tRing.copy(), GT_Utility.getIntegratedCircuit(4) },
-                    Materials.Tin.getMolten(32),
-                    GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L),
-                    (int) Math.max(aMaterial.getMass(), 1L),
-                    calculateRecipeEU(aMaterial, 24));
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tPlate.copy(), tRing.copy(), GT_Utility.getIntegratedCircuit(4))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L))
+                    .fluidInputs(Materials.Tin.getMolten(32))
+                    .noFluidOutputs()
+                    .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS)
+                    .eut(calculateRecipeEU(aMaterial, 24))
+                    .addTo(sAssemblerRecipes);
 
-                GT_Values.RA.addAssemblerRecipe(
-                    new ItemStack[] { tPlate.copy(), tRing.copy(), GT_Utility.getIntegratedCircuit(4) },
-                    Materials.Lead.getMolten(48),
-                    GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L),
-                    (int) Math.max(aMaterial.getMass(), 1L),
-                    calculateRecipeEU(aMaterial, 24));
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tPlate.copy(), tRing.copy(), GT_Utility.getIntegratedCircuit(4))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L))
+                    .fluidInputs(Materials.Lead.getMolten(48))
+                    .noFluidOutputs()
+                    .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS)
+                    .eut(calculateRecipeEU(aMaterial, 24))
+                    .addTo(sAssemblerRecipes);
 
-                GT_Values.RA.addAssemblerRecipe(
-                    new ItemStack[] { tPlate.copy(), tRing.copy(), GT_Utility.getIntegratedCircuit(4) },
-                    Materials.SolderingAlloy.getMolten(16),
-                    GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L),
-                    (int) Math.max(aMaterial.getMass(), 1L),
-                    calculateRecipeEU(aMaterial, 24));
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tPlate.copy(), tRing.copy(), GT_Utility.getIntegratedCircuit(4))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L))
+                    .fluidInputs(Materials.SolderingAlloy.getMolten(16))
+                    .noFluidOutputs()
+                    .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS)
+                    .eut(calculateRecipeEU(aMaterial, 24))
+                    .addTo(sAssemblerRecipes);
             }
-            GT_Values.RA.addExtruderRecipe(
-                GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 5L),
-                ItemList.Shape_Extruder_Rotor.get(0L),
-                GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L),
-                (int) Math.max(aMaterial.getMass(), 1L),
-                calculateRecipeEU(aMaterial, 24));
 
-            if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) {
-                GT_Values.RA.addFluidSolidifierRecipe(
-                    ItemList.Shape_Mold_Rotor.get(0L),
-                    aMaterial.getMolten(612L),
-                    GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L),
-                    (int) Math.max(aMaterial.getMass(), 1L),
-                    calculateRecipeEU(aMaterial, 24));
+            if (GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null) {
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(
+                        GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 5L),
+                        ItemList.Shape_Extruder_Rotor.get(0L))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L))
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS)
+                    .eut(calculateRecipeEU(aMaterial, 24))
+                    .addTo(sExtruderRecipes);
+            }
+            if (aMaterial.mStandardMoltenFluid != null) {
+                if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) {
+
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(ItemList.Shape_Mold_Rotor.get(0L))
+                        .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L))
+                        .fluidInputs(aMaterial.getMolten(612L))
+                        .noFluidOutputs()
+                        .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS)
+                        .eut(calculateRecipeEU(aMaterial, 24))
+                        .addTo(sFluidSolidficationRecipes);
+                }
             }
         }
     }
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStick.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStick.java
index 024a2183dd..f1e4fd0cea 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStick.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStick.java
@@ -1,8 +1,12 @@
 package gregtech.loaders.oreprocessing;
 
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sAssemblerRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sBenderRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCutterRecipes;
 import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sHammerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sLatheRecipes;
 import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
 import static gregtech.api.util.GT_Utility.calculateRecipeEU;
 
 import net.minecraft.item.ItemStack;
@@ -29,19 +33,77 @@ public class ProcessingStick implements gregtech.api.interfaces.IOreRecipeRegist
                 new Object[] { " s ", "fPx", 'P', OrePrefixes.stick.get(aMaterial) });
         }
         if (!aMaterial.contains(gregtech.api.enums.SubTag.NO_WORKING)) {
-            GT_Values.RA.addLatheRecipe(
-                aMaterial.contains(SubTag.CRYSTAL) ? GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)
-                    : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L),
-                GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L),
-                GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial.mMacerateInto, 2L),
-                (int) Math.max(aMaterial.getMass() * 5L, 1L),
-                calculateRecipeEU(aMaterial, 16));
-            GT_Values.RA.addCutterRecipe(
-                GT_Utility.copyAmount(1L, aStack),
-                GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 4L),
-                null,
-                (int) Math.max(aMaterial.getMass() * 2L, 1L),
-                calculateRecipeEU(aMaterial, 4));
+
+            if ((aMaterial.contains(SubTag.CRYSTAL) ? GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)
+                : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L)) != null
+                && GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial.mMacerateInto, 1L) != null) {
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(
+                        aMaterial.contains(SubTag.CRYSTAL) ? GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)
+                            : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial.mMacerateInto, 2L))
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(((int) Math.max(aMaterial.getMass() * 5L, 1L)) * TICKS)
+                    .eut(calculateRecipeEU(aMaterial, 16))
+                    .addTo(sLatheRecipes);
+            }
+
+            if (GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L) != null) {
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 4L))
+                    .fluidInputs(
+                        Materials.Water.getFluid(
+                            Math.max(
+                                4,
+                                Math.min(
+                                    1000,
+                                    2 * ((int) Math.max(aMaterial.getMass() * 2L, 1L))
+                                        * calculateRecipeEU(aMaterial, 4)
+                                        / 320))))
+                    .noFluidOutputs()
+                    .duration(2 * ((int) Math.max(aMaterial.getMass() * 2L, 1L)) * TICKS)
+                    .eut(calculateRecipeEU(aMaterial, 4))
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 4L))
+                    .fluidInputs(
+                        GT_ModHandler.getDistilledWater(
+                            Math.max(
+                                3,
+                                Math.min(
+                                    750,
+                                    2 * ((int) Math.max(aMaterial.getMass() * 2L, 1L))
+                                        * calculateRecipeEU(aMaterial, 4)
+                                        / 426))))
+                    .noFluidOutputs()
+                    .duration(2 * ((int) Math.max(aMaterial.getMass() * 2L, 1L)) * TICKS)
+                    .eut(calculateRecipeEU(aMaterial, 4))
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 4L))
+                    .fluidInputs(
+                        Materials.Lubricant.getFluid(
+                            Math.max(
+                                1,
+                                Math.min(
+                                    250,
+                                    ((int) Math.max(aMaterial.getMass() * 2L, 1L)) * calculateRecipeEU(aMaterial, 4)
+                                        / 1280))))
+                    .noFluidOutputs()
+                    .duration(((int) Math.max(aMaterial.getMass() * 2L, 1L)) * TICKS)
+                    .eut(calculateRecipeEU(aMaterial, 4))
+                    .addTo(sCutterRecipes);
+            }
+
             if ((aMaterial.mUnificatable) && (aMaterial.mMaterialInto == aMaterial)) {
                 if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
                     GT_ModHandler.addCraftingRecipe(
@@ -81,12 +143,15 @@ public class ProcessingStick implements gregtech.api.interfaces.IOreRecipeRegist
                     .addTo(sHammerRecipes);
             }
         }
-        GT_Values.RA.addAssemblerRecipe(
-            GT_OreDictUnificator.get(OrePrefixes.stick, Materials.Wood, 1),
-            GT_Utility.getIntegratedCircuit(2),
-            Materials.SeedOil.getFluid(50L),
-            ItemList.FR_Stick.get(1L),
-            16,
-            8);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.stick, Materials.Wood, 1),
+                GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(ItemList.FR_Stick.get(1L))
+            .fluidInputs(Materials.SeedOil.getFluid(50L))
+            .noFluidOutputs()
+            .duration(16 * TICKS)
+            .eut(8)
+            .addTo(sAssemblerRecipes);
     }
 }
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java
index 4936487f68..74029510c5 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java
@@ -1,6 +1,10 @@
 package gregtech.loaders.oreprocessing;
 
 import static gregtech.api.enums.Mods.Railcraft;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sAssemblerRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCutterRecipes;
+import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMaceratorRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
 
 import net.minecraft.block.Block;
 import net.minecraft.init.Blocks;
@@ -11,6 +15,7 @@ import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.ItemList;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
 import gregtech.api.interfaces.IOreRecipeRegistrator;
 import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_OreDictUnificator;
@@ -28,202 +33,389 @@ public class ProcessingStone implements IOreRecipeRegistrator {
         Block aBlock = GT_Utility.getBlockFromStack(aStack);
         switch (aMaterial.mName) {
             case "NULL":
-                GT_Values.RA.addAssemblerRecipe(
-                    GT_Utility.copyAmount(3L, aStack),
-                    new ItemStack(Blocks.redstone_torch, 2),
-                    Materials.Redstone.getMolten(144L),
-                    new ItemStack(Items.repeater, 1),
-                    100,
-                    4);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(3L, aStack), new ItemStack(Blocks.redstone_torch, 2))
+                    .itemOutputs(new ItemStack(Items.repeater, 1))
+                    .fluidInputs(Materials.Redstone.getMolten(144L))
+                    .noFluidOutputs()
+                    .duration(5 * SECONDS)
+                    .eut(48)
+                    .addTo(sAssemblerRecipes);
                 break;
             case "Sand":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    new ItemStack(Blocks.sand, 1, 0),
-                    null,
-                    10,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(new ItemStack(Blocks.sand, 1, 0))
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Endstone":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Endstone, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Tungstate, 1L),
-                    5,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Endstone, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Tungstate, 1L))
+                    .outputChances(10000, 500)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Netherrack":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Netherrack, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Gold, 1L),
-                    5,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Netherrack, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Gold, 1L))
+                    .outputChances(10000, 500)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "NetherBrick":
-                GT_Values.RA.addAssemblerRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    ItemList.Circuit_Integrated.getWithDamage(0L, 1L),
-                    new ItemStack(Blocks.nether_brick_fence, 1),
-                    100,
-                    4);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(1))
+                    .itemOutputs(new ItemStack(Blocks.nether_brick_fence, 1))
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(5 * SECONDS)
+                    .eut(4)
+                    .addTo(sAssemblerRecipes);
                 break;
             case "Obsidian":
                 if (aBlock != Blocks.air) aBlock.setResistance(20.0F);
-                GT_Values.RA.addAssemblerRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    ItemList.IC2_Compressed_Coal_Ball.get(8L),
-                    ItemList.IC2_Compressed_Coal_Chunk.get(1L),
-                    400,
-                    4);
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_ModHandler.getModItem(
-                        Railcraft.ID,
-                        "cube.crushed.obsidian",
-                        1L,
-                        GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L)),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
-                    10,
-                    true);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack), ItemList.IC2_Compressed_Coal_Ball.get(8L))
+                    .itemOutputs(ItemList.IC2_Compressed_Coal_Chunk.get(1L))
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(4)
+                    .addTo(sAssemblerRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_ModHandler.getModItem(Railcraft.ID, "cube", 1L, 4),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
+                    .outputChances(10000, 1000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Concrete":
-                GT_Values.RA.addCutterRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L),
-                    null,
-                    100,
-                    30);
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L));
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(Materials.Water.getFluid(Math.max(4, Math.min(1000, 200 * 30 / 320))))
+                    .noFluidOutputs()
+                    .duration(10 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(GT_ModHandler.getDistilledWater(Math.max(3, Math.min(750, 200 * 30 / 426))))
+                    .noFluidOutputs()
+                    .duration(10 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(Materials.Lubricant.getFluid(Math.max(1, Math.min(250, 100 * 30 / 1280))))
+                    .noFluidOutputs()
+                    .duration(5 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Rhyolite":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.PotassiumFeldspar, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quartz, 1L),
-                    20,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.PotassiumFeldspar, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quartz, 1L))
+                    .outputChances(10000, 2000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Komatiite":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Biotite, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Uranium, 1L),
-                    5,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Biotite, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Uranium, 1L))
+                    .outputChances(10000, 500)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Dacite":
             case "Andesite":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconDioxide, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Obsidian, 1L),
-                    20,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconDioxide, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Obsidian, 1L))
+                    .outputChances(10000, 2000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Gabbro":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.PotassiumFeldspar, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Pyrite, 1L),
-                    20,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.PotassiumFeldspar, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Pyrite, 1L))
+                    .outputChances(10000, 2000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Eclogite":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconDioxide, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Rutile, 1L),
-                    10,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconDioxide, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Rutile, 1L))
+                    .outputChances(10000, 1000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Soapstone":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Talc, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Chromite, 1L),
-                    10,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Talc, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Chromite, 1L))
+                    .outputChances(10000, 1000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Greenschist":
             case "Blueschist":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Glauconite, 2L),
-                    GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Basalt, 1L),
-                    100,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Glauconite, 2L),
+                        GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Basalt, 1L))
+                    .outputChances(10000, 1000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Gneiss":
             case "Migmatite":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconDioxide, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.GraniteBlack, 1L),
-                    50,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconDioxide, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.GraniteBlack, 1L))
+                    .outputChances(10000, 5000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Redrock":
             case "Marble":
-                GT_Values.RA.addCutterRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L),
-                    null,
-                    200,
-                    30);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(Materials.Water.getFluid(Math.max(4, Math.min(1000, 400 * 30 / 320))))
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(GT_ModHandler.getDistilledWater(Math.max(3, Math.min(750, 400 * 30 / 426))))
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(Materials.Lubricant.getFluid(Math.max(1, Math.min(250, 200 * 30 / 1280))))
+                    .noFluidOutputs()
+                    .duration(10 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
             case "Basalt":
-                GT_Values.RA.addCutterRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_Utility.getIntegratedCircuit(3),
-                    GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L),
-                    null,
-                    200,
-                    30);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(3))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(Materials.Water.getFluid(Math.max(4, Math.min(1000, 400 * 30 / 320))))
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(3))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(GT_ModHandler.getDistilledWater(Math.max(3, Math.min(750, 400 * 30 / 426))))
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(3))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(Materials.Lubricant.getFluid(Math.max(1, Math.min(250, 200 * 30 / 1280))))
+                    .noFluidOutputs()
+                    .duration(10 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
             case "Quartzite":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
-                    10,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))
+                    .outputChances(10000, 1000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "Flint":
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 2L),
-                    new ItemStack(Items.flint, 1),
-                    50,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 2L),
+                        new ItemStack(Items.flint, 1))
+                    .outputChances(10000, 5000)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "GraniteBlack":
-                GT_Values.RA.addCutterRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L),
-                    null,
-                    200,
-                    30);
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Thorium, 1L),
-                    1,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(Materials.Water.getFluid(Math.max(4, Math.min(1000, 400 * 30 / 320))))
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(GT_ModHandler.getDistilledWater(Math.max(3, Math.min(750, 400 * 30 / 426))))
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(Materials.Lubricant.getFluid(Math.max(1, Math.min(250, 200 * 30 / 1280))))
+                    .noFluidOutputs()
+                    .duration(10 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Thorium, 1L))
+                    .outputChances(10000, 100)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
                 break;
             case "GraniteRed":
-                GT_Values.RA.addCutterRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L),
-                    null,
-                    200,
-                    30);
-                GT_ModHandler.addPulverisationRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L),
-                    GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Uranium, 1L),
-                    1,
-                    false);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(Materials.Water.getFluid(Math.max(4, Math.min(1000, 400 * 30 / 320))))
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(GT_ModHandler.getDistilledWater(Math.max(3, Math.min(750, 400 * 30 / 426))))
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))
+                    .fluidInputs(Materials.Lubricant.getFluid(Math.max(1, Math.min(250, 200 * 30 / 1280))))
+                    .noFluidOutputs()
+                    .duration(10 * SECONDS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(sCutterRecipes);
+
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1L, aStack))
+                    .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L),
+                        GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Uranium, 1L))
+                    .outputChances(10000, 100)
+                    .noFluidInputs()
+                    .noFluidOutputs()
+                    .duration(20 * SECONDS)
+                    .eut(2)
+                    .addTo(sMaceratorRecipes);
         }
     }
 }