Update spotless config to 0.2.2

1 files changed, 138 insertions, 158 deletions

diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java
index cba50285a6..a74aa229a5 100644
--- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java
+++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java
@@ -19,60 +19,56 @@ public class ProcessingOre implements gregtech.api.interfaces.IOreRecipeRegistra
 
     public ProcessingOre() {
         for (OrePrefixes tPrefix : OrePrefixes.values()) if ((tPrefix.name()
-                                                                     .startsWith("ore"))
-                && (tPrefix != OrePrefixes.orePoor)
-                && (tPrefix != OrePrefixes.oreSmall)
-                && (tPrefix != OrePrefixes.oreRich)
-                && (tPrefix != OrePrefixes.oreNormal))
-            tPrefix.add(this);
+            .startsWith("ore")) && (tPrefix != OrePrefixes.orePoor)
+            && (tPrefix != OrePrefixes.oreSmall)
+            && (tPrefix != OrePrefixes.oreRich)
+            && (tPrefix != OrePrefixes.oreNormal)) tPrefix.add(this);
     }
 
     @Override
     public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName,
-            ItemStack aStack) {
+        ItemStack aStack) {
         boolean tIsRich = (aPrefix == OrePrefixes.oreNetherrack) || (aPrefix == OrePrefixes.oreNether)
-                || (aPrefix == OrePrefixes.oreEndstone)
-                || (aPrefix == OrePrefixes.oreEnd)
-                || (aPrefix == OrePrefixes.oreRich)
-                || (aPrefix == OrePrefixes.oreDense);
+            || (aPrefix == OrePrefixes.oreEndstone)
+            || (aPrefix == OrePrefixes.oreEnd)
+            || (aPrefix == OrePrefixes.oreRich)
+            || (aPrefix == OrePrefixes.oreDense);
 
         if (aMaterial == Materials.Oilsands) {
             GT_Values.RA.addCentrifugeRecipe(
-                    GT_Utility.copyAmount(1L, aStack),
-                    null,
-                    null,
-                    Materials.OilHeavy.getFluid(tIsRich ? 4000L : 2000L),
-                    new ItemStack(net.minecraft.init.Blocks.sand, 1, 0),
-                    null,
-                    null,
-                    null,
-                    null,
-                    null,
-                    new int[] { tIsRich ? 2000 : 4000 },
-                    tIsRich ? 600 : 300,
-                    30);
+                GT_Utility.copyAmount(1L, aStack),
+                null,
+                null,
+                Materials.OilHeavy.getFluid(tIsRich ? 4000L : 2000L),
+                new ItemStack(net.minecraft.init.Blocks.sand, 1, 0),
+                null,
+                null,
+                null,
+                null,
+                null,
+                new int[] { tIsRich ? 2000 : 4000 },
+                tIsRich ? 600 : 300,
+                30);
         } else {
             registerStandardOreRecipes(
-                    aPrefix,
-                    aMaterial,
-                    GT_Utility.copyAmount(1L, aStack),
-                    Math.max(
-                            1,
-                            gregtech.api.GregTech_API.sOPStuff.get(
-                                    gregtech.api.enums.ConfigCategories.Materials.oreprocessingoutputmultiplier,
-                                    aMaterial.toString(),
-                                    1))
-                            * (tIsRich ? 2 : 1));
+                aPrefix,
+                aMaterial,
+                GT_Utility.copyAmount(1L, aStack),
+                Math.max(
+                    1,
+                    gregtech.api.GregTech_API.sOPStuff.get(
+                        gregtech.api.enums.ConfigCategories.Materials.oreprocessingoutputmultiplier,
+                        aMaterial.toString(),
+                        1))
+                    * (tIsRich ? 2 : 1));
         }
     }
 
     private boolean registerStandardOreRecipes(OrePrefixes aPrefix, Materials aMaterial, ItemStack aOreStack,
-            int aMultiplier) {
+        int aMultiplier) {
         if ((aOreStack == null) || (aMaterial == null)) return false;
-        GT_ModHandler.addValuableOre(
-                GT_Utility.getBlockFromStack(aOreStack),
-                aOreStack.getItemDamage(),
-                aMaterial.mOreValue);
+        GT_ModHandler
+            .addValuableOre(GT_Utility.getBlockFromStack(aOreStack), aOreStack.getItemDamage(), aMaterial.mOreValue);
         Materials tMaterial = aMaterial.mOreReplacement;
         Materials tPrimaryByMaterial = null;
         aMultiplier = Math.max(1, aMultiplier);
@@ -81,37 +77,37 @@ public class ProcessingOre implements gregtech.api.interfaces.IOreRecipeRegistra
 
         ItemStack tIngot = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L);
         ItemStack tGem = GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial, 1L);
-        ItemStack tSmeltInto = tIngot == null ? null
+        ItemStack tSmeltInto = tIngot
+            == null
+                ? null
                 : aMaterial.contains(SubTag.SMELTING_TO_GEM)
-                        ? GT_OreDictUnificator.get(
+                    ? GT_OreDictUnificator.get(
+                        OrePrefixes.gem,
+                        tMaterial.mDirectSmelting,
+                        GT_OreDictUnificator.get(
+                            OrePrefixes.crystal,
+                            tMaterial.mDirectSmelting,
+                            GT_OreDictUnificator.get(
                                 OrePrefixes.gem,
-                                tMaterial.mDirectSmelting,
-                                GT_OreDictUnificator.get(
-                                        OrePrefixes.crystal,
-                                        tMaterial.mDirectSmelting,
-                                        GT_OreDictUnificator.get(
-                                                OrePrefixes.gem,
-                                                tMaterial,
-                                                GT_OreDictUnificator.get(OrePrefixes.crystal, tMaterial, 1L),
-                                                1L),
-                                        1L),
-                                1L)
-                        : tIngot;
+                                tMaterial,
+                                GT_OreDictUnificator.get(OrePrefixes.crystal, tMaterial, 1L),
+                                1L),
+                            1L),
+                        1L)
+                    : tIngot;
 
         ItemStack tDust = GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial, tGem, 1L);
         ItemStack tCleaned = GT_OreDictUnificator.get(OrePrefixes.crushedPurified, tMaterial, tDust, 1L);
-        ItemStack tCrushed = GT_OreDictUnificator.get(
-                OrePrefixes.crushed,
-                tMaterial,
-                aMaterial.mOreMultiplier * aMultiplier);
+        ItemStack tCrushed = GT_OreDictUnificator
+            .get(OrePrefixes.crushed, tMaterial, aMaterial.mOreMultiplier * aMultiplier);
         ItemStack tPrimaryByProduct = null;
 
         if (tCrushed == null) {
             tCrushed = GT_OreDictUnificator.get(
-                    OrePrefixes.dustImpure,
-                    tMaterial,
-                    GT_Utility.copyAmount(aMaterial.mOreMultiplier * aMultiplier, tCleaned, tDust, tGem),
-                    aMaterial.mOreMultiplier * aMultiplier);
+                OrePrefixes.dustImpure,
+                tMaterial,
+                GT_Utility.copyAmount(aMaterial.mOreMultiplier * aMultiplier, tCleaned, tDust, tGem),
+                aMaterial.mOreMultiplier * aMultiplier);
         }
 
         ArrayList<ItemStack> tByProductStacks = new ArrayList<>();
@@ -122,32 +118,26 @@ public class ProcessingOre implements gregtech.api.interfaces.IOreRecipeRegistra
             if (tPrimaryByProduct == null) {
                 tPrimaryByMaterial = tMat;
                 tPrimaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L);
-                if (GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L) == null) GT_OreDictUnificator.get(
-                        OrePrefixes.dustTiny,
-                        tMat,
-                        GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L),
-                        2L);
+                if (GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L) == null) GT_OreDictUnificator
+                    .get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L);
             }
             GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L);
-            if (GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L) == null) GT_OreDictUnificator.get(
-                    OrePrefixes.dustTiny,
-                    tMat,
-                    GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L),
-                    2L);
+            if (GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L) == null) GT_OreDictUnificator
+                .get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L);
         }
         if ((!tByProductStacks.isEmpty()) && (!this.mAlreadyListedOres.contains(aMaterial))) {
             this.mAlreadyListedOres.add(aMaterial);
             gregtech.api.util.GT_Recipe.GT_Recipe_Map.sByProductList.addFakeRecipe(
-                    false,
-                    new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.ore, aMaterial, aOreStack, 1L) },
-                    tByProductStacks.toArray(new ItemStack[0]),
-                    null,
-                    null,
-                    null,
-                    null,
-                    0,
-                    0,
-                    0);
+                false,
+                new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.ore, aMaterial, aOreStack, 1L) },
+                tByProductStacks.toArray(new ItemStack[0]),
+                null,
+                null,
+                null,
+                null,
+                0,
+                0,
+                0);
         }
 
         if (tPrimaryByMaterial == null) tPrimaryByMaterial = tMaterial;
@@ -159,105 +149,95 @@ public class ProcessingOre implements gregtech.api.interfaces.IOreRecipeRegistra
                 GT_ModHandler.removeFurnaceSmelting(aOreStack);
             } else {
                 tHasSmelting = GT_ModHandler.addSmeltingRecipe(
-                        aOreStack,
-                        GT_Utility.copyAmount(aMultiplier * aMaterial.mSmeltingMultiplier, tSmeltInto));
+                    aOreStack,
+                    GT_Utility.copyAmount(aMultiplier * aMaterial.mSmeltingMultiplier, tSmeltInto));
             }
 
             if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_TRIPLE)) {
                 if (aMaterial.mAutoGenerateBlastFurnaceRecipes) {
                     GT_Values.RA.addBlastRecipe(
-                            aOreStack,
-                            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcite, aMultiplier),
-                            null,
-                            null,
-                            GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, tSmeltInto),
-                            ItemList.TE_Slag.get(
-                                    1L,
-                                    GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)),
-                            tSmeltInto.stackSize * 500,
-                            120,
-                            1500);
+                        aOreStack,
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcite, aMultiplier),
+                        null,
+                        null,
+                        GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, tSmeltInto),
+                        ItemList.TE_Slag
+                            .get(1L, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)),
+                        tSmeltInto.stackSize * 500,
+                        120,
+                        1500);
                     GT_Values.RA.addBlastRecipe(
-                            aOreStack,
-                            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, aMultiplier),
-                            null,
-                            null,
-                            GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, tSmeltInto),
-                            ItemList.TE_Slag.get(
-                                    1L,
-                                    GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)),
-                            tSmeltInto.stackSize * 500,
-                            120,
-                            1500);
+                        aOreStack,
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, aMultiplier),
+                        null,
+                        null,
+                        GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, tSmeltInto),
+                        ItemList.TE_Slag
+                            .get(1L, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)),
+                        tSmeltInto.stackSize * 500,
+                        120,
+                        1500);
                 }
             } else if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_DOUBLE)) {
                 if (aMaterial.mAutoGenerateBlastFurnaceRecipes) {
                     GT_Values.RA.addBlastRecipe(
-                            aOreStack,
-                            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcite, aMultiplier),
-                            null,
-                            null,
-                            GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, tSmeltInto),
-                            ItemList.TE_Slag.get(
-                                    1L,
-                                    GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)),
-                            tSmeltInto.stackSize * 500,
-                            120,
-                            1500);
+                        aOreStack,
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcite, aMultiplier),
+                        null,
+                        null,
+                        GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, tSmeltInto),
+                        ItemList.TE_Slag
+                            .get(1L, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)),
+                        tSmeltInto.stackSize * 500,
+                        120,
+                        1500);
                     GT_Values.RA.addBlastRecipe(
-                            aOreStack,
-                            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, aMultiplier),
-                            null,
-                            null,
-                            GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, tSmeltInto),
-                            ItemList.TE_Slag.get(
-                                    1L,
-                                    GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)),
-                            tSmeltInto.stackSize * 500,
-                            120,
-                            1500);
+                        aOreStack,
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, aMultiplier),
+                        null,
+                        null,
+                        GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, tSmeltInto),
+                        ItemList.TE_Slag
+                            .get(1L, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)),
+                        tSmeltInto.stackSize * 500,
+                        120,
+                        1500);
                 }
             }
         }
 
         if (!tHasSmelting) {
             GT_ModHandler.addSmeltingRecipe(
-                    aOreStack,
-                    GT_OreDictUnificator.get(
-                            OrePrefixes.gem,
-                            tMaterial.mDirectSmelting,
-                            Math.max(1, aMultiplier * aMaterial.mSmeltingMultiplier / 2)));
+                aOreStack,
+                GT_OreDictUnificator.get(
+                    OrePrefixes.gem,
+                    tMaterial.mDirectSmelting,
+                    Math.max(1, aMultiplier * aMaterial.mSmeltingMultiplier / 2)));
         }
 
         if (tCrushed != null) {
             GT_Values.RA.addForgeHammerRecipe(
-                    aOreStack,
-                    GT_Utility.copy(GT_Utility.copyAmount(tCrushed.stackSize, tGem), tCrushed),
-                    16,
-                    10);
+                aOreStack,
+                GT_Utility.copy(GT_Utility.copyAmount(tCrushed.stackSize, tGem), tCrushed),
+                16,
+                10);
             GT_ModHandler.addPulverisationRecipe(
-                    aOreStack,
-                    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);
+                aOreStack,
+                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);
         }
         return true;
     }