The Great Renaming (#3014)

* move kekztech to a single root dir

* move detrav to a single root dir

* move gtnh-lanthanides to a single root dir

* move tectech and delete some gross reflection in gt++

* remove more reflection inside gt5u

* delete more reflection in gt++

* fix imports

* move bartworks and bwcrossmod

* fix proxies

* move galactigreg and ggfab

* move gtneioreplugin

* try to fix gt++ bee loader

* apply the rename rules to BW

* apply rename rules to bwcrossmod

* apply rename rules to detrav scanner mod

* apply rename rules to galacticgreg

* apply rename rules to ggfab

* apply rename rules to goodgenerator

* apply rename rules to gtnh-lanthanides

* apply rename rules to gt++

* apply rename rules to kekztech

* apply rename rules to kubatech

* apply rename rules to tectech

* apply rename rules to gt

apply the rename rules to gt

* fix tt import

* fix mui hopefully

* fix coremod except intergalactic

* rename assline recipe class

* fix a class name i stumbled on

* rename StructureUtility to GTStructureUtility to prevent conflict with structurelib

* temporary rename of GTTooltipDataCache to old name

* fix gt client/server proxy names

3 files changed, 1459 insertions, 0 deletions

diff --git a/src/main/java/bartworks/system/material/gtenhancement/BWGTMetaItems.java b/src/main/java/bartworks/system/material/gtenhancement/BWGTMetaItems.java
new file mode 100644
index 0000000000..b543150e35
--- /dev/null
+++ b/src/main/java/bartworks/system/material/gtenhancement/BWGTMetaItems.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package bartworks.system.material.gtenhancement;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+
+import bartworks.API.SideReference;
+import bartworks.client.textures.PrefixTextureLinker;
+import bartworks.system.material.BWMetaGeneratedItems;
+import bartworks.system.material.Werkstoff;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TextureSet;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.util.GTOreDictUnificator;
+import gregtech.common.render.items.GeneratedMaterialRenderer;
+
+public class BWGTMetaItems extends BWMetaGeneratedItems {
+
+    private boolean hasList;
+    private final Set<Integer> hiddenThings = new HashSet<>();
+
+    public BWGTMetaItems(OrePrefixes orePrefixes, List<Materials> noSubIDMaterials) {
+        super(orePrefixes, null);
+        // materialloop:
+        for (int i = 0; i < Materials.values().length; i++) {
+            ItemStack tStack = new ItemStack(this, 1, i);
+            Materials material = Materials.values()[i];
+            if (material.getMolten(1) == null && orePrefixes == OrePrefixes.capsuleMolten
+                || material.getFluid(1) == null && material.getGas(1) == null
+                    && (orePrefixes == OrePrefixes.capsule || orePrefixes == OrePrefixes.bottle))
+                continue;
+
+            if (OreDictionary.doesOreNameExist(this.orePrefixes.name() + material.mDefaultLocalName.replace(" ", ""))) {
+                this.hiddenThings.add(i);
+                continue;
+            }
+            GTOreDictUnificator
+                .registerOre(this.orePrefixes.name() + material.mDefaultLocalName.replace(" ", ""), tStack);
+        }
+
+        if (noSubIDMaterials != null) {
+            this.hasList = true;
+            // materialloop:
+            for (int i = 0; i < noSubIDMaterials.size(); i++) {
+                ItemStack tStack = new ItemStack(this, 1, i + 1001);
+                Materials w = noSubIDMaterials.get(i);
+                if (w.getMolten(1) == null && orePrefixes == OrePrefixes.capsuleMolten
+                    || w.getFluid(1) == null && w.getGas(1) == null
+                        && (orePrefixes == OrePrefixes.capsule || orePrefixes == OrePrefixes.bottle))
+                    continue;
+
+                if (OreDictionary.doesOreNameExist(this.orePrefixes.name() + w.mDefaultLocalName.replace(" ", ""))) {
+                    this.hiddenThings.add(i);
+                    continue;
+                }
+                GTOreDictUnificator.registerOre(this.orePrefixes.name() + w.mDefaultLocalName.replace(" ", ""), tStack);
+            }
+        }
+    }
+
+    private Materials getMaterial(ItemStack is) {
+        if (is == null || is.getItem() != this) return null;
+        final int meta = is.getItemDamage();
+        return this.getMaterialFromMeta(meta);
+    }
+
+    @Override
+    public String getItemStackDisplayName(ItemStack aStack) {
+        Materials material = this.getMaterial(aStack);
+        if (material == null) material = Materials._NULL;
+        return material.getLocalizedNameForItem(this.itemTypeLocalizedName);
+    }
+
+    @Override
+    protected void addAdditionalToolTips(List<String> aList, ItemStack aStack, EntityPlayer aPlayer) {
+        Materials material = this.getMaterial(aStack);
+        if (material != null) {
+            String tooltip = material.getToolTip();
+            if (tooltip != null && !tooltip.isEmpty()) {
+                aList.add(tooltip);
+            }
+        }
+    }
+
+    @Override
+    public IIconContainer getIconContainer(int aMetaData) {
+        if (this.orePrefixes.mTextureIndex == -1) return this.getIconContainerBartWorks(aMetaData);
+        Materials material = this.getMaterialFromMeta(aMetaData);
+        if (material != null) {
+            return material.mIconSet.mTextures[this.orePrefixes.mTextureIndex];
+        }
+        return null;
+    }
+
+    @Override
+    protected IIconContainer getIconContainerBartWorks(int aMetaData) {
+        if (SideReference.Side.Server || PrefixTextureLinker.texMap == null) return null;
+
+        HashMap<TextureSet, Textures.ItemIcons.CustomIcon> iconLink = PrefixTextureLinker.texMap.get(this.orePrefixes);
+
+        if (iconLink == null) return null;
+
+        Materials material = this.getMaterialFromMeta(aMetaData);
+
+        if (material == null || material.mIconSet == null) return null;
+
+        return iconLink.getOrDefault(material.mIconSet, iconLink.get(TextureSet.SET_DULL));
+    }
+
+    @Override
+    public IIcon getIconFromDamage(int aMetaData) {
+        return this.getIcon(aMetaData, 0);
+    }
+
+    @Override
+    public GeneratedMaterialRenderer getMaterialRenderer(int aMetaData) {
+        return this.getMaterialFromMeta(aMetaData).renderer;
+    }
+
+    public Materials getMaterialFromMeta(int aMetaData) {
+        if (aMetaData > 1000 && this.hasList) {
+            return GTMetaItemEnhancer.NoMetaValue.get(aMetaData - 1001);
+        }
+        if (aMetaData < 0 || aMetaData >= Materials.values().length) {
+            return null;
+        }
+        return Materials.values()[aMetaData];
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item var1, CreativeTabs aCreativeTab, List<ItemStack> aList) {
+        for (int i = 0; i < Materials.values().length; i++) {
+            Materials w = Materials.values()[i];
+            if (w == null || (w.mTypes & Werkstoff.GenerationFeatures.getPrefixDataRaw(this.orePrefixes)) == 0
+                && Werkstoff.GenerationFeatures.getPrefixDataRaw(this.orePrefixes) != 0) continue;
+            if (w.getMolten(1) == null && this.orePrefixes == OrePrefixes.capsuleMolten
+                || w.getFluid(1) == null && w.getGas(1) == null
+                    && (this.orePrefixes == OrePrefixes.capsule || this.orePrefixes == OrePrefixes.bottle))
+                continue;
+            else if (this.hiddenThings.contains(i)) continue;
+            aList.add(new ItemStack(this, 1, i));
+        }
+        if (this.hasList) for (int i = 0; i < GTMetaItemEnhancer.NoMetaValue.size(); i++) {
+            Materials w = GTMetaItemEnhancer.NoMetaValue.get(i);
+            if (w == null || (w.mTypes & Werkstoff.GenerationFeatures.getPrefixDataRaw(this.orePrefixes)) == 0
+                && Werkstoff.GenerationFeatures.getPrefixDataRaw(this.orePrefixes) != 0) continue;
+            if (w.getMolten(1) == null && this.orePrefixes == OrePrefixes.capsuleMolten
+                || w.getFluid(1) == null && w.getGas(1) == null
+                    && (this.orePrefixes == OrePrefixes.capsule || this.orePrefixes == OrePrefixes.bottle))
+                continue;
+            else if (this.hiddenThings.contains(i)) continue;
+            aList.add(new ItemStack(this, 1, i + 1001));
+        }
+    }
+
+    @Override
+    public short[] getColorForGUI(ItemStack aStack) {
+        return this.getMaterial(aStack).mRGBa;
+    }
+
+    @Override
+    public String getNameForGUI(ItemStack aStack) {
+        return this.getMaterial(aStack).mDefaultLocalName;
+    }
+
+    @Override
+    public void onUpdate(ItemStack aStack, World aWorld, Entity aPlayer, int aTimer, boolean aIsInHand) {}
+
+    @Override
+    public short[] getRGBa(ItemStack aStack) {
+        return this.getMaterial(aStack).mRGBa;
+    }
+
+    @Override
+    public boolean onEntityItemUpdate(EntityItem aItemEntity) {
+        return false;
+    }
+}
diff --git a/src/main/java/bartworks/system/material/gtenhancement/GTMetaItemEnhancer.java b/src/main/java/bartworks/system/material/gtenhancement/GTMetaItemEnhancer.java
new file mode 100644
index 0000000000..d3c1bb2ece
--- /dev/null
+++ b/src/main/java/bartworks/system/material/gtenhancement/GTMetaItemEnhancer.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package bartworks.system.material.gtenhancement;
+
+import static gregtech.api.enums.Mods.Forestry;
+import static gregtech.api.recipe.RecipeMaps.fluidCannerRecipes;
+import static gregtech.api.util.GTRecipeBuilder.TICKS;
+import static gregtech.api.util.GTRecipeBuilder.WILDCARD;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidContainerRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+import codechicken.nei.api.API;
+import gregtech.api.enums.GTValues;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GTModHandler;
+import gregtech.api.util.GTOreDictUnificator;
+import gregtech.api.util.GTUtility;
+
+public class GTMetaItemEnhancer {
+
+    static List<Materials> NoMetaValue;
+
+    private GTMetaItemEnhancer() {}
+
+    public static void init() {
+        if (!Forestry.isModLoaded()) {
+            return;
+        }
+        NoMetaValue = Materials.getMaterialsMap()
+            .values()
+            .stream()
+            .filter(m -> m.mMetaItemSubID == -1)
+            .collect(Collectors.toList());
+        Item moltenCapsuls = new BWGTMetaItems(OrePrefixes.capsuleMolten, null);
+        Item capsuls = new BWGTMetaItems(OrePrefixes.capsule, NoMetaValue);
+        // Item bottles = new BWGTMetaItems(OrePrefixes.bottle, NoMetaValue);
+
+        Materials[] values = Materials.values();
+        for (int i = 0, valuesLength = values.length; i < valuesLength; i++) {
+            Materials m = values[i];
+            if (m.mStandardMoltenFluid != null && GTOreDictUnificator.get(OrePrefixes.cellMolten, m, 1) != null) {
+                final FluidContainerRegistry.FluidContainerData emptyData = new FluidContainerRegistry.FluidContainerData(
+                    m.getMolten(144),
+                    new ItemStack(moltenCapsuls, 1, i),
+                    GTModHandler.getModItem(Forestry.ID, "refractoryEmpty", 1));
+                FluidContainerRegistry.registerFluidContainer(emptyData);
+                GTUtility.addFluidContainerData(emptyData);
+
+                GTValues.RA.stdBuilder()
+                    .itemInputs(GTModHandler.getModItem(Forestry.ID, "refractoryEmpty", 1))
+                    .itemOutputs(new ItemStack(moltenCapsuls, 1, i))
+                    .fluidInputs(m.getMolten(144))
+                    .duration(2 * TICKS)
+                    .eut(2)
+                    .addTo(fluidCannerRecipes);
+
+                GTValues.RA.stdBuilder()
+                    .itemInputs(new ItemStack(moltenCapsuls, 1, i))
+                    .fluidOutputs(m.getMolten(144))
+                    .duration(2 * TICKS)
+                    .eut(2)
+                    .addTo(fluidCannerRecipes);
+
+            }
+            if (m.getFluid(1) == null && m.getGas(1) == null || OreDictionary.doesOreNameExist("capsule" + m.mName))
+                continue;
+            addFluidData(m, GTModHandler.getModItem(Forestry.ID, "waxCapsule", 1), capsuls, 1000, i, true);
+            // addFluidData(m, new ItemStack(Items.glass_bottle), bottles, 250, i, false);
+        }
+        for (int i = 0, valuesLength = NoMetaValue.size(); i < valuesLength; i++) {
+            Materials m = NoMetaValue.get(i);
+            if (m.getFluid(1) == null && m.getGas(1) == null || OreDictionary.doesOreNameExist("capsule" + m.mName))
+                continue;
+            addFluidData(m, GTModHandler.getModItem(Forestry.ID, "waxCapsule", 1), capsuls, 1000, i + 1001, true);
+            // addFluidData(m, new ItemStack(Items.glass_bottle), bottles, 250, i + 1001, false);
+        }
+
+        API.hideItem(new ItemStack(capsuls, 1, WILDCARD));
+        API.hideItem(new ItemStack(moltenCapsuls, 1, WILDCARD));
+    }
+
+    private static void addFluidData(Materials m, ItemStack container, Item filled, int amount, int it, boolean empty) {
+        Fluid f = m.getFluid(1) != null ? m.getFluid(1)
+            .getFluid()
+            : m.getGas(1)
+                .getFluid();
+        final FluidContainerRegistry.FluidContainerData emptyData = new FluidContainerRegistry.FluidContainerData(
+            new FluidStack(f, amount),
+            new ItemStack(filled, 1, it),
+            container);
+        FluidContainerRegistry.registerFluidContainer(emptyData);
+        GTUtility.addFluidContainerData(emptyData);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(container)
+            .itemOutputs(new ItemStack(filled, 1, it))
+            .fluidInputs(new FluidStack(f, amount))
+            .duration(amount / 62)
+            .eut(2)
+            .addTo(fluidCannerRecipes);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(new ItemStack(filled, 1, it))
+            .fluidOutputs(new FluidStack(f, amount))
+            .duration(amount / 62)
+            .eut(2)
+            .addTo(fluidCannerRecipes);
+
+    }
+
+    public static void addAdditionalOreDictToForestry() {
+        if (!Forestry.isModLoaded()) return;
+        OreDictionary.registerOre("capsuleWater", getForestryItem("waxCapsuleWater"));
+        OreDictionary.registerOre("capsuleIce", getForestryItem("waxCapsuleIce"));
+        OreDictionary.registerOre("capsuleHoney", getForestryItem("waxCapsuleHoney"));
+        OreDictionary.registerOre("capsuleJuice", getForestryItem("waxCapsuleJuice"));
+        OreDictionary.registerOre("capsuleSeedOil", getForestryItem("waxCapsuleSeedOil"));
+        OreDictionary.registerOre("capsuleEthanol", getForestryItem("waxCapsuleEthanol"));
+        OreDictionary.registerOre("capsuleBiomass", getForestryItem("waxCapsuleBiomass"));
+        OreDictionary.registerOre("capsuleShortMead", getForestryItem("waxCapsuleShortMead"));
+        OreDictionary.registerOre("capsuleMead", getForestryItem("waxCapsuleMead"));
+        OreDictionary.registerOre("capsuleFuel", getForestryItem("waxCapsuleFuel"));
+        OreDictionary.registerOre("capsuleOil", getForestryItem("waxCapsuleOil"));
+        OreDictionary.registerOre("capsuleLava", getForestryItem("refractoryLava"));
+    }
+
+    private static ItemStack getForestryItem(String itemName) {
+        return GTModHandler.getModItem(Forestry.ID, itemName, 1);
+    }
+}
diff --git a/src/main/java/bartworks/system/material/gtenhancement/PlatinumSludgeOverHaul.java b/src/main/java/bartworks/system/material/gtenhancement/PlatinumSludgeOverHaul.java
new file mode 100644
index 0000000000..a20996d463
--- /dev/null
+++ b/src/main/java/bartworks/system/material/gtenhancement/PlatinumSludgeOverHaul.java
@@ -0,0 +1,1102 @@
+/*
+ * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package bartworks.system.material.gtenhancement;
+
+import static bartworks.system.material.WerkstoffLoader.AcidicIridiumSolution;
+import static bartworks.system.material.WerkstoffLoader.AcidicOsmiumSolution;
+import static bartworks.system.material.WerkstoffLoader.AmmoniumChloride;
+import static bartworks.system.material.WerkstoffLoader.AquaRegia;
+import static bartworks.system.material.WerkstoffLoader.CalciumChloride;
+import static bartworks.system.material.WerkstoffLoader.CrudeRhMetall;
+import static bartworks.system.material.WerkstoffLoader.FormicAcid;
+import static bartworks.system.material.WerkstoffLoader.HotRutheniumTetroxideSollution;
+import static bartworks.system.material.WerkstoffLoader.IrLeachResidue;
+import static bartworks.system.material.WerkstoffLoader.IrOsLeachResidue;
+import static bartworks.system.material.WerkstoffLoader.IridiumChloride;
+import static bartworks.system.material.WerkstoffLoader.IridiumDioxide;
+import static bartworks.system.material.WerkstoffLoader.LeachResidue;
+import static bartworks.system.material.WerkstoffLoader.OsmiumSolution;
+import static bartworks.system.material.WerkstoffLoader.PDAmmonia;
+import static bartworks.system.material.WerkstoffLoader.PDMetallicPowder;
+import static bartworks.system.material.WerkstoffLoader.PDRawPowder;
+import static bartworks.system.material.WerkstoffLoader.PDSalt;
+import static bartworks.system.material.WerkstoffLoader.PGSDResidue;
+import static bartworks.system.material.WerkstoffLoader.PGSDResidue2;
+import static bartworks.system.material.WerkstoffLoader.PTConcentrate;
+import static bartworks.system.material.WerkstoffLoader.PTMetallicPowder;
+import static bartworks.system.material.WerkstoffLoader.PTRawPowder;
+import static bartworks.system.material.WerkstoffLoader.PTResidue;
+import static bartworks.system.material.WerkstoffLoader.PTSaltCrude;
+import static bartworks.system.material.WerkstoffLoader.PTSaltRefined;
+import static bartworks.system.material.WerkstoffLoader.PotassiumDisulfate;
+import static bartworks.system.material.WerkstoffLoader.RHFilterCakeSolution;
+import static bartworks.system.material.WerkstoffLoader.RHNitrate;
+import static bartworks.system.material.WerkstoffLoader.RHSalt;
+import static bartworks.system.material.WerkstoffLoader.RHSaltSolution;
+import static bartworks.system.material.WerkstoffLoader.RHSulfate;
+import static bartworks.system.material.WerkstoffLoader.RHSulfateSolution;
+import static bartworks.system.material.WerkstoffLoader.ReRh;
+import static bartworks.system.material.WerkstoffLoader.RhFilterCake;
+import static bartworks.system.material.WerkstoffLoader.Rhodium;
+import static bartworks.system.material.WerkstoffLoader.Ruthenium;
+import static bartworks.system.material.WerkstoffLoader.RutheniumTetroxide;
+import static bartworks.system.material.WerkstoffLoader.RutheniumTetroxideSollution;
+import static bartworks.system.material.WerkstoffLoader.SodiumNitrate;
+import static bartworks.system.material.WerkstoffLoader.SodiumRuthenate;
+import static bartworks.system.material.WerkstoffLoader.Sodiumformate;
+import static bartworks.system.material.WerkstoffLoader.Sodiumsulfate;
+import static bartworks.system.material.WerkstoffLoader.ZincSulfate;
+import static gregtech.api.enums.Mods.GalaxySpace;
+import static gregtech.api.enums.Mods.NewHorizonsCoreMod;
+import static gregtech.api.enums.OrePrefixes.cell;
+import static gregtech.api.enums.OrePrefixes.crushed;
+import static gregtech.api.enums.OrePrefixes.crushedCentrifuged;
+import static gregtech.api.enums.OrePrefixes.crushedPurified;
+import static gregtech.api.enums.OrePrefixes.dust;
+import static gregtech.api.enums.OrePrefixes.dustImpure;
+import static gregtech.api.enums.OrePrefixes.dustPure;
+import static gregtech.api.enums.OrePrefixes.dustRefined;
+import static gregtech.api.enums.OrePrefixes.dustSmall;
+import static gregtech.api.enums.OrePrefixes.dustTiny;
+import static gregtech.api.enums.OrePrefixes.ingot;
+import static gregtech.api.enums.OrePrefixes.nugget;
+import static gregtech.api.enums.OrePrefixes.rawOre;
+import static gregtech.api.recipe.RecipeMaps.*;
+import static gregtech.api.util.GTRecipeBuilder.MINUTES;
+import static gregtech.api.util.GTRecipeBuilder.SECONDS;
+import static gregtech.api.util.GTRecipeBuilder.TICKS;
+import static gregtech.api.util.GTRecipeConstants.COIL_HEAT;
+import static gregtech.api.util.GTRecipeConstants.UniversalChemical;
+import static gtPlusPlus.core.material.MaterialsAlloy.HELICOPTER;
+import static gtPlusPlus.core.material.MaterialsElements.STANDALONE.WHITE_METAL;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.CraftingManager;
+import net.minecraft.item.crafting.FurnaceRecipes;
+import net.minecraft.item.crafting.IRecipe;
+
+import bartworks.MainMod;
+import bartworks.system.material.BWMetaGeneratedItems;
+import bartworks.system.material.Werkstoff;
+import bartworks.util.BWUtil;
+import bwcrossmod.BartWorksCrossmod;
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.enums.GTValues;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.interfaces.IRecipeMutableAccess;
+import gregtech.api.interfaces.ISubTagContainer;
+import gregtech.api.items.GTGenericBlock;
+import gregtech.api.items.GTGenericItem;
+import gregtech.api.objects.ItemData;
+import gregtech.api.objects.MaterialStack;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.util.GTModHandler;
+import gregtech.api.util.GTOreDictUnificator;
+import gregtech.api.util.GTRecipe;
+import gregtech.api.util.GTUtility;
+import gregtech.common.blocks.BlockOresAbstract;
+
+public class PlatinumSludgeOverHaul {
+
+    private static final Materials[] BLACKLIST = { Materials.HSSS, Materials.EnderiumBase, Materials.Osmiridium,
+        Materials.TPV, Materials.get("Uraniumtriplatinid"), Materials.get("Tetranaquadahdiindiumhexaplatiumosminid"),
+        Materials.get("Longasssuperconductornameforuvwire"), };
+    private static final OrePrefixes[] OPBLACKLIST = { crushedCentrifuged, crushed, crushedPurified, dustPure,
+        dustImpure, dustRefined, dust, dustTiny, dustSmall };
+
+    private PlatinumSludgeOverHaul() {}
+
+    private static void runHelperrecipes() {
+        // DilutedSulfuricAcid
+        // 2H2SO4 + H2O = 3H2SO4(d)
+        GTValues.RA.stdBuilder()
+            .itemInputs(
+                Materials.SulfuricAcid.getCells(2),
+                Materials.Water.getCells(1),
+                GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(Materials.DilutedSulfuricAcid.getCells(3))
+            .duration(1 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(mixerRecipes);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(Materials.Water.getCells(1), GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(Materials.Empty.getCells(1))
+            .fluidInputs(Materials.SulfuricAcid.getFluid(2000))
+            .fluidOutputs(Materials.DilutedSulfuricAcid.getFluid(3000))
+            .duration(1 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(mixerRecipes);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(Materials.SulfuricAcid.getCells(2), GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(Materials.Empty.getCells(2))
+            .fluidInputs(Materials.Water.getFluid(1000))
+            .fluidOutputs(Materials.DilutedSulfuricAcid.getFluid(3000))
+            .duration(1 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(mixerRecipes);
+        // FormicAcid
+        // CO + NaOH = CHO2Na
+        GTValues.RA.stdBuilder()
+            .itemInputs(Materials.CarbonMonoxide.getCells(1), Materials.SodiumHydroxide.getDust(3))
+            .itemOutputs(Sodiumformate.get(cell))
+            .duration(15 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+        // H2SO4 + 2CHO2Na = 2CH2O2 + Na2SO4
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(Sodiumformate.get(cell, 2), GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(FormicAcid.get(cell, 2), Sodiumsulfate.get(dust, 7))
+            .fluidInputs(Materials.SulfuricAcid.getFluid(1000))
+            .duration(15 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(Materials.SulfuricAcid.getCells(1), GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(Materials.Empty.getCells(1), Sodiumsulfate.get(dust, 7))
+            .fluidInputs(Sodiumformate.getFluidOrGas(2000))
+            .fluidOutputs(FormicAcid.getFluidOrGas(2000))
+            .duration(15 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        // AquaRegia
+        GTValues.RA.stdBuilder()
+            .itemInputs(
+                Materials.DilutedSulfuricAcid.getCells(1),
+                Materials.NitricAcid.getCells(1),
+                GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(AquaRegia.get(cell, 2))
+            .duration(1 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(mixerRecipes);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(
+                Materials.DilutedSulfuricAcid.getCells(1),
+                Materials.NitricAcid.getCells(1),
+                GTUtility.getIntegratedCircuit(2))
+            .itemOutputs(Materials.Empty.getCells(2))
+            .fluidOutputs(AquaRegia.getFluidOrGas(2000))
+            .duration(1 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(mixerRecipes);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(Materials.NitricAcid.getCells(1), GTUtility.getIntegratedCircuit(3))
+            .itemOutputs(Materials.Empty.getCells(1))
+            .fluidInputs(Materials.DilutedSulfuricAcid.getFluid(1000))
+            .fluidOutputs(AquaRegia.getFluidOrGas(2000))
+            .duration(1 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(mixerRecipes);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(Materials.DilutedSulfuricAcid.getCells(1), GTUtility.getIntegratedCircuit(4))
+            .itemOutputs(Materials.Empty.getCells(1))
+            .fluidInputs(Materials.NitricAcid.getFluid(1000))
+            .fluidOutputs(AquaRegia.getFluidOrGas(2000))
+            .duration(1 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(mixerRecipes);
+
+        // AmmoniumChloride
+        // NH3 + HCl = NH4Cl
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(Materials.Ammonia.getCells(1), GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(AmmoniumChloride.get(cell, 1))
+            .fluidInputs(Materials.HydrochloricAcid.getFluid(1000))
+            .duration(15 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(Materials.HydrochloricAcid.getCells(1), GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(Materials.Empty.getCells(1))
+            .fluidInputs(Materials.Ammonia.getGas(1000))
+            .fluidOutputs(AmmoniumChloride.getFluidOrGas(1000))
+            .duration(15 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(GTUtility.getIntegratedCircuit(9))
+            .fluidInputs(Materials.Ammonia.getGas(64000), Materials.HydrochloricAcid.getFluid(64000))
+            .fluidOutputs(AmmoniumChloride.getFluidOrGas(64000))
+            .duration(3 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(multiblockChemicalReactorRecipes);
+
+        // base solution
+        for (Werkstoff w : Werkstoff.werkstoffHashSet) if (w.containsStuff(Materials.Sulfur)
+            && (w.containsStuff(Materials.Copper) || w.containsStuff(Materials.Nickel))) {
+
+                GTValues.RA.stdBuilder()
+                    .itemInputs(w.get(crushedPurified), GTUtility.getIntegratedCircuit(1))
+                    .fluidInputs(AquaRegia.getFluidOrGas(150))
+                    .fluidOutputs(PTConcentrate.getFluidOrGas(150))
+                    .duration(12 * SECONDS + 10 * TICKS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(UniversalChemical);
+
+                GTValues.RA.stdBuilder()
+                    .itemInputs(w.get(crushedPurified, 9), GTUtility.getIntegratedCircuit(9))
+                    .fluidInputs(AquaRegia.getFluidOrGas(1350))
+                    .fluidOutputs(PTConcentrate.getFluidOrGas(1350))
+                    .duration(11 * SECONDS + 5 * TICKS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(UniversalChemical);
+
+                GTValues.RA.stdBuilder()
+                    .itemInputs(w.get(crushedPurified, 9), PTMetallicPowder.get(dust, 9))
+                    .itemOutputs(PTResidue.get(dust))
+                    .fluidInputs(AquaRegia.getFluidOrGas(10350))
+                    .fluidOutputs(PTConcentrate.getFluidOrGas(10350))
+                    .duration(1 * MINUTES + 52 * SECONDS + 10 * TICKS)
+                    .eut(TierEU.RECIPE_LV)
+                    .addTo(UniversalChemical);
+
+            }
+        for (Materials m : Materials.values()) if (PlatinumSludgeOverHaul.materialsContains(m, Materials.Sulfur)
+            && (PlatinumSludgeOverHaul.materialsContains(m, Materials.Copper)
+                || PlatinumSludgeOverHaul.materialsContains(m, Materials.Nickel))) {
+
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTOreDictUnificator.get(crushedPurified, m, 1), GTUtility.getIntegratedCircuit(1))
+                        .fluidInputs(AquaRegia.getFluidOrGas(150))
+                        .fluidOutputs(PTConcentrate.getFluidOrGas(150))
+                        .duration(12 * SECONDS + 10 * TICKS)
+                        .eut(TierEU.RECIPE_LV)
+                        .addTo(UniversalChemical);
+
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTOreDictUnificator.get(crushedPurified, m, 9), GTUtility.getIntegratedCircuit(9))
+                        .fluidInputs(AquaRegia.getFluidOrGas(1350))
+                        .fluidOutputs(PTConcentrate.getFluidOrGas(1350))
+                        .duration(1 * MINUTES + 52 * SECONDS + 10 * TICKS)
+                        .eut(TierEU.RECIPE_LV)
+                        .addTo(UniversalChemical);
+
+                    GTValues.RA.stdBuilder()
+                        .itemInputs(GTOreDictUnificator.get(crushedPurified, m, 9), PTMetallicPowder.get(dust, 9))
+                        .itemOutputs(PTResidue.get(dust))
+                        .fluidInputs(AquaRegia.getFluidOrGas(10350))
+                        .fluidOutputs(PTConcentrate.getFluidOrGas(10350))
+                        .duration(1 * MINUTES + 52 * SECONDS + 10 * TICKS)
+                        .eut(TierEU.RECIPE_LV)
+                        .addTo(UniversalChemical);
+
+                }
+        // Pt
+        GTValues.RA.stdBuilder()
+            .itemInputs(PTMetallicPowder.get(dust, 3), GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(Materials.Platinum.getNuggets(2))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .metadata(COIL_HEAT, Materials.Platinum.mMeltingPoint)
+            .addTo(blastFurnaceRecipes);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(PTMetallicPowder.get(dust), GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(PTResidue.get(dustTiny))
+            .fluidInputs(AquaRegia.getFluidOrGas(1000))
+            .fluidOutputs(PTConcentrate.getFluidOrGas(1000))
+            .duration(12 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(PTMetallicPowder.get(dust, 9), GTUtility.getIntegratedCircuit(9))
+            .itemOutputs(PTResidue.get(dust))
+            .fluidInputs(AquaRegia.getFluidOrGas(9000))
+            .fluidOutputs(PTConcentrate.getFluidOrGas(9000))
+            .duration(1 * MINUTES + 52 * SECONDS + 10 * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(PTConcentrate.get(cell, 2))
+            .itemOutputs(
+                PTSaltCrude.get(dustTiny, 16),
+                PTRawPowder.get(dustTiny, 4),
+                Materials.NitrogenDioxide.getCells(1),
+                Materials.DilutedSulfuricAcid.getCells(1))
+            .fluidInputs(AmmoniumChloride.getFluidOrGas(400))
+            .fluidOutputs(PDAmmonia.getFluidOrGas(400))
+            .duration(60 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(centrifugeRecipes);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(GTUtility.getIntegratedCircuit(1))
+            .itemOutputs(PTSaltCrude.get(dustTiny, 16), PTRawPowder.get(dustTiny, 4))
+            .fluidInputs(PTConcentrate.getFluidOrGas(2000), AmmoniumChloride.getFluidOrGas(400))
+            .fluidOutputs(
+                PDAmmonia.getFluidOrGas(400),
+                Materials.NitrogenDioxide.getGas(1000),
+                Materials.DilutedSulfuricAcid.getFluid(1000))
+            .duration(1200)
+            .eut(30)
+            .addTo(multiblockChemicalReactorRecipes);
+        // transitional recipe. to be removed in 2.8.0 and onwards
+        GTValues.RA.stdBuilder()
+            .itemInputs(GTUtility.getIntegratedCircuit(2))
+            .itemOutputs(PTSaltCrude.get(dust, 16), PTRawPowder.get(dust, 4))
+            .fluidInputs(PTConcentrate.getFluidOrGas(18000), AmmoniumChloride.getFluidOrGas(3600))
+            .fluidOutputs(
+                PDAmmonia.getFluidOrGas(3600),
+                Materials.NitrogenDioxide.getGas(9000),
+                Materials.DilutedSulfuricAcid.getFluid(9000))
+            .duration(1400)
+            .eut(240)
+            .addTo(multiblockChemicalReactorRecipes);
+        GTValues.RA.stdBuilder()
+            .itemInputs(GTUtility.getIntegratedCircuit(3))
+            .itemOutputs(PTSaltCrude.get(dust, 16), PTRawPowder.get(dust, 4))
+            .fluidInputs(PTConcentrate.getFluidOrGas(18000), AmmoniumChloride.getFluidOrGas(3600))
+            .fluidOutputs(
+                PDAmmonia.getFluidOrGas(3600),