From 1b820de08a05070909a267e17f033fcf58ac8710 Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Mon, 2 Sep 2024 23:17:17 +0200 Subject: 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 --- .../material/gtenhancement/BWGTMetaItems.java | 207 ++++ .../material/gtenhancement/GTMetaItemEnhancer.java | 150 +++ .../gtenhancement/PlatinumSludgeOverHaul.java | 1102 ++++++++++++++++++++ 3 files changed, 1459 insertions(+) create mode 100644 src/main/java/bartworks/system/material/gtenhancement/BWGTMetaItems.java create mode 100644 src/main/java/bartworks/system/material/gtenhancement/GTMetaItemEnhancer.java create mode 100644 src/main/java/bartworks/system/material/gtenhancement/PlatinumSludgeOverHaul.java (limited to 'src/main/java/bartworks/system/material/gtenhancement') 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 hiddenThings = new HashSet<>(); + + public BWGTMetaItems(OrePrefixes orePrefixes, List 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 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 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 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 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), + Materials.NitrogenDioxide.getGas(9000), + Materials.DilutedSulfuricAcid.getFluid(9000)) + .duration(700) + .eut(480) + .addTo(multiblockChemicalReactorRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(PTSaltCrude.get(dust)) + .itemOutputs( + PTSaltRefined.get(dust), + PTSaltRefined.get(dust), + PTSaltRefined.get(dust), + PTSaltRefined.get(dust), + PTSaltRefined.get(dust), + PTSaltRefined.get(dust), + PTSaltRefined.get(dust), + PTSaltRefined.get(dust), + PTSaltRefined.get(dust)) + .outputChances(1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1500) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sifterRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(PTSaltRefined.get(dust), GTUtility.getIntegratedCircuit(1)) + .itemOutputs(PTMetallicPowder.get(dust)) + .fluidOutputs(Materials.Chlorine.getGas(87)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 900) + .addTo(blastFurnaceRecipes); + + // 2PtCl + Ca = 2Pt + CaCl2 + + GTValues.RA.stdBuilder() + .itemInputs(PTRawPowder.get(dust, 4), Materials.Calcium.getDust(1)) + .itemOutputs(Materials.Platinum.getDust(2), CalciumChloride.get(dust, 3)) + .duration(1 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + // Pd + + GTValues.RA.stdBuilder() + .itemInputs(PDMetallicPowder.get(dust), GTUtility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Ammonia.getGas(1000)) + .fluidOutputs(PDAmmonia.getFluidOrGas(1000)) + .duration(12 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(PDMetallicPowder.get(dust), GTUtility.getIntegratedCircuit(1)) + .itemOutputs(PDSalt.get(dustTiny, 16), PDRawPowder.get(dustTiny, 2)) + .fluidInputs(PDAmmonia.getFluidOrGas(1000)) + .duration(12 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(PDMetallicPowder.get(dust, 9), GTUtility.getIntegratedCircuit(9)) + .itemOutputs(PDSalt.get(dust, 16), PDRawPowder.get(dust, 2)) + .fluidInputs(PDAmmonia.getFluidOrGas(9000)) + .duration(1 * MINUTES + 52 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(GTUtility.getIntegratedCircuit(2)) + .itemOutputs(PDSalt.get(dust)) + .fluidInputs(PDAmmonia.getFluidOrGas(1000)) + .duration(12 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(PDSalt.get(dust)) + .itemOutputs( + PDMetallicPowder.get(dust), + PDMetallicPowder.get(dust), + PDMetallicPowder.get(dust), + PDMetallicPowder.get(dust), + PDMetallicPowder.get(dust), + PDMetallicPowder.get(dust), + PDMetallicPowder.get(dust), + PDMetallicPowder.get(dust), + PDMetallicPowder.get(dust)) + .outputChances(1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1500) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sifterRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(PDRawPowder.get(dust, 4), Materials.Empty.getCells(1)) + .itemOutputs(Materials.Palladium.getDust(2), Materials.Ethylene.getCells(1)) + .fluidInputs(FormicAcid.getFluidOrGas(4000)) + .fluidOutputs(Materials.Ammonia.getGas(4000)) + .duration(12 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(chemicalReactorRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(PDRawPowder.get(dust, 4)) + .itemOutputs(Materials.Palladium.getDust(2)) + .fluidInputs(FormicAcid.getFluidOrGas(4000)) + .fluidOutputs( + Materials.Ammonia.getGas(4000), + Materials.Ethylene.getGas(1000), + Materials.Water.getFluid(1000)) + .duration(12 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(multiblockChemicalReactorRecipes); + + // Na2SO4 + 2H = 2Na + H2SO4 + + GTValues.RA.stdBuilder() + .itemInputs(Sodiumsulfate.get(dust, 7), Materials.Hydrogen.getCells(2)) + .itemOutputs(Materials.Sodium.getDust(2), Materials.Empty.getCells(2)) + .fluidOutputs(Materials.SulfuricAcid.getFluid(1000)) + .duration(1 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + // Rh/Os/Ir/Ru + GTValues.RA.stdBuilder() + .itemInputs(PTResidue.get(dust), GTUtility.getIntegratedCircuit(11)) + .itemOutputs(LeachResidue.get(dust)) + .fluidInputs(PotassiumDisulfate.getMolten(360)) + .fluidOutputs(RHSulfate.getFluidOrGas(360)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 775) + .addTo(blastFurnaceRecipes); + + // Ru + GTValues.RA.stdBuilder() + .itemInputs(LeachResidue.get(dust, 10), Materials.Saltpeter.getDust(10)) + .itemOutputs(SodiumRuthenate.get(dust, 3), IrOsLeachResidue.get(dust, 6)) + .fluidInputs(Materials.SaltWater.getFluid(1000)) + .fluidOutputs(GTModHandler.getSteam(1000)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 775) + .addTo(blastFurnaceRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(SodiumRuthenate.get(dust, 6), Materials.Chlorine.getCells(3)) + .itemOutputs(Materials.Empty.getCells(3)) + .fluidOutputs(RutheniumTetroxideSollution.getFluidOrGas(9000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(GTUtility.getIntegratedCircuit(1)) + .fluidInputs(RutheniumTetroxideSollution.getFluidOrGas(1000)) + .fluidOutputs(HotRutheniumTetroxideSollution.getFluidOrGas(2000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_HV) + .noOptimize() + .addTo(fluidHeaterRecipes); + + GTValues.RA.stdBuilder() + .itemOutputs(Materials.Salt.getDust(6)) + .fluidInputs(HotRutheniumTetroxideSollution.getFluidOrGas(9000)) + .fluidOutputs(Materials.Water.getFluid(1800), RutheniumTetroxide.getFluidOrGas(7200)) + .duration(1 * MINUTES + 15 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(distillationTowerRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(RutheniumTetroxide.get(dust, 1), Materials.HydrochloricAcid.getCells(6)) + .itemOutputs(Ruthenium.get(dust), Materials.Chlorine.getCells(6)) + .fluidOutputs(Materials.Water.getFluid(2000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + // Os + GTValues.RA.stdBuilder() + .itemInputs(IrOsLeachResidue.get(dust, 4), GTUtility.getIntegratedCircuit(11)) + .itemOutputs(IrLeachResidue.get(dust, 2)) + .fluidInputs(Materials.HydrochloricAcid.getFluid(1000)) + .fluidOutputs(AcidicOsmiumSolution.getFluidOrGas(2000)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 775) + .addTo(blastFurnaceRecipes); + + GTValues.RA.stdBuilder() + .fluidInputs(AcidicOsmiumSolution.getFluidOrGas(1000)) + .fluidOutputs(OsmiumSolution.getFluidOrGas(100), Materials.Water.getFluid(900)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_IV) + .addTo(distillationTowerRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(OsmiumSolution.get(cell), Materials.HydrochloricAcid.getCells(6)) + .itemOutputs(Materials.Osmium.getDust(1), Materials.Chlorine.getCells(7)) + .fluidOutputs(Materials.Water.getFluid(2000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + // Ir + GTValues.RA.stdBuilder() + .itemInputs(IrLeachResidue.get(dust), GTUtility.getIntegratedCircuit(1)) + .itemOutputs(PGSDResidue.get(dust), IridiumDioxide.get(dust)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 775) + .addTo(blastFurnaceRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(IridiumDioxide.get(dust), Materials.HydrochloricAcid.getCells(1)) + .itemOutputs(Materials.Empty.getCells(1)) + .fluidOutputs(AcidicIridiumSolution.getFluidOrGas(1000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(AcidicIridiumSolution.get(cell), AmmoniumChloride.get(cell, 3)) + .itemOutputs(Materials.Empty.getCells(4), IridiumChloride.get(dust)) + .fluidOutputs(Materials.Ammonia.getGas(3000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(IridiumChloride.get(dust), Materials.Calcium.getDust(1)) + .itemOutputs(PGSDResidue2.get(dust), Materials.Iridium.getDust(1)) + .fluidOutputs(CalciumChloride.getFluidOrGas(3000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(UniversalChemical); + // Rh + + GTValues.RA.stdBuilder() + .itemInputs(RHSulfate.get(cell, 11), GTUtility.getIntegratedCircuit(1)) + .itemOutputs(RHSulfateSolution.get(cell, 11), LeachResidue.get(dustTiny, 10)) + .fluidInputs(Materials.Water.getFluid(10000)) + .fluidOutputs(Materials.Potassium.getMolten(2000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(GTUtility.getIntegratedCircuit(3)) + .itemOutputs(LeachResidue.get(dust, 4)) + .fluidInputs(Materials.Water.getFluid(36000), RHSulfate.getFluidOrGas(39600)) + .fluidOutputs(Materials.Potassium.getMolten(7200), RHSulfateSolution.getFluidOrGas(39600)) + .duration(1 * MINUTES) + .eut(TierEU.RECIPE_LV) + .addTo(multiblockChemicalReactorRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(Materials.Zinc.getDust(1)) + .itemOutputs(ZincSulfate.get(dust, 6), CrudeRhMetall.get(dust)) + .fluidInputs(RHSulfateSolution.getFluidOrGas(1000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(CrudeRhMetall.get(dust), Materials.Salt.getDust(1)) + .itemOutputs(RHSalt.get(dust, 3)) + .fluidInputs(Materials.Chlorine.getGas(1000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 600) + .addTo(blastFurnaceRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(RHSalt.get(dust, 10)) + .fluidInputs(Materials.Water.getFluid(2000)) + .fluidOutputs(RHSaltSolution.getFluidOrGas(2000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(mixerRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(SodiumNitrate.get(dust, 5), GTUtility.getIntegratedCircuit(1)) + .itemOutputs(RHNitrate.get(dust), Materials.Salt.getDust(2)) + .fluidInputs(RHSaltSolution.getFluidOrGas(1000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + // Na + HNO3 = NaNO3 + H + + GTValues.RA.stdBuilder() + .itemInputs(Materials.Sodium.getDust(1)) + .itemOutputs(SodiumNitrate.get(dust, 5)) + .fluidInputs(Materials.NitricAcid.getFluid(1000)) + .fluidOutputs(Materials.Hydrogen.getGas(1000)) + .duration(8 * TICKS) + .eut(60) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(RHNitrate.get(dust)) + .itemOutputs( + RhFilterCake.get(dust), + RhFilterCake.get(dust), + RhFilterCake.get(dust), + RhFilterCake.get(dust), + RhFilterCake.get(dust), + RhFilterCake.get(dust), + RhFilterCake.get(dust), + RhFilterCake.get(dust), + RhFilterCake.get(dust)) + .outputChances(1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1500) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sifterRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(RhFilterCake.get(dust)) + .fluidInputs(Materials.Water.getFluid(1000)) + .fluidOutputs(RHFilterCakeSolution.getFluidOrGas(1000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(mixerRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(GTUtility.getIntegratedCircuit(2)) + .itemOutputs(ReRh.get(dust)) + .fluidInputs(RHFilterCakeSolution.getFluidOrGas(1000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GTValues.RA.stdBuilder() + .itemInputs(ReRh.get(dust), Materials.Empty.getCells(1)) + .itemOutputs(Rhodium.get(dust), Materials.Ammonia.getCells(1)) + .fluidInputs(Materials.HydrochloricAcid.getFluid(1000)) + .fluidOutputs(Materials.Chlorine.getGas(1000)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + } + + private static boolean materialsContains(Materials one, ISubTagContainer other) { + if (one == null || one.mMaterialList == null || one.mMaterialList.isEmpty()) return false; + for (MaterialStack stack : one.mMaterialList) if (stack.mMaterial.equals(other)) return true; + return false; + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + public static void replacePureElements() { + // furnace + for (Object entry : FurnaceRecipes.smelting() + .getSmeltingList() + .entrySet()) { + Map.Entry realEntry = (Map.Entry) entry; + if (GTUtility.isStackValid(realEntry.getKey()) + && BWUtil.checkStackAndPrefix((ItemStack) realEntry.getKey())) { + ItemData association = GTOreDictUnificator.getAssociation((ItemStack) realEntry.getKey()); + if (!dust.equals(association.mPrefix) && !dustTiny.equals(association.mPrefix) + || !association.mMaterial.mMaterial.equals(Materials.Platinum)) + if (GTUtility.isStackValid(realEntry.getValue()) + && BWUtil.checkStackAndPrefix((ItemStack) realEntry.getValue())) { + ItemData ass = GTOreDictUnificator.getAssociation((ItemStack) realEntry.getValue()); + if (ass.mMaterial.mMaterial.equals(Materials.Platinum)) + if (!PlatinumSludgeOverHaul.isInBlackList((ItemStack) realEntry.getKey())) + realEntry.setValue( + PTMetallicPowder.get( + ass.mPrefix == nugget ? dustTiny : dust, + ((ItemStack) realEntry.getValue()).stackSize * 2)); + else if (ass.mMaterial.mMaterial.equals(Materials.Palladium)) + if (!PlatinumSludgeOverHaul.isInBlackList((ItemStack) realEntry.getKey())) + realEntry.setValue( + PDMetallicPowder.get( + ass.mPrefix == nugget ? dustTiny : dust, + ((ItemStack) realEntry.getValue()).stackSize * 2)); + } + } + } + // vanilla crafting + CraftingManager.getInstance() + .getRecipeList() + .forEach(PlatinumSludgeOverHaul::setnewMaterialInRecipe); + // gt crafting + GTModHandler.sBufferRecipeList.forEach(PlatinumSludgeOverHaul::setnewMaterialInRecipe); + // gt machines + maploop: for (RecipeMap map : RecipeMap.ALL_RECIPE_MAPS.values()) { + if (map == fusionRecipes || map == unpackagerRecipes + || map == packagerRecipes + || map == replicatorRecipes + || "gt.recipe.eyeofharmony".equals(map.unlocalizedName) + || "gtpp.recipe.quantumforcesmelter".equals(map.unlocalizedName)) continue; + HashSet toDel = new HashSet<>(); + recipeloop: for (GTRecipe recipe : map.getAllRecipes()) { + if (recipe.mFakeRecipe) continue maploop; + + for (int i = 0; i < recipe.mFluidOutputs.length; i++) { + if (map.equals(fluidExtractionRecipes)) continue maploop; + if ("gtpp.recipe.alloyblastsmelter".equals(map.unlocalizedName)) continue maploop; + if (map.equals(multiblockChemicalReactorRecipes) || map.equals(chemicalReactorRecipes)) { + if (GTUtility.areFluidsEqual(Ruthenium.getMolten(1), recipe.mFluidOutputs[i]) + || GTUtility.areFluidsEqual(Rhodium.getMolten(1), recipe.mFluidOutputs[i])) + toDel.add(recipe); + else if (GTUtility.areFluidsEqual(Materials.Iridium.getMolten(1), recipe.mFluidOutputs[i])) { + recipe.mFluidOutputs[i] = AcidicIridiumSolution.getFluidOrGas(1000); + recipe.reloadOwner(); + } else if (GTUtility.areFluidsEqual(Materials.Platinum.getMolten(1), recipe.mFluidOutputs[i])) { + recipe.mFluidOutputs[i] = PTConcentrate.getFluidOrGas(1000); + recipe.reloadOwner(); + } else if (GTUtility.areFluidsEqual(Materials.Osmium.getMolten(1), recipe.mFluidOutputs[i])) { + recipe.mFluidOutputs[i] = AcidicOsmiumSolution.getFluidOrGas(1000); + recipe.reloadOwner(); + } + } else if (GTUtility.areFluidsEqual(Ruthenium.getMolten(1), recipe.mFluidOutputs[i]) + || GTUtility.areFluidsEqual(Rhodium.getMolten(1), recipe.mFluidOutputs[i]) + || GTUtility.areFluidsEqual(Materials.Iridium.getMolten(1), recipe.mFluidOutputs[i]) + || GTUtility.areFluidsEqual(Materials.Platinum.getMolten(1), recipe.mFluidOutputs[i])) + toDel.add(recipe); + else if (GTUtility.areFluidsEqual(Materials.Osmium.getMolten(1), recipe.mFluidOutputs[i])) + toDel.add(recipe); + } + for (int i = 0; i < recipe.mOutputs.length; i++) { + if (!GTUtility.isStackValid(recipe.mOutputs[i])) continue; + if ((BWUtil.areStacksEqualOrNull(Ruthenium.get(dust), recipe.mOutputs[i]) + || BWUtil.areStacksEqualOrNull(Ruthenium.get(dustImpure), recipe.mOutputs[i]) + || BWUtil.areStacksEqualOrNull(Ruthenium.get(dustPure), recipe.mOutputs[i])) + && !BWUtil.areStacksEqualOrNull(Ruthenium.get(ingot), recipe.mInputs[0])) { + for (ItemStack mInput : recipe.mInputs) + if (PlatinumSludgeOverHaul.isInBlackList(mInput)) continue recipeloop; + int amount = recipe.mOutputs[i].stackSize * 2; + recipe.mOutputs[i] = LeachResidue.get(dust, amount); + recipe.reloadOwner(); + } + if ((BWUtil.areStacksEqualOrNull(Rhodium.get(dust), recipe.mOutputs[i]) + || BWUtil.areStacksEqualOrNull(Rhodium.get(dustImpure), recipe.mOutputs[i]) + || BWUtil.areStacksEqualOrNull(Rhodium.get(dustPure), recipe.mOutputs[i])) + && !BWUtil.areStacksEqualOrNull(Rhodium.get(ingot), recipe.mInputs[0])) { + for (ItemStack mInput : recipe.mInputs) + if (PlatinumSludgeOverHaul.isInBlackList(mInput)) continue recipeloop; + int amount = recipe.mOutputs[i].stackSize * 2; + recipe.mOutputs[i] = CrudeRhMetall.get(dust, amount); + recipe.reloadOwner(); + } + if (!BWUtil.checkStackAndPrefix(recipe.mOutputs[i])) continue; + // Pt + if (GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mMaterial.mMaterial + .equals(Materials.Platinum)) { + for (ItemStack mInput : recipe.mInputs) { + if (PlatinumSludgeOverHaul.isInBlackList(mInput)) continue recipeloop; + } + if (dust.equals(GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix) + || dustImpure.equals(GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix) + || dustPure.equals(GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = BWUtil.setStackSize(PTMetallicPowder.get(dust), amount * 2); + recipe.reloadOwner(); + } else if (dustSmall.equals(GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = BWUtil.setStackSize(PTMetallicPowder.get(dustSmall), amount * 2); + recipe.reloadOwner(); + } else if (dustTiny.equals(GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = BWUtil.setStackSize(PTMetallicPowder.get(dustTiny), amount * 2); + recipe.reloadOwner(); + } + } else if (GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mMaterial.mMaterial + .equals(Materials.Palladium)) { + for (ItemStack mInput : recipe.mInputs) { + if (PlatinumSludgeOverHaul.isInBlackList(mInput)) continue recipeloop; + } + if (dust.equals(GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix) + || dustImpure.equals(GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix) + || dustPure.equals(GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = BWUtil.setStackSize(PDMetallicPowder.get(dust), amount * 4); + recipe.reloadOwner(); + } else + if (dustSmall.equals(GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = BWUtil + .setStackSize(PDMetallicPowder.get(dustSmall), amount * 4); + recipe.reloadOwner(); + } else if (dustTiny + .equals(GTOreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = BWUtil + .setS