From 95812474d5a2ccdd7936be618ba7b0f22dfcf5cb Mon Sep 17 00:00:00 2001 From: bartimaeusnek <33183715+bartimaeusnek@users.noreply.github.com> Date: Sat, 28 Sep 2019 21:21:39 +0200 Subject: +added localisation to BioCulture System(add your locale to the GT Language File) (fixes #38) +removed dead AE2 code +applied new prefix logic to the thaum compat +added most of GT Tools and some Electric GT Tools +greatly improved bridge materials +fixed some platinum stuff not giving back the correct dusts +fixed formic acid input loss +moved code in the propper packages Signed-off-by: bartimaeusnek <33183715+bartimaeusnek@users.noreply.github.com> Former-commit-id: cd295221dc66e27a72cddc900e70535ea81c5d54 --- .../github/bartimaeusnek/bartworks/MainMod.java | 2 +- .../bartworks/common/items/LabParts.java | 8 +- .../bartworks/common/loaders/BioCultureLoader.java | 6 + .../bartworks/common/loaders/FluidLoader.java | 2 + .../system/material/BW_MetaGenerated_Items.java | 3 - .../material/GT_Enhancement/LuVTierEnhancer.java | 212 ++++++++ .../GT_Enhancement/PlatinumSludgeOverHaul.java | 570 +++++++++++++++++++++ .../bartworks/system/material/Werkstoff.java | 91 +++- .../bartworks/system/material/WerkstoffLoader.java | 205 ++++++-- .../processingLoaders/AdditionalRecipes.java | 1 + .../processingLoaders/LuVTierEnhancer.java | 211 -------- .../processingLoaders/PlatinumSludgeOverHaul.java | 548 -------------------- .../bartimaeusnek/bartworks/util/BW_ColorUtil.java | 4 +- .../bartimaeusnek/bartworks/util/BioCulture.java | 11 + .../bartimaeusnek/crossmod/BartWorksCrossmod.java | 1 - .../crossmod/ae2/ItemSingleItemStorageCell.java | 244 ++++----- .../thaumcraft/util/ThaumcraftHandler.java | 2 +- .../resources/assets/bartworks/lang/en_US.lang | 4 +- 18 files changed, 1182 insertions(+), 943 deletions(-) create mode 100644 src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/LuVTierEnhancer.java create mode 100644 src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/PlatinumSludgeOverHaul.java delete mode 100644 src/main/java/com/github/bartimaeusnek/bartworks/system/material/processingLoaders/LuVTierEnhancer.java delete mode 100644 src/main/java/com/github/bartimaeusnek/bartworks/system/material/processingLoaders/PlatinumSludgeOverHaul.java (limited to 'src') diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/MainMod.java b/src/main/java/com/github/bartimaeusnek/bartworks/MainMod.java index 6182738f04..b936be1f72 100644 --- a/src/main/java/com/github/bartimaeusnek/bartworks/MainMod.java +++ b/src/main/java/com/github/bartimaeusnek/bartworks/MainMod.java @@ -45,7 +45,7 @@ import com.github.bartimaeusnek.bartworks.system.material.CircuitGeneration.Circ import com.github.bartimaeusnek.bartworks.system.material.ThreadedLoader; import com.github.bartimaeusnek.bartworks.system.material.Werkstoff; import com.github.bartimaeusnek.bartworks.system.material.processingLoaders.DownTierLoader; -import com.github.bartimaeusnek.bartworks.system.material.processingLoaders.PlatinumSludgeOverHaul; +import com.github.bartimaeusnek.bartworks.system.material.GT_Enhancement.PlatinumSludgeOverHaul; import com.github.bartimaeusnek.bartworks.system.oredict.OreDictHandler; import com.github.bartimaeusnek.bartworks.util.BWRecipes; import com.github.bartimaeusnek.bartworks.util.BW_Util; diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/items/LabParts.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/items/LabParts.java index 5aeed95774..675eb4602d 100644 --- a/src/main/java/com/github/bartimaeusnek/bartworks/common/items/LabParts.java +++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/items/LabParts.java @@ -25,6 +25,7 @@ package com.github.bartimaeusnek.bartworks.common.items; import com.github.bartimaeusnek.bartworks.MainMod; import com.github.bartimaeusnek.bartworks.util.BW_ColorUtil; import com.github.bartimaeusnek.bartworks.util.BW_Util; +import com.github.bartimaeusnek.bartworks.util.BioCulture; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; import net.minecraft.creativetab.CreativeTabs; @@ -101,19 +102,20 @@ public class LabParts extends SimpleSubItemClass { return; } + BioCulture culture = BioCulture.getBioCulture(itemStack.getTagCompound().getString("Name")); switch (itemStack.getItemDamage()) { case 0: - list.add(StatCollector.translateToLocal("tooltip.labparts.5.name") + " " + itemStack.getTagCompound().getString("Name")); + list.add(StatCollector.translateToLocal("tooltip.labparts.5.name") + " " + itemStack.getTagCompound().getString("Name") + (culture != null ? " ("+culture.getLocalisedName()+")" : "")); if (!itemStack.getTagCompound().getBoolean("Breedable")) { list.add(StatCollector.translateToLocal("tooltip.labparts.6.name")); } break; case 1: - list.add(StatCollector.translateToLocal("tooltip.labparts.7.name") + " " + itemStack.getTagCompound().getString("Name")); + list.add(StatCollector.translateToLocal("tooltip.labparts.7.name") + " " + itemStack.getTagCompound().getString("Name") + (culture != null ? " ("+culture.getLocalisedName()+")" : "")); break; case 2: - list.add(StatCollector.translateToLocal("tooltip.labparts.8.name") + " " + itemStack.getTagCompound().getString("Name")); + list.add(StatCollector.translateToLocal("tooltip.labparts.8.name") + " " + itemStack.getTagCompound().getString("Name") + (culture != null ? " ("+culture.getLocalisedName()+")" : "")); break; default: break; diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/BioCultureLoader.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/BioCultureLoader.java index 57a9ee9aac..35ad62ae47 100644 --- a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/BioCultureLoader.java +++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/BioCultureLoader.java @@ -54,6 +54,12 @@ public class BioCultureLoader implements Runnable { BioCultureLoader.rottenFleshBacteria = BioCulture.createAndRegisterBioCulture(new Color(110, 40, 25), "Escherichia cadaver", BioPlasmid.convertDataToPlasmid(BioCultureLoader.BIO_DATA_BETA_LACMATASE), BioDNA.convertDataToDNA(BioCultureLoader.BIO_DATA_BETA_LACMATASE), false); BioCultureLoader.eColi = BioCulture.createAndRegisterBioCulture(new Color(149, 132, 75), "Escherichia koli", BioPlasmid.convertDataToPlasmid(BioCultureLoader.eColiData), BioDNA.convertDataToDNA(BioCultureLoader.eColiData), true); BioCultureLoader.anaerobicOil = BioCulture.createAndRegisterBioCulture(new Color(0, 0, 0), "Pseudomonas Veronii", BioPlasmid.convertDataToPlasmid(BioCultureLoader.BIO_DNA_ANAEROBIC_OIL), BioDNA.convertDataToDNA(BioCultureLoader.BIO_DATA_ANAEROBIC_OIL), true); + BioCultureLoader.CommonYeast.setLocalisedName("Common Yeast"); + BioCultureLoader.WhineYeast.setLocalisedName("Whine Yeast"); + BioCultureLoader.BeerYeast.setLocalisedName("Beer Yeast"); + BioCultureLoader.rottenFleshBacteria.setLocalisedName("Rotten Flesh Bacteria"); + BioCultureLoader.eColi.setLocalisedName("eColi Bacteria"); + BioCultureLoader.anaerobicOil.setLocalisedName("Anaerobic Oil Bacteria"); } } diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/FluidLoader.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/FluidLoader.java index 5fa6e23213..09d8292eb6 100644 --- a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/FluidLoader.java +++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/FluidLoader.java @@ -34,6 +34,7 @@ import cpw.mods.fml.common.registry.GameRegistry; import gregtech.api.enums.GT_Values; import gregtech.api.enums.Materials; import gregtech.api.objects.GT_Fluid; +import gregtech.api.util.GT_LanguageManager; import gregtech.api.util.GT_Utility; import ic2.core.item.ItemFluidCell; import net.minecraft.block.Block; @@ -86,6 +87,7 @@ public class FluidLoader implements Runnable { if (B.isBreedable()) { B.setFluid(new GT_Fluid(B.getName().replaceAll(" ", "").toLowerCase() + "fluid", "molten.autogenerated", new short[]{(short) B.getColor().getRed(), (short) B.getColor().getBlue(), (short) B.getColor().getGreen()})); FluidRegistry.registerFluid(B.getFluid()); + GT_LanguageManager.addStringLocalization(B.getFluid().getUnlocalizedName(), B.getLocalisedName()+" Fluid"); GT_Values.RA.addCentrifugeRecipe(GT_Utility.getIntegratedCircuit(10),GT_Values.NI,new FluidStack(B.getFluid(),1000),dnaFluid,GT_Values.NI,GT_Values.NI,GT_Values.NI,GT_Values.NI,GT_Values.NI,GT_Values.NI,null,500,120); } } diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/system/material/BW_MetaGenerated_Items.java b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/BW_MetaGenerated_Items.java index 29b98c9506..6f0365d412 100644 --- a/src/main/java/com/github/bartimaeusnek/bartworks/system/material/BW_MetaGenerated_Items.java +++ b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/BW_MetaGenerated_Items.java @@ -33,8 +33,6 @@ 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.items.GT_MetaGenerated_Item; import gregtech.api.util.GT_LanguageManager; @@ -57,7 +55,6 @@ import net.minecraft.util.MathHelper; import net.minecraft.util.StatCollector; import net.minecraft.world.World; -import java.util.HashMap; import java.util.List; import static com.github.bartimaeusnek.bartworks.system.material.Werkstoff.werkstoffHashMap; diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/LuVTierEnhancer.java b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/LuVTierEnhancer.java new file mode 100644 index 0000000000..ee1f6b3b57 --- /dev/null +++ b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/LuVTierEnhancer.java @@ -0,0 +1,212 @@ +/* + * Copyright (c) 2019 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 com.github.bartimaeusnek.bartworks.system.material.GT_Enhancement; + +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; +import com.github.bartimaeusnek.bartworks.system.material.processingLoaders.AfterLuVTierEnhacement; +import com.github.bartimaeusnek.bartworks.util.BW_Util; +import cpw.mods.fml.common.Loader; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.objects.ItemData; +import gregtech.api.util.*; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.CraftingManager; +import net.minecraft.item.crafting.IRecipe; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import org.apache.commons.lang3.reflect.FieldUtils; +import org.apache.commons.lang3.reflect.MethodUtils; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; + +import static gregtech.api.enums.OrePrefixes.*; + +public class LuVTierEnhancer implements Runnable { + + public void run() { + LuVTierEnhancer.replaceAsslineRecipes(); + List bufferedRecipeList = null; + try { + bufferedRecipeList = (List) FieldUtils.getDeclaredField(GT_ModHandler.class, "sBufferRecipeList", true).get(null); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + assert bufferedRecipeList != null; + + HashSet LuVMachines = new HashSet<>(); + OrePrefixes[] LuVMaterialsGenerated = {dust, ingot, plate, stick, stickLong, rotor, plateDouble, plateDense}; + for (ItemList item : ItemList.values()) { + if (item.toString().contains("LuV") && item.hasBeenSet()) + LuVMachines.add(item.get(1)); + } + if (Loader.isModLoaded("dreamcraft")) { + try { + Class customItemListClass = Class.forName("com.dreammaster.gthandler.CustomItemList"); + Method hasnotBeenSet = MethodUtils.getAccessibleMethod(customItemListClass, "hasBeenSet"); + Method get = MethodUtils.getAccessibleMethod(customItemListClass, "get", long.class, Object[].class); + for (Enum customItemList : (Enum[]) FieldUtils.getField(customItemListClass, "$VALUES", true).get(null)) { + if (customItemList.toString().contains("LuV") && (boolean) hasnotBeenSet.invoke(customItemList)) + LuVMachines.add((ItemStack) get.invoke(customItemList, 1, new Object[0])); + } + } catch (IllegalAccessException | ClassNotFoundException | InvocationTargetException e) { + e.printStackTrace(); + } + } + GT_ModHandler.addCraftingRecipe(ItemList.Casing_LuV.get(1), GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.DELETE_ALL_OTHER_RECIPES, new Object[]{"PPP", "PwP", "PPP", 'P', WerkstoffLoader.LuVTierMaterial.get(plate)}); + for (ItemStack stack : LuVMachines) { + for (GT_Recipe.GT_Recipe_Map map : GT_Recipe.GT_Recipe_Map.sMappings) { + for (GT_Recipe recipe : map.mRecipeList) { + for (OrePrefixes prefixes : LuVMaterialsGenerated) { + if (LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, stack, false)) { + LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes)); + LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes)); + } + if (LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, stack, false)) { + LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes)); + LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes)); + } + } + if (LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, stack, false)) { + LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidInputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid()); + LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidOutputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid()); + } + if (LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, stack, false)) { + LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidInputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid()); + LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidOutputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid()); + } + } + } + for (OrePrefixes prefixes : LuVMaterialsGenerated) { + for (Object obj : CraftingManager.getInstance().getRecipeList()) { + if (!(obj instanceof GT_Shaped_Recipe)) + continue; + if (GT_Utility.areStacksEqual(((GT_Shaped_Recipe) obj).getRecipeOutput(), stack, true)) { + LuVTierEnhancer.doStacksCointainAndReplace(((GT_Shaped_Recipe) obj).getInput(), GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes)); + } + } + for (Object obj : bufferedRecipeList) { + if (!(obj instanceof GT_Shaped_Recipe)) + continue; + if (GT_Utility.areStacksEqual(((GT_Shaped_Recipe) obj).getRecipeOutput(), stack, true)) { + LuVTierEnhancer.doStacksCointainAndReplace(((GT_Shaped_Recipe) obj).getInput(), GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes)); + } + } + } + } + new AfterLuVTierEnhacement().run(); + } + + private static void replaceAsslineRecipes(){ + for (GT_Recipe.GT_Recipe_AssemblyLine recipe_assemblyLine : GT_Recipe.GT_Recipe_AssemblyLine.sAssemblylineRecipes){ + if (recipe_assemblyLine.mEUt > 6000) + continue; + for (int i = 0; i < recipe_assemblyLine.mInputs.length; i++) { + ItemStack stack = recipe_assemblyLine.mInputs[i]; + if (!BW_Util.checkStackAndPrefix(stack)) + continue; + ItemData ass = GT_OreDictUnificator.getAssociation(stack); + if (ass.mMaterial.mMaterial.equals(Materials.Osmiridium)) + if (WerkstoffLoader.items.get(ass.mPrefix) != null) + recipe_assemblyLine.mInputs[i] = WerkstoffLoader.Ruridit.get(ass.mPrefix,stack.stackSize); + } + } + for (GT_Recipe recipe_assemblyLine : GT_Recipe.GT_Recipe_Map.sAssemblerRecipes.mRecipeList){ + if (recipe_assemblyLine.mEUt > BW_Util.getTierVoltage(6)) + continue; + if (BW_Util.checkStackAndPrefix(recipe_assemblyLine.mOutputs[0])) + continue; + for (int i = 0; i < recipe_assemblyLine.mInputs.length; i++) { + ItemStack stack = recipe_assemblyLine.mInputs[i]; + if (!BW_Util.checkStackAndPrefix(stack)) + continue; + ItemData ass = GT_OreDictUnificator.getAssociation(stack); + if (ass.mMaterial.mMaterial.equals(Materials.Osmiridium)) + if (WerkstoffLoader.items.get(ass.mPrefix) != null) + recipe_assemblyLine.mInputs[i] = WerkstoffLoader.Ruridit.get(ass.mPrefix, stack.stackSize); + } + } + for (GT_Recipe recipe_assemblyLine : GT_Recipe.GT_Recipe_Map.sAssemblylineVisualRecipes.mRecipeList){ + if (recipe_assemblyLine.mEUt > 6000) + continue; + for (int i = 0; i < recipe_assemblyLine.mInputs.length; i++) { + ItemStack stack = recipe_assemblyLine.mInputs[i]; + if (!BW_Util.checkStackAndPrefix(stack)) + continue; + ItemData ass = GT_OreDictUnificator.getAssociation(stack); + if (ass.mMaterial.mMaterial.equals(Materials.Osmiridium)) + if (WerkstoffLoader.items.get(ass.mPrefix) != null) + recipe_assemblyLine.mInputs[i] = WerkstoffLoader.Ruridit.get(ass.mPrefix,stack.stackSize); + } + } + } + + private static boolean doStacksCointainAndReplace(FluidStack[] stacks, FluidStack stack, boolean replace, Fluid... replacement) { + boolean replaced = false; + for (int i = 0; i < stacks.length; i++) { + if (GT_Utility.areFluidsEqual(stack, stacks[i])) + if (!replace) + return true; + else { + int amount = stacks[i].amount; + stacks[i] = new FluidStack(replacement[0], amount); + replaced = true; + } + } + return replaced; + } + + private static boolean doStacksCointainAndReplace(Object[] stacks, ItemStack stack, boolean replace, ItemStack... replacement) { + boolean replaced = false; + for (int i = 0; i < stacks.length; i++) { + if (!GT_Utility.isStackValid(stacks[i])) { + if (stacks[i] instanceof ArrayList && ((ArrayList)stacks[i]).size() > 0) { + if (GT_Utility.areStacksEqual(stack, (ItemStack) ((ArrayList)stacks[i]).get(0), true)) + if (!replace) + return true; + else { + int amount = ((ItemStack) ((ArrayList)stacks[i]).get(0)).stackSize; + stacks[i] = new ArrayList<>(); + ((ArrayList)stacks[i]).add(replacement[0].splitStack(amount)); + replaced = true; + } + + } else + continue; + } else if (GT_Utility.areStacksEqual(stack, (ItemStack) stacks[i], true)) + if (!replace) + return true; + else { + int amount = ((ItemStack) stacks[i]).stackSize; + stacks[i] = replacement[0].splitStack(amount); + replaced = true; + } + } + return replaced; + } +} diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/PlatinumSludgeOverHaul.java b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/PlatinumSludgeOverHaul.java new file mode 100644 index 0000000000..6427b827f3 --- /dev/null +++ b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/PlatinumSludgeOverHaul.java @@ -0,0 +1,570 @@ +/* + * Copyright (c) 2019 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 com.github.bartimaeusnek.bartworks.system.material.GT_Enhancement; + +import com.github.bartimaeusnek.bartworks.MainMod; +import com.github.bartimaeusnek.bartworks.system.material.BW_MetaGenerated_Items; +import com.github.bartimaeusnek.bartworks.system.material.Werkstoff; +import com.github.bartimaeusnek.bartworks.util.BW_Util; +import com.github.bartimaeusnek.crossmod.BartWorksCrossmod; +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.ISubTagContainer; +import gregtech.api.items.GT_Generic_Block; +import gregtech.api.items.GT_Generic_Item; +import gregtech.api.objects.ItemData; +import gregtech.api.objects.MaterialStack; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gregtech.common.blocks.GT_Block_Ores_Abstract; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.*; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.ShapedOreRecipe; +import net.minecraftforge.oredict.ShapelessOreRecipe; +import org.apache.commons.lang3.reflect.FieldUtils; + +import java.lang.reflect.Field; +import java.util.*; + +import static com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader.*; +import static gregtech.api.enums.OrePrefixes.*; + +public class PlatinumSludgeOverHaul { + private static final Materials[] BLACKLIST = { + Materials.HSSS, + Materials.EnderiumBase, + Materials.Osmiridium, + 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 + GT_Values.RA.addMixerRecipe(Materials.SulfuricAcid.getCells(3), Materials.Water.getCells(1), GT_Utility.getIntegratedCircuit(1), null, null, null, Materials.DilutedSulfuricAcid.getCells(4), 30, 30); + GT_Values.RA.addMixerRecipe(Materials.Water.getCells(1), GT_Utility.getIntegratedCircuit(1), null, null, Materials.SulfuricAcid.getFluid(3000), Materials.DilutedSulfuricAcid.getFluid(4000), Materials.Empty.getCells(1), 30, 30); + GT_Values.RA.addMixerRecipe(Materials.SulfuricAcid.getCells(3), GT_Utility.getIntegratedCircuit(1), null, null, Materials.Water.getFluid(1000), Materials.DilutedSulfuricAcid.getFluid(4000), Materials.Empty.getCells(3), 30, 30); + //FormicAcid + GT_Values.RA.addChemicalRecipe(Materials.CarbonMonoxide.getCells(1), Materials.SodiumHydroxide.getDust(1), null, null, Sodiumformate.get(cell), null, 15); + GT_Values.RA.addChemicalRecipe(Sodiumformate.get(cell, 2), GT_Utility.getIntegratedCircuit(1), Materials.SulfuricAcid.getFluid(1000), null, FormicAcid.get(cell, 2), Sodiumsulfate.get(dust, 7), 15); + GT_Values.RA.addChemicalRecipe(Materials.SulfuricAcid.getCells(1), GT_Utility.getIntegratedCircuit(1), Sodiumformate.getFluidOrGas(2000), FormicAcid.getFluidOrGas(2000), Materials.Empty.getCells(1), Sodiumsulfate.get(dust, 7), 15); + //AquaRegia + GT_Values.RA.addMixerRecipe(Materials.DilutedSulfuricAcid.getCells(1), Materials.NitricAcid.getCells(1), GT_Utility.getIntegratedCircuit(1), null, null, null, AquaRegia.get(cell, 2), 30, 30); + GT_Values.RA.addMixerRecipe(Materials.DilutedSulfuricAcid.getCells(1), Materials.NitricAcid.getCells(1), GT_Utility.getIntegratedCircuit(2), null, null, AquaRegia.getFluidOrGas(2000), Materials.Empty.getCells(2), 30, 30); + GT_Values.RA.addMixerRecipe(Materials.NitricAcid.getCells(1), GT_Utility.getIntegratedCircuit(3), null, null, Materials.DilutedSulfuricAcid.getFluid(1000), AquaRegia.getFluidOrGas(2000), Materials.Empty.getCells(1), 30, 30); + GT_Values.RA.addMixerRecipe(Materials.DilutedSulfuricAcid.getCells(1), GT_Utility.getIntegratedCircuit(4), null, null, Materials.NitricAcid.getFluid(1000), AquaRegia.getFluidOrGas(2000), Materials.Empty.getCells(1), 30, 30); + + //AmmoniumCloride + GT_Values.RA.addChemicalRecipe(Materials.Ammonia.getCells(1), GT_Utility.getIntegratedCircuit(1), Materials.HydrochloricAcid.getFluid(1000), null, AmmoniumChloride.get(cell, 1), null, 15); + GT_Values.RA.addChemicalRecipe(Materials.HydrochloricAcid.getCells(1), GT_Utility.getIntegratedCircuit(1), Materials.Ammonia.getGas(1000), AmmoniumChloride.getFluidOrGas(1000), Materials.Empty.getCells(1), null, 15); + + //base sollution + for (Werkstoff w : Werkstoff.werkstoffHashSet) + if (w.containsStuff(Materials.Sulfur) && (w.containsStuff(Materials.Copper) || w.containsStuff(Materials.Nickel))) { + GT_Values.RA.addChemicalRecipe(w.get(crushedPurified), GT_Utility.getIntegratedCircuit(1), AquaRegia.getFluidOrGas(150), PTConcentrate.getFluidOrGas(150), null, 250); + GT_Values.RA.addChemicalRecipe(w.get(crushedPurified), PTMetallicPowder.get(dust), AquaRegia.getFluidOrGas(1150), PTConcentrate.getFluidOrGas(1150), PTResidue.get(dustTiny), 250); + } + for (Materials m : Materials.values()) + if (PlatinumSludgeOverHaul.materialsContains(m, Materials.Sulfur) && (PlatinumSludgeOverHaul.materialsContains(m, Materials.Copper) || PlatinumSludgeOverHaul.materialsContains(m, Materials.Nickel))) { + GT_Values.RA.addChemicalRecipe(GT_OreDictUnificator.get(crushedPurified, m, 1), GT_Utility.getIntegratedCircuit(1), AquaRegia.getFluidOrGas(150), PTConcentrate.getFluidOrGas(150), null, 250); + GT_Values.RA.addChemicalRecipe(GT_OreDictUnificator.get(crushedPurified, m, 1), PTMetallicPowder.get(dust), AquaRegia.getFluidOrGas(1150), PTConcentrate.getFluidOrGas(1150), PTResidue.get(dustTiny), 250); + } + //Pt + GT_Values.RA.addBlastRecipe(PTMetallicPowder.get(dust, 3), GT_Utility.getIntegratedCircuit(1), null, null, Materials.Platinum.getNuggets(2), null, 600, 120, Materials.Platinum.mMeltingPoint); + + GT_Values.RA.addChemicalRecipe(PTMetallicPowder.get(dust), GT_Utility.getIntegratedCircuit(1), AquaRegia.getFluidOrGas(1000), PTConcentrate.getFluidOrGas(1000), PTResidue.get(dustTiny), 250); + GT_Values.RA.addCentrifugeRecipe(PTConcentrate.get(cell,2),null, AmmoniumChloride.getFluidOrGas(200), PDAmmonia.getFluidOrGas(200), PTSaltCrude.get(dustTiny, 18), PTRawPowder.get(dustTiny,2), Materials.NitrogenDioxide.getCells(1), Materials.DilutedSulfuricAcid.getCells(1), null, null, null, 1200, 30); + GT_Values.RA.addMultiblockChemicalRecipe(new ItemStack[]{}, new FluidStack[]{PTConcentrate.getFluidOrGas(2000), AmmoniumChloride.getFluidOrGas(200)}, new FluidStack[]{PDAmmonia.getFluidOrGas(200), Materials.NitrogenDioxide.getGas(1000),Materials.DilutedSulfuricAcid.getFluid(1000)}, new ItemStack[]{PTSaltCrude.get(dustTiny, 16), PTRawPowder.get(dustTiny,2)}, 1200, 30); + GT_Values.RA.addSifterRecipe(PTSaltCrude.get(dust), new ItemStack[]{ + 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), + }, new int[]{ + 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1500, + }, 600, 30); + GT_Values.RA.addBlastRecipe(PTSaltRefined.get(dust), GT_Utility.getIntegratedCircuit(1), null, Materials.Chlorine.getGas(87), PTMetallicPowder.get(dust), null, 200, 120, 900); + GT_Values.RA.addChemicalRecipe(PTRawPowder.get(dust, 2), Materials.Calcium.getDust(1), null, null, Materials.Platinum.getDust(2), CalciumChloride.get(dust), 30); + //Pd + GT_Values.RA.addChemicalRecipe(PDMetallicPowder.get(dust), GT_Utility.getIntegratedCircuit(1), Materials.Ammonia.getGas(1000), PDAmmonia.getFluidOrGas(1000), null, 250); + GT_Values.RA.addChemicalRecipe(PDMetallicPowder.get(dust), GT_Utility.getIntegratedCircuit(1), PDAmmonia.getFluidOrGas(1000), null, PDSalt.get(dustTiny, 16), PDRawPowder.get(dustTiny, 2), 250); + GT_Values.RA.addChemicalRecipe(GT_Utility.getIntegratedCircuit(2), null, PDAmmonia.getFluidOrGas(1000), null, PDSalt.get(dust), 250); + GT_Values.RA.addSifterRecipe(PDSalt.get(dust), new ItemStack[]{ + 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), + }, new int[]{ + 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1500, + }, 600, 30); + GT_Values.RA.addChemicalRecipeForBasicMachineOnly(PDRawPowder.get(dust, 2), Materials.Empty.getCells(1), FormicAcid.getFluidOrGas(4000), Materials.Ammonia.getGas(2000), Materials.Palladium.getDust(2), Materials.Ethylene.getCells(1), 250, 30); + GT_Values.RA.addMultiblockChemicalRecipe(new ItemStack[]{PDRawPowder.get(dust, 2)}, new FluidStack[]{FormicAcid.getFluidOrGas(4000)}, new FluidStack[]{Materials.Ammonia.getGas(2000), Materials.Ethylene.getGas(1000), Materials.Water.getFluid(1000)}, new ItemStack[]{Materials.Palladium.getDust(2)}, 250, 30); + GT_Values.RA.addChemicalRecipe(Sodiumsulfate.get(dust, 2), Materials.Hydrogen.getCells(1), null, Materials.SulfuricAcid.getFluid(2000), Materials.Sodium.getDust(1), Materials.Empty.getCells(3), 30); + //K2S2O7 + // GT_Values.RA.addChemicalRecipe(Sodiumsulfate.get(dust), Materials.Potassium.getDust(2), Materials.Oxygen.getGas(3000), null, PotassiumDisulfate.get(dust,6), null, 30); + //Rh/Os/Ir/Ru + GT_Values.RA.addBlastRecipe(PTResidue.get(dust), GT_Utility.getIntegratedCircuit(11), PotassiumDisulfate.getMolten(1440), RHSulfate.getFluidOrGas(1440), LeachResidue.get(dust), null, 200, 120, 775); + + //Ru + GT_Values.RA.addBlastRecipe(LeachResidue.get(dust, 10), Materials.Saltpeter.getDust(10), Materials.SaltWater.getFluid(1000), GT_ModHandler.getSteam(1000), SodiumRuthenate.get(dust, 3), IrOsLeachResidue.get(dust, 6), 200, 120, 775); + GT_Values.RA.addChemicalRecipe(SodiumRuthenate.get(dust, 6), Materials.Chlorine.getCells(3), null, RutheniumTetroxideSollution.getFluidOrGas(9000), Materials.Empty.getCells(3), 300); + GT_Values.RA.addFluidHeaterRecipe(GT_Utility.getIntegratedCircuit(1), RutheniumTetroxideSollution.getFluidOrGas(800), HotRutheniumTetroxideSollution.getFluidOrGas(800), 300, 480); + GT_Values.RA.addCrackingRecipe(17, RutheniumTetroxideSollution.getFluidOrGas(1000), GT_ModHandler.getSteam(1000), HotRutheniumTetroxideSollution.getFluidOrGas(2000), 150, 480); + GT_Values.RA.addDistillationTowerRecipe(HotRutheniumTetroxideSollution.getFluidOrGas(9000), new FluidStack[]{ + Materials.Water.getFluid(1800), + RutheniumTetroxide.getFluidOrGas(7200) + }, Materials.Salt.getDust(6), 1500, 480); + GT_Values.RA.addChemicalRecipe(RutheniumTetroxide.get(dust, 1), Materials.HydrochloricAcid.getCells(6), null, Materials.Water.getFluid(2000), Ruthenium.get(dust), Materials.Chlorine.getCells(6), 300); + + //Os + GT_Values.RA.addBlastRecipe(IrOsLeachResidue.get(dust, 4), GT_Utility.getIntegratedCircuit(11), Materials.HydrochloricAcid.getFluid(1000), AcidicOsmiumSolution.getFluidOrGas(2000), IrLeachResidue.get(dust, 2), null, 200, 120, 775); + GT_Values.RA.addDistillationTowerRecipe(AcidicOsmiumSolution.getFluidOrGas(1000), new FluidStack[]{OsmiumSolution.getFluidOrGas(100), Materials.Water.getFluid(900)}, null, 150, BW_Util.getMachineVoltageFromTier(5)); + GT_Values.RA.addChemicalRecipe(OsmiumSolution.get(cell), Materials.HydrochloricAcid.getCells(6), null, Materials.Water.getFluid(2000), Materials.Osmium.getDust(1), Materials.Chlorine.getCells(7), 300); + + //Ir + GT_Values.RA.addBlastRecipe(IrLeachResidue.get(dust), GT_Utility.getIntegratedCircuit(1), null, null, PGSDResidue.get(dust), IridiumDioxide.get(dust), 200, 120, 775); + GT_Values.RA.addChemicalRecipe(IridiumDioxide.get(dust), Materials.HydrochloricAcid.getCells(1), null, AcidicIridiumSolution.getFluidOrGas(1000), Materials.Empty.getCells(1), null, 300); + GT_Values.RA.addChemicalRecipe(AcidicIridiumSolution.get(cell), AmmoniumChloride.get(cell, 3), null, Materials.Ammonia.getGas(3000), Materials.Empty.getCells(4), IridiumChloride.get(dust), 300); + GT_Values.RA.addChemicalRecipe(IridiumChloride.get(dust), Materials.Calcium.getDust(3), null, CalciumChloride.getFluidOrGas(3000), PGSDResidue2.get(dust), Materials.Iridium.getDust(1), 300, 1920); + + //Rh + GT_Values.RA.addChemicalRecipe(RHSulfate.get(cell, 11), GT_Utility.getIntegratedCircuit(1), Materials.Water.getFluid(10000), Materials.Potassium.getMolten(2000), RHSulfateSolution.get(cell, 11), LeachResidue.get(dustTiny, 10), 300, 30); + + GT_Values.RA.addChemicalRecipe(Materials.Zinc.getDust(1), null, RHSulfateSolution.getFluidOrGas(1000), null, ZincSulfate.get(dust), CrudeRhMetall.get(dust), 300); + GT_Values.RA.addBlastRecipe(CrudeRhMetall.get(dust), Materials.Salt.getDust(1), Materials.Chlorine.getGas(1000), null, RHSalt.get(dust, 3), null, 300, 120, 600); + GT_Values.RA.addMixerRecipe(RHSalt.get(dust, 10), null, null, null, Materials.Water.getFluid(2000), RHSaltSolution.getFluidOrGas(2000), null, 300, 30); + GT_Values.RA.addChemicalRecipe(SodiumNitrate.get(dust), GT_Utility.getIntegratedCircuit(1), RHSaltSolution.getFluidOrGas(1000), null, RHNitrate.get(dust), Materials.Salt.getDust(1), 300); + GT_Values.RA.addSifterRecipe(RHNitrate.get(dust), new ItemStack[]{ + 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), + }, new int[]{ + 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1500, + }, 600, 30); + GT_Values.RA.addMixerRecipe(RhFilterCake.get(dust), null, null, null, Materials.Water.getFluid(1000), RHFilterCakeSolution.getFluidOrGas(1000), null, 300, 30); + GT_Values.RA.addChemicalRecipe(GT_Utility.getIntegratedCircuit(2), null, RHFilterCakeSolution.getFluidOrGas(1000), null, ReRh.get(dust), null, 300); + GT_Values.RA.addChemicalRecipe(ReRh.get(dust), Materials.Empty.getCells(1), Materials.HydrochloricAcid.getFluid(1000), Materials.Chlorine.getGas(1000), Rhodium.get(dust), Materials.Ammonia.getCells(1), 300); + } + + 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; + } + + public static void replacePureElements() { + //furnace + for (Object entry : FurnaceRecipes.smelting().getSmeltingList().entrySet()) { + Map.Entry realEntry = (Map.Entry) entry; + if (GT_Utility.isStackValid(realEntry.getKey()) && BW_Util.checkStackAndPrefix((ItemStack) realEntry.getKey())) + if ((!GT_OreDictUnificator.getAssociation((ItemStack) realEntry.getKey()).mPrefix.equals(dust) && !GT_OreDictUnificator.getAssociation((ItemStack) realEntry.getKey()).mPrefix.equals(dustTiny)) || !GT_OreDictUnificator.getAssociation((ItemStack) realEntry.getKey()).mMaterial.mMaterial.equals(Materials.Platinum)) + if (GT_Utility.isStackValid(realEntry.getValue()) && BW_Util.checkStackAndPrefix((ItemStack) realEntry.getValue())){ + ItemData ass = GT_OreDictUnificator.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 + try { + ((List) FieldUtils.getDeclaredField(GT_ModHandler.class, "sBufferRecipeList", true).get(null)).forEach(PlatinumSludgeOverHaul::setnewMaterialInRecipe); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + //gt machines + maploop: + for (GT_Recipe.GT_Recipe_Map map : GT_Recipe.GT_Recipe_Map.sMappings) { + if (map == GT_Recipe.GT_Recipe_Map.sUnboxinatorRecipes || map == GT_Recipe.GT_Recipe_Map.sBoxinatorRecipes) + continue; + HashSet toDel = new HashSet(); + recipeloop: + for (GT_Recipe recipe : map.mRecipeList) { + if (recipe.mFakeRecipe) + continue maploop; + + for (int i = 0; i < recipe.mFluidOutputs.length; i++) { + if (map.equals(GT_Recipe.GT_Recipe_Map.sFluidExtractionRecipes)) + continue maploop; + else if (map.equals(GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes) || map.equals(GT_Recipe.GT_Recipe_Map.sChemicalRecipes)) { + if (GT_Utility.areFluidsEqual(Ruthenium.getMolten(1), recipe.mFluidOutputs[i])) + toDel.add(recipe); + else if (GT_Utility.areFluidsEqual(Rhodium.getMolten(1), recipe.mFluidOutputs[i])) + toDel.add(recipe); + else if (GT_Utility.areFluidsEqual(Materials.Iridium.getMolten(1), recipe.mFluidOutputs[i])) + recipe.mFluidOutputs[i] = Materials.Water.getFluid(1000); + else if (GT_Utility.areFluidsEqual(Materials.Platinum.getMolten(1), recipe.mFluidOutputs[i])) + recipe.mFluidOutputs[i] = Materials.Water.getFluid(1000); + else if (GT_Utility.areFluidsEqual(Materials.Osmium.getMolten(1), recipe.mFluidOutputs[i])) + recipe.mFluidOutputs[i] = Materials.Water.getFluid(1000); + } else { + if (GT_Utility.areFluidsEqual(Ruthenium.getMolten(1), recipe.mFluidOutputs[i])) + toDel.add(recipe); + else if (GT_Utility.areFluidsEqual(Rhodium.getMolten(1), recipe.mFluidOutputs[i])) + toDel.add(recipe); + else if (GT_Utility.areFluidsEqual(Materials.Iridium.getMolten(1), recipe.mFluidOutputs[i])) + toDel.add(recipe); + else if (GT_Utility.areFluidsEqual(Materials.Platinum.getMolten(1), recipe.mFluidOutputs[i])) + toDel.add(recipe); + else if (GT_Utility.areFluidsEqual(Materials.Osmium.getMolten(1), recipe.mFluidOutputs[i])) + toDel.add(recipe); + } + } + for (int i = 0; i < recipe.mOutputs.length; i++) { + if (!GT_Utility.isStackValid(recipe.mOutputs[i])) + continue; + if (BW_Util.areStacksEqualOrNull(Ruthenium.get(dust), recipe.mOutputs[i]) || BW_Util.areStacksEqualOrNull(Ruthenium.get(dustImpure), recipe.mOutputs[i]) || BW_Util.areStacksEqualOrNull(Ruthenium.get(dustPure), recipe.mOutputs[i])) { + if (!BW_Util.areStacksEqualOrNull(Ruthenium.get(ingot), recipe.mInputs[0])) { + for (int j = 0; j < recipe.mInputs.length; j++) + if (PlatinumSludgeOverHaul.isInBlackList(recipe.mInputs[j])) + continue recipeloop; + int amount = recipe.mOutputs[i].stackSize * 2; + recipe.mOutputs[i] = LeachResidue.get(dust, amount); + } + } + if (BW_Util.areStacksEqualOrNull(Rhodium.get(dust), recipe.mOutputs[i]) || BW_Util.areStacksEqualOrNull(Rhodium.get(dustImpure), recipe.mOutputs[i]) || BW_Util.areStacksEqualOrNull(Rhodium.get(dustPure), recipe.mOutputs[i])) { + if (!BW_Util.areStacksEqualOrNull(Rhodium.get(ingot), recipe.mInputs[0])) { + for (int j = 0; j < recipe.mInputs.length; j++) + if (PlatinumSludgeOverHaul.isInBlackList(recipe.mInputs[j])) + continue recipeloop; + int amount = recipe.mOutputs[i].stackSize * 2; + recipe.mOutputs[i] = CrudeRhMetall.get(dust, amount); + } + } + if (!BW_Util.checkStackAndPrefix(recipe.mOutputs[i])) + continue; + //Pt + if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mMaterial.mMaterial.equals(Materials.Platinum)) { + for (int j = 0; j < recipe.mInputs.length; j++) { + if (PlatinumSludgeOverHaul.isInBlackList(recipe.mInputs[j])) + continue recipeloop; + } + if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dust) || GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustImpure) || GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustPure)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = PTMetallicPowder.get(dust).splitStack(amount * 2); + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustSmall)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = PTMetallicPowder.get(dustSmall).splitStack(amount * 2); + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustTiny)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = PTMetallicPowder.get(dustTiny).splitStack(amount * 2); + } + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mMaterial.mMaterial.equals(Materials.Palladium)) { + for (int j = 0; j < recipe.mInputs.length; j++) { + if (PlatinumSludgeOverHaul.isInBlackList(recipe.mInputs[j])) + continue recipeloop; + } + if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dust) || GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustImpure) || GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustPure)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = PDMetallicPowder.get(dust).splitStack(amount * 2); + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustSmall)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = PDMetallicPowder.get(dustSmall).splitStack(amount * 2); + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustTiny)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = PDMetallicPowder.get(dustTiny).splitStack(amount * 2); + } + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mMaterial.mMaterial.equals(Materials.Osmium)) { + for (int j = 0; j < recipe.mInputs.length; j++) { + if (PlatinumSludgeOverHaul.isInBlackList(recipe.mInputs[j])) + continue recipeloop; + } + if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dust) || GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustImpure) || GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustPure)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = IrOsLeachResidue.get(dust).splitStack(amount); + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustSmall)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = IrOsLeachResidue.get(dustSmall).splitStack(amount); + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustTiny)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = IrOsLeachResidue.get(dustTiny).splitStack(amount); + } + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mMaterial.mMaterial.equals(Materials.Iridium)) { + for (int j = 0; j < recipe.mInputs.length; j++) { + if (PlatinumSludgeOverHaul.isInBlackList(recipe.mInputs[j])) + continue recipeloop; + } + if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dust) || GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustImpure) || GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustPure)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = IrLeachResidue.get(dust).splitStack(amount); + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustSmall)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = IrLeachResidue.get(dustSmall).splitStack(amount); + } else if (GT_OreDictUnificator.getAssociation(recipe.mOutputs[i]).mPrefix.equals(dustTiny)) { + int amount = recipe.mOutputs[i].stackSize; + recipe.mOutputs[i] = IrLeachResidue.get(dustTiny).splitStack(amount); + } + } + } + } + map.mRecipeList.removeAll(toDel); + } + //TODO: remove EnderIO recipes + + //fix HV tier + PlatinumSludgeOverHaul.replaceHVCircuitMaterials(); + //add new recipes + PlatinumSludgeOverHaul.runHelperrecipes(); + } + + private static void replaceHVCircuitMaterials(){ + GT_Values.RA.addMixerRecipe(Materials.Redstone.getDust(1),Materials.Electrum.getDust(1),GT_Utility.getIntegratedCircuit(1),null,null,null,Materials.Nikolite.getDust(8),1800,120); + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sCircuitAssemblerRecipes.mRecipeList){ + if (recipe.mEUt > 512) + continue; + if (BW_Util.checkStackAndPrefix(recipe.mOutputs[0])) { + for (int i = 0; i < recipe.mInputs.length; i++) { + ItemStack stack = recipe.mInputs[i]; + ItemData ass = GT_OreDictUnificator.getAssociation(stack); + if (BW_Util.checkStackAndPrefix(stack) && ass.mMaterial.mMaterial.equals(Materials.Platinum)) { + recipe.mInputs[i] = GT_OreDictUnificator.get(ass.mPrefix,Materials.BlueAlloy,stack.stackSize); + } + } + } + } + } + + private static void setnewMaterialInRecipe(Object obj) { + String inputName = "output"; + String inputItemName = "input"; + if (!(obj instanceof ShapedOreRecipe || obj instanceof ShapelessOreRecipe)){ + if (obj instanceof ShapedRecipes || (obj instanceof ShapelessRecipes)) { + inputName = "recipeOutput"; + inputItemName = "recipeItems"; + } + else if (Loader.isModLoaded("miscutils")) { + try { + if (Class.forName("gtPlusPlus.api.objects.minecraft.ShapedRecipe").isAssignableFrom(obj.getClass())) + obj = FieldUtils.getField(obj.getClass(),"mRecipe",true).get(obj); + } catch (ClassNotFoundException | IllegalAccessException e) { + e.printStackTrace(); + } + } + } + + IRecipe recipe = (IRecipe) obj; + ItemStack otpt = recipe.getRecipeOutput(); + + Field out = FieldUtils.getDeclaredField(recipe.getClass(), inputName, true); + if (out == null) + out = FieldUtils.getField(recipe.getClass(), inputName, true); + + + Field in = FieldUtils.getDeclaredField(recipe.getClass(), inputItemName, true); + if (in == null) + in = FieldUtils.getField(recipe.getClass(), inputItemName, true); + if (in == null) + return; + FieldUtils.removeFinalModifier(in,true); + Object input = null; + try { + input = in.get(obj); + } catch (IllegalAccessException e) { + e.printStackTrace(); + return; + } + assert input != null; + + if (out != null && GT_Utility.areStacksEqual(otpt, Materials.Platinum.getDust(1), true)) { + if (PlatinumSludgeOverHaul.checkRecipe(input,Materials.Platinum)) + return; + try { + out.set(recipe, PTMetallicPowder.get(dust, otpt.stackSize * 2)); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } else if (out != null && GT_Utility.areStacksEqual(otpt, Materials.Palladium.getDust(1), true)) { + if (PlatinumSludgeOverHaul.checkRecipe(input,Materials.Palladium)) + return; + try { + out.set(recipe, PDMetallicPowder.get(dust, otpt.stackSize * 2)); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } else if (out != null && GT_Utility.areStacksEqual(otpt, Materials.Iridium.getDust(1), true)) { + if (PlatinumSludgeOverHaul.checkRecipe(input,Materials.Iridium)) + return; + try { + out.set(recipe, IrLeachResidue.get(dust, otpt.stackSize)); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } else if (out != null && GT_Utility.areStacksEqual(otpt, Materials.Osmium.getDust(1), true)) { + if (PlatinumSludgeOverHaul.checkRecipe(input,Materials.Osmium)) + return; + try { + out.set(recipe, IrOsLeachResidue.get(dust, otpt.stackSize)); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + } + + private static boolean checkRecipe(Object input,Materials mat){ + if (input instanceof List || input instanceof Object[]) { + Set lists = new HashSet(), stacks= new HashSet(); + List ip = input instanceof List ? (List)input : new ArrayList(); + Object[] ip2 = input instanceof Object[] ? (Object[])input : new Object[0]; + + for (Object o : ip){ + if (o instanceof List) + lists.add(o); + else if (o instanceof ItemStack) + stacks.add(o); + } + for (Object o : ip2){ + if (o instanceof List) + lists.add(o); + else if (o instanceof ItemStack) + stacks.add(o); + } + + for (Object o : lists) { + if (!((List) o).isEmpty()) + stacks.add(((List) o).get(0)); + } + + for (Object stack : stacks) { + if (stack instanceof ItemStack) { + if (GT_Utility.areStacksEqual(GT_OreDictUnificator.get(crateGtDust, mat, 1), (ItemStack) stack)) + return true; + } + } + + boolean allSame = false; + for (Object stack : stacks) { + if (stack instanceof ItemStack) { + allSame = BW_Util.checkStackAndPrefix((ItemStack) stack) && GT_OreDictUnificator.getAssociation((ItemStack) stack).mMaterial.mMaterial.equals(mat); + } else { + allSame = false; + break; + } + if (!allSame) + break; + } + return allSame; + } + return false; + } + + private static boolean isInBlackList(ItemStack stack) { + if (stack == null) + return true; + + if (stack.getItem() instanceof BW_MetaGenerated_Items) + return true; + + if (GameRegistry.findUniqueIdentifierFor(stack.getItem()).modId.equals(MainMod.MOD_ID)) + return true; + + if (GameRegistry.findUniqueIdentifierFor(stack.getItem()).modId.equals(BartWorksCrossmod.MOD_ID)) + return true; + + if (Block.getBlockFromItem(stack.getItem()) instanceof GT_Generic_Block && !(Block.getBlockFromItem(stack.getItem()) instanceof GT_Block_Ores_Abstract)) + return true; + + if (GT_Utility.areStacksEqual(ItemList.Depleted_Naquadah_1.get(1),stack,true) || GT_Utility.areStacksEqual(ItemList.Depleted_Naquadah_2.get(1),stack,true) || GT_Utility.areStacksEqual(ItemList.Depleted_Naquadah_4.get(1),stack,true)) + return true; + + + if (GT_Utility.areStacksEqual(ItemList.Tool_Lighter_Platinum_Empty.get(1),stack,true) || GT_Utility.areStacksEqual(ItemList.Tool_Lighter_Platinum_Used.get(1),stack,true) || GT_Utility.areStacksEqual(ItemList.Tool_Lighter_Platinum_Full.get(1),stack,true)) + return true; + + if (GT_Utility.areStacksEqual(ItemList.Emitter_EV.get(1),stack,true)) + return true; + + try { + ItemList gtnhItemListItems = ItemList.valueOf("Large_Fluid_Cell_TungstenSteel"); + if (GT_Utility.areStacksEqual(gtnhItemListItems.get(1), stack, true)) + return true; + gtnhItemListItems = ItemList.valueOf("Depleted_MNq_1"); + if (GT_Utility.areStacksEqual(gtnhItemListItems.get(1), stack, true)) + return true; + gtnhItemListItems = ItemList.valueOf("Depleted_MNq_2"); + if (GT_Utility.areStacksEqual(gtnhItemListItems.get(1), stack, true)) + return true; + gtnhItemListItems = ItemList.valueOf("Depleted_MNq_4"); + if (GT_Utility.areStacksEqual(gtnhItemListItems.get(1), stack, true)) + return true; + } catch (IllegalArgumentException ignored) {} + + if (stack.getItem() instanceof GT_Generic_Item) { + if (!BW_Util.checkStackAndPrefix(stack)) + return false; + return (!Arrays.asList(PlatinumSludgeOverHaul.OPBLACKLIST).contains(GT_OreDictUnificator.getAssociation(stack).mPrefix)) || Arrays.asList(PlatinumSludgeOverHaul.BLACKLIST).contains(GT_OreDictUnificator.getAssociation(stack).mMaterial.mMaterial); + } + + if (Loader.isModLoaded("miscutils")) { + try { + if (Class.forName("gtPlusPlus.core.item.base.BaseItemComponent").isAssignableFrom(stack.getItem().getClass()) && !(stack.getUnlocalizedName().contains("dust") || stack.getUnlocalizedName().contains("Dust"))) + return true; + if (Class.forName("gtPlusPlus.core.block.base.BlockBaseModular").isAssignableFrom(Block.getBlockFromItem(stack.getItem()).getClass())) + return true; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + } + + if (!BW_Util.checkStackAndPrefix(stack)) + return false; + + return Arrays.asList(PlatinumSludgeOverHaul.BLACKLIST).contains(GT_OreDictUnificator.getAssociation(stack).mMaterial.mMaterial); + } +} \ No newline at end of file diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/system/material/Werkstoff.java b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/Werkstoff.java index 7be1117d4c..ac1d96bc9b 100644 --- a/src/main/java/com/github/bartimaeusnek/bartworks/system/material/Werkstoff.java +++ b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/Werkstoff.java @@ -26,6 +26,7 @@ import com.github.bartimaeusnek.bartworks.util.BW_ColorUtil; import com.github.bartimaeusnek.bartworks.util.BW_Util; import com.github.bartimaeusnek.bartworks.util.MurmurHash3; import com.github.bartimaeusnek.bartworks.util.Pair; +import com.github.bartimaeusnek.crossmod.thaumcraft.util.ThaumcraftHandler; import gregtech.api.enums.*; import gregtech.api.interfaces.IColorModulationContainer; import gregtech.api.interfaces.ISubTagContainer; @@ -33,11 +34,10 @@ import gregtech.api.util.GT_OreDictUnificator; import net.minecraft.item.ItemStack; import net.minecraftforge.fluids.FluidStack; +import java.lang.reflect.InvocationTargetException; import java.nio.ByteBuffer; import java.util.*; -import static gregtech.api.enums.OrePrefixes.capsule; - public class Werkstoff implements IColorModulationContainer, ISubTagContainer { public static final LinkedHashSet werkstoffHashSet = new LinkedHashSet<>(); @@ -76,9 +76,15 @@ public class Werkstoff implements IColorModulationContainer, ISubTagContainer { Werkstoff.default_null_Werkstoff = new Werkstoff(new short[3], "_NULL", "Default null Werkstoff", Werkstoff.DEFAULT_NULL_STATS, Werkstoff.Types.UNDEFINED, Werkstoff.DEFAULT_NULL_GENERATION_FEATURES, -1, TextureSet.SET_NONE); } + public Werkstoff(short[] rgba, String defaultName, Werkstoff.Types type,int meltingpoint, Werkstoff.GenerationFeatures generationFeatures, int mID, TextureSet texSet, Pair... contents) { + this(rgba, defaultName, Werkstoff.Types.getDefaultStatForType(type).setMeltingPoint(meltingpoint), type, generationFeatures, mID, texSet, contents); + } public Werkstoff(short[] rgba, String defaultName, Werkstoff.Types type, Werkstoff.GenerationFeatures generationFeatures, int mID, TextureSet texSet, Pa