From 16ed7ace0dc69f0fb67233cd1a5846d638611a98 Mon Sep 17 00:00:00 2001 From: GlodBlock <1356392126@qq.com> Date: Thu, 26 Aug 2021 21:17:59 +0800 Subject: add Naquadah Line --- .../GoodGenerator/Blocks/TEs/NeutronActivator.java | 4 +- .../CrossMod/NEI/NeutronActivatorHandler.java | 2 +- src/main/java/GoodGenerator/Items/MyMaterial.java | 39 +- src/main/java/GoodGenerator/Loader/Loaders.java | 7 +- .../Loader/NaquadahReworkRecipeLoader.java | 1050 ++++++++++++++++++++ .../Loader/NeutronActivatorLoader.java | 8 + .../java/GoodGenerator/Loader/RecipeLoader_02.java | 4 +- .../java/GoodGenerator/Main/GoodGenerator.java | 8 + src/main/java/GoodGenerator/util/ItemRefer.java | 3 + 9 files changed, 1116 insertions(+), 9 deletions(-) create mode 100644 src/main/java/GoodGenerator/Loader/NaquadahReworkRecipeLoader.java (limited to 'src/main/java') diff --git a/src/main/java/GoodGenerator/Blocks/TEs/NeutronActivator.java b/src/main/java/GoodGenerator/Blocks/TEs/NeutronActivator.java index 29cc5c765e..464e9f6e19 100644 --- a/src/main/java/GoodGenerator/Blocks/TEs/NeutronActivator.java +++ b/src/main/java/GoodGenerator/Blocks/TEs/NeutronActivator.java @@ -104,9 +104,9 @@ public class NeutronActivator extends GT_MetaTileEntity_MultiblockBase_EM implem for (GT_Recipe recipe : tRecipes) { minNKE = (recipe.mSpecialValue % 10000) * 1000000; maxNKE = (recipe.mSpecialValue / 10000) * 1000000; - mFloor = minNKE; - mCeil = maxNKE; if (recipe.isRecipeInputEqual(true, inFluids, inItems)) { + mFloor = minNKE; + mCeil = maxNKE; mMaxProgresstime = recipe.mDuration; if (eV <= maxNKE && eV >= minNKE) { this.mOutputFluids = recipe.mFluidOutputs; diff --git a/src/main/java/GoodGenerator/CrossMod/NEI/NeutronActivatorHandler.java b/src/main/java/GoodGenerator/CrossMod/NEI/NeutronActivatorHandler.java index e26290c538..61264e27ab 100644 --- a/src/main/java/GoodGenerator/CrossMod/NEI/NeutronActivatorHandler.java +++ b/src/main/java/GoodGenerator/CrossMod/NEI/NeutronActivatorHandler.java @@ -34,7 +34,7 @@ public class NeutronActivatorHandler extends GT_NEI_DefaultHandler { int tDuration = ((CachedDefaultRecipe) this.arecipes.get(aRecipeIndex)).mRecipe.mDuration; int minNKE = ((CachedDefaultRecipe) this.arecipes.get(aRecipeIndex)).mRecipe.mSpecialValue % 10000; int maxNKE = ((CachedDefaultRecipe) this.arecipes.get(aRecipeIndex)).mRecipe.mSpecialValue / 10000; - drawText(10, 73, this.trans("158", "Time: ") + GT_Utility.formatNumbers(tDuration) + this.trans("161", " secs"), -16777216); + drawText(10, 73, this.trans("158", "Time: ") + GT_Utility.formatNumbers((float)tDuration / 20.0) + this.trans("161", " secs"), -16777216); drawText(10, 83, StatCollector.translateToLocal("value.neutron_activator.0") + " " + GT_Utility.formatNumbers(minNKE) + StatCollector.translateToLocal("value.neutron_activator.2"), -16777216); drawText(10, 93, StatCollector.translateToLocal("value.neutron_activator.1") + " " + GT_Utility.formatNumbers(maxNKE) + StatCollector.translateToLocal("value.neutron_activator.2"), -16777216); } diff --git a/src/main/java/GoodGenerator/Items/MyMaterial.java b/src/main/java/GoodGenerator/Items/MyMaterial.java index 1194336ae4..5d0a43679d 100644 --- a/src/main/java/GoodGenerator/Items/MyMaterial.java +++ b/src/main/java/GoodGenerator/Items/MyMaterial.java @@ -614,7 +614,7 @@ public class MyMaterial implements Runnable { subscriptNumbers("??NqTiGaAd??"), new Werkstoff.Stats(), Werkstoff.Types.MIXTURE, - new Werkstoff.GenerationFeatures().disable().onlyDust(), + new Werkstoff.GenerationFeatures(), OffsetID + 53, TextureSet.SET_METALLIC ); @@ -771,7 +771,7 @@ public class MyMaterial implements Runnable { subscriptNumbers("??KeNq") + CharExchanger.shifter(8314) + "??", new Werkstoff.Stats().setRadioactive(true), Werkstoff.Types.MIXTURE, - new Werkstoff.GenerationFeatures().disable().onlyDust(), + new Werkstoff.GenerationFeatures(), OffsetID + 66, TextureSet.SET_METALLIC ); @@ -832,7 +832,7 @@ public class MyMaterial implements Runnable { subscriptNumbers("??Nq*BaIn??"), new Werkstoff.Stats().setRadioactive(true).setToxic(true), Werkstoff.Types.MIXTURE, - new Werkstoff.GenerationFeatures().disable().onlyDust(), + new Werkstoff.GenerationFeatures(), OffsetID + 71, TextureSet.SET_METALLIC ); @@ -909,6 +909,39 @@ public class MyMaterial implements Runnable { new Pair<>(Oxygen, 8) ); + public static final Werkstoff naquadahGoo = new Werkstoff( + new short[]{0x4c,0x4c,0x4c}, + "Naquadah Goo", + subscriptNumbers("??NqTiGaAd??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().addCells(), + OffsetID + 78, + TextureSet.SET_FLUID + ); + + public static final Werkstoff enrichedNaquadahGoo = new Werkstoff( + new short[]{0x82,0x68,0x68}, + "Enriched Naquadah Goo", + subscriptNumbers("??KeNq") + CharExchanger.shifter(8314) + "??", + new Werkstoff.Stats().setRadioactive(true), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().addCells(), + OffsetID + 79, + TextureSet.SET_FLUID + ); + + public static final Werkstoff naquadriaGoo = new Werkstoff( + new short[]{0x4d,0x4d,0x55}, + "Naquadria Goo", + subscriptNumbers("??Nq*BaIn??"), + new Werkstoff.Stats().setRadioactive(true).setToxic(true), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().addCells(), + OffsetID + 80, + TextureSet.SET_FLUID + ); + @Override public void run() { } } diff --git a/src/main/java/GoodGenerator/Loader/Loaders.java b/src/main/java/GoodGenerator/Loader/Loaders.java index 99022d2832..0afdb884cc 100644 --- a/src/main/java/GoodGenerator/Loader/Loaders.java +++ b/src/main/java/GoodGenerator/Loader/Loaders.java @@ -51,7 +51,9 @@ public class Loaders { public static final Item quartzCrystalResonator = new MyItems("quartzCrystalResonator", GoodGenerator.GG); public static final Item inverter = new MyItems("inverter", addText("inverter.tooltip", 1), GoodGenerator.GG); public static final Item neutronSource = new MyItems("neutronSource", GoodGenerator.GG); - + public static final Item naquadahMass = new MyItems("naquadahMass", addText("naquadahMass.tooltip", 1), GoodGenerator.GG); + public static final Item enrichedNaquadahMass = new MyItems("enrichedNaquadahMass", addText("enrichedNaquadahMass.tooltip", 1), GoodGenerator.GG); + public static final Item naquadriaMass = new MyItems("naquadriaMass", addText("naquadriaMass.tooltip", 1), GoodGenerator.GG); public static final Block MAR_Casing = new Casing("MAR_Casing", new String[]{GoodGenerator.MOD_ID+":MAR_Casing"}); public static final Block FRF_Casings = new Casing("FRF_Casing", new String[]{"gregtech:iconsets/MACHINE_CASING_MINING_BLACKPLUTONIUM"}); @@ -111,6 +113,9 @@ public class Loaders { GameRegistry.registerItem(quartzCrystalResonator, "quartzCrystalResonator", GoodGenerator.MOD_ID); GameRegistry.registerItem(inverter, "inverter", GoodGenerator.MOD_ID); GameRegistry.registerItem(neutronSource, "neutronSource", GoodGenerator.MOD_ID); + GameRegistry.registerItem(naquadahMass, "naquadahMass", GoodGenerator.MOD_ID); + GameRegistry.registerItem(enrichedNaquadahMass, "enrichedNaquadahMass", GoodGenerator.MOD_ID); + GameRegistry.registerItem(naquadriaMass, "naquadriaMass", GoodGenerator.MOD_ID); Loaders.MAR = new MultiNqGenerator(12732, "NaG", "Large Naquadah Reactor").getStackForm(1L); Loaders.FRF = new FuelRefineFactory(16999, "FRF", "Naquadah Fuel Refinery").getStackForm(1L); Loaders.UCFE = new UniversalChemicalFuelEngine(IDOffset, "UniversalChemicalFuelEngine", "Universal Chemical Fuel Engine").getStackForm(1L); diff --git a/src/main/java/GoodGenerator/Loader/NaquadahReworkRecipeLoader.java b/src/main/java/GoodGenerator/Loader/NaquadahReworkRecipeLoader.java new file mode 100644 index 0000000000..89b090c69b --- /dev/null +++ b/src/main/java/GoodGenerator/Loader/NaquadahReworkRecipeLoader.java @@ -0,0 +1,1050 @@ +package GoodGenerator.Loader; + +import GoodGenerator.Main.GoodGenerator; +import GoodGenerator.util.ItemRefer; +import GoodGenerator.util.MyRecipeAdder; +import com.github.bartimaeusnek.bartworks.system.material.GT_Enhancement.PlatinumSludgeOverHaul; +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; +import cpw.mods.fml.common.Loader; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.*; +import gregtech.common.items.CombType; +import gregtech.loaders.misc.GT_Bees; +import gtPlusPlus.xmod.gregtech.loaders.RecipeGen_MultisUsingFluidInsteadOfCells; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.CraftingManager; +import net.minecraft.item.crafting.IRecipe; +import net.minecraft.item.crafting.ShapedRecipes; +import net.minecraft.item.crafting.ShapelessRecipes; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; +import net.minecraftforge.oredict.ShapedOreRecipe; +import net.minecraftforge.oredict.ShapelessOreRecipe; +import org.apache.commons.lang3.reflect.FieldUtils; + +import java.lang.reflect.*; +import java.util.HashSet; + +import static GoodGenerator.Items.MyMaterial.*; +import static gregtech.common.items.GT_MetaGenerated_Item_01.registerCauldronCleaningFor; + +public class NaquadahReworkRecipeLoader { + + public static void RecipeLoad(){ + //Naquadah Rework Line + GT_Values.RA.addBlastRecipe( + naquadahEarth.get(OrePrefixes.dust, 2), + GT_Utility.getIntegratedCircuit(1), + fluoroantimonicAcid.getFluidOrGas(3000), + lowQualityNaquadahEmulsion.getFluidOrGas(2000), + titaniumTrifluoride.get(OrePrefixes.dust, 1), + null, + 100, + 480, + 3000 + ); + + GT_Values.RA.addBlastRecipe( + titaniumTrifluoride.get(OrePrefixes.dust, 1), + GT_Utility.getIntegratedCircuit(1), + Materials.Hydrogen.getGas(3000), + Materials.HydrofluoricAcid.getFluid(3000), + GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Titanium, 1), + null, + 120, + 1920, + 2000 + ); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[]{ + GT_Utility.copyAmount(0, GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Copper, 1)) + }, + new FluidStack[]{ + Materials.Hydrogen.getGas(8000), + FluidRegistry.getFluidStack("seedoil", 3000) + }, + new FluidStack[]{ + towEthyl1Hexanol.getFluidOrGas(1000) + }, + null, + 400, + 480 + ); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[]{ + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 16) + }, + new FluidStack[]{ + towEthyl1Hexanol.getFluidOrGas(2000), + Materials.PhosphoricAcid.getFluid(1000), + Materials.Ethanol.getFluid(4000) + }, + new FluidStack[]{ + P507.getFluidOrGas(1000) + }, + null, + 1200, + 1920 + ); + + GT_Values.RA.addMultiblockChemicalRecipe( + null, + new FluidStack[]{ + P507.getFluidOrGas(4000), + lowQualityNaquadahSolution.getFluidOrGas(36000), + }, + new FluidStack[]{ + fluorineRichWasteLiquid.getFluidOrGas(6000), + naquadahAdamantiumSolution.getFluidOrGas(30000) + }, + null, + 4000, + 1920 + ); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[]{ + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, 60), + }, + new FluidStack[]{ + fluorineRichWasteLiquid.getFluidOrGas(1500) + }, + new FluidStack[]{ + wasteLiquid.getFluidOrGas(1000) + }, + new ItemStack[]{ + WerkstoffLoader.Fluorspar.get(OrePrefixes.dust, 60) + }, + 1000, + 120 + ); + + GT_Values.RA.addUniversalDistillationRecipe( + wasteLiquid.getFluidOrGas(10000), + new FluidStack[]{ + Materials.SaltWater.getFluid(3000), + FluidRegistry.getFluidStack("phenol", 2000), + Materials.HydrochloricAcid.getFluid(5000) + }, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Chrome, 3), + 300, + 480 + ); + + MyRecipeAdder.instance.addNeutronActivatorRecipe( + new FluidStack[]{ + naquadahAdamantiumSolution.getFluidOrGas(3000) + }, + null, + new FluidStack[]{ + naquadahRichSolution.getFluidOrGas(2000) + }, + new ItemStack[]{ + adamantine.get(OrePrefixes.dust, 4), + naquadahEarth.get(OrePrefixes.dust, 2), + concentratedEnrichedNaquadahSludge.get(OrePrefixes.dust, 1) + }, + 100, + 230, + 200 + ); + + GT_Values.RA.addAutoclaveRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 27), + null, + naquadahRichSolution.getFluidOrGas(5000), + P507.getFluidOrGas(1000), + naquadahine.get(OrePrefixes.dust, 10), + 10000, + 1000, + 1920, + false + ); + + GT_Values.RA.addBlastRecipe( + naquadahine.get(OrePrefixes.dust, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Carbon, 1), + null, + Materials.CarbonDioxide.getGas(1000), + GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Naquadah, 1), + null, + 20, + 7680, + 5000 + ); + + GT_Values.RA.addCentrifugeRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 27), + GT_Utility.getIntegratedCircuit(1), + lowQualityNaquadahEmulsion.getFluidOrGas(10000), + lowQualityNaquadahSolution.getFluidOrGas(9000), + galliumHydroxide.get(OrePrefixes.dust, 16), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.AntimonyTrioxide, 10), + null,null,null, null, + new int[]{6250, 10000}, + 1000, + 1920 + ); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[]{ + enrichedNaquadahEarth.get(OrePrefixes.dust, 4), + }, + new FluidStack[]{ + P507.getFluidOrGas(1000), + Materials.SulfuricAcid.getFluid(4000) + }, + new FluidStack[]{ + enrichedNaquadahRichSolution.getFluidOrGas(4000), + wasteLiquid.getFluidOrGas(1000) + }, + new ItemStack[]{ + naquadahEarth.get(OrePrefixes.dust, 1), + triniumSulphate.get(OrePrefixes.dust, 4) + }, + 400, + 1920 + ); + + GT_Values.RA.addAutoclaveRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 27), + null, + enrichedNaquadahRichSolution.getFluidOrGas(10000), + P507.getFluidOrGas(2500), + concentratedEnrichedNaquadahSludge.get(OrePrefixes.dust, 8), + 10000, + 1000, + 480, + false + ); + + MyRecipeAdder.instance.addNeutronActivatorRecipe( + null, + new ItemStack[]{ + concentratedEnrichedNaquadahSludge.get(OrePrefixes.dust, 16), + }, + null, + new ItemStack[]{ + enrichedNaquadahSulphate.get(OrePrefixes.dust, 15), + WerkstoffLoader.Sodiumsulfate.get(OrePrefixes.dust, 20), + lowQualityNaquadriaSulphate.get(OrePrefixes.dust, 2) + }, + 120, + 480, + 460 + ); + + GT_Values.RA.addBlastRecipe( + enrichedNaquadahSulphate.get(OrePrefixes.dust, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Zinc, 2), + null, + null, + GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.NaquadahEnriched, 1), + WerkstoffLoader.ZincSulfate.get(OrePrefixes.dust, 2), + 20, + 7680, + 7500 + ); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[]{ + triniumSulphate.get(OrePrefixes.dust, 1), + }, + new FluidStack[]{ + Materials.Hydrogen.getGas(1000) + }, + new FluidStack[]{ + Materials.SulfuricAcid.getFluid(1000) + }, + new ItemStack[]{ + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Trinium, 1), + }, + 120, + 480 + ); + + GT_Values.RA.addCentrifugeRecipe( + naquadriaEarth.get(OrePrefixes.dust, 4), + null, + Materials.PhosphoricAcid.getFluid(4000), + null, + indiumPhosphate.get(OrePrefixes.dust, 1), + lowQualityNaquadriaPhosphate.get(OrePrefixes.dust, 4), + null, null, null, null, + new int[]{10000, 10000}, + 400, + 7680 + ); + + GT_Values.RA.addChemicalRecipe( + galliumHydroxide.get(OrePrefixes.dust, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Gallium, 1), + 40, + 30 + ); + + GT_Values.RA.addChemicalRecipe( + indiumPhosphate.get(OrePrefixes.dust, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcium, 1), + null, null, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Indium, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.TricalciumPhosphate, 1), + 20, + 30 + ); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[]{ + lowQualityNaquadriaPhosphate.get(OrePrefixes.dust, 10), + }, + new FluidStack[]{ + Materials.SulfuricAcid.getFluid(10000) + }, + new FluidStack[]{ + naquadriaRichSolution.getFluidOrGas(9000) + }, + new ItemStack[]{ + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Barite, 1), + }, + 1000, + 7680 + ); + + MyRecipeAdder.instance.addNeutronActivatorRecipe( + new FluidStack[]{ + naquadriaRichSolution.getFluidOrGas(9000) + }, + null, + null, + new ItemStack[]{ + naquadriaSulphate.get(OrePrefixes.dust, 4), + lowQualityNaquadriaSulphate.get(OrePrefixes.dust, 6) + }, + 100, + 1100, + 1050 + ); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[]{ + lowQualityNaquadriaSulphate.get(OrePrefixes.dust, 3), + }, + new FluidStack[]{ + Materials.Water.getFluid(3000), + P507.getFluidOrGas(500) + }, + new FluidStack[]{ + lowQualityNaquadriaSolution.getFluidOrGas(3500) + }, + null, + 500, + 30720 + ); + + GT_Values.RA.addUniversalDistillationRecipe( + lowQualityNaquadriaSolution.getFluidOrGas(7000), + new FluidStack[]{ + P507.getFluidOrGas(1000), + naquadriaRichSolution.getFluidOrGas(5400), + Materials.DilutedSulfuricAcid.getFluid(10000) + }, + enrichedNaquadahEarth.get(OrePrefixes.dust, 2), + 500, + 7680 + ); + + GT_Values.RA.addBlastRecipe( + naquadriaSulphate.get(OrePrefixes.dust, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesium, 1), + null, + Materials.HydricSulfide.getGas(1000), + GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Naquadria, 1), + null, + 20, + 122880, + 9100 + ); + + GT_Values.RA.addMixerRecipe( + indiumPhosphate.get(OrePrefixes.dust, 1), + galliumHydroxide.get(OrePrefixes.dust, 1), + GT_Utility.getIntegratedCircuit(2), + null, + null, + null, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.IndiumGalliumPhosphide, 3), + 15, + 7 + ); + + GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Ball.get(0), + naquadahGoo.getFluidOrGas(72), + ItemRefer.Naquadah_Mass.get(1), + 100, + 30 + ); + + GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Ball.get(0), + enrichedNaquadahGoo.getFluidOrGas(72), + ItemRefer.Enriched_Naquadah_Mass.get(1), + 100, + 30 + ); + + GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Ball.get(0), + naquadriaGoo.getFluidOrGas(72), + ItemRefer.Naquadria_Mass.get(1), + 100, + 30 + ); + + GT_Values.RA.addPulveriserRecipe( + ItemRefer.Naquadah_Mass.get(1), + new ItemStack[]{ + naquadahEarth.get(OrePrefixes.dust, 1), + enrichedNaquadahEarth.get(OrePrefixes.dust, 1) + }, + new int[]{10000, 100}, + 100, + 2 + ); + + GT_Values.RA.addPulveriserRecipe( + ItemRefer.Enriched_Naquadah_Mass.get(1), + new ItemStack[]{ + enrichedNaquadahEarth.get(OrePrefixes.dust, 1), + naquadriaEarth.get(OrePrefixes.dust, 1) + }, + new int[]{10000, 100}, + 100, + 2 + ); + + GT_Values.RA.addPulveriserRecipe( + ItemRefer.Naquadria_Mass.get(1), + new ItemStack[]{ + naquadriaEarth.get(OrePrefixes.dust, 1), + naquadriaEarth.get(OrePrefixes.dust, 1) + }, + new int[]{10000, 100}, + 100, + 2 + ); + + GT_Values.RA.addBlastRecipe( + GT_OreDictUnificator.get(OrePrefixes.block, Materials.Silicon, 16), + naquadahine.get(OrePrefixes.dust, 1), + Materials.Argon.getGas(8000), + null, + ItemList.Circuit_Silicon_Ingot3.get(1), + null, + 1000, + 7680, + 4484 + ); + + GT_Values.RA.addChemicalRecipe( + naquadahine.get(OrePrefixes.dust, 1), + Materials.Sodium.getDust(1), + Materials.Naquadah.getDust(1), + 10, + 1920 + ); + } + + public static void SmallRecipeChange() { + + GT_Recipe tRecipe; + + tRecipe = GT_Recipe.GT_Recipe_Map.sChemicalRecipes.findRecipe( + null, false, 1 << 30, + new FluidStack[]{Materials.SulfuricAcid.getFluid(500)}, + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Platinum, 16), + ItemList.Empty_Board_Elite.get(2) + ); + if (tRecipe != null) { + GT_Recipe.GT_Recipe_Map.sChemicalRecipes.mRecipeList.remove(tRecipe); + GT_Recipe tRecipe2 = tRecipe.copy(); + tRecipe2.mInputs = new ItemStack[]{GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Naquadah, 16), ItemList.Empty_Board_Elite.get(2)}; + GT_Recipe.GT_Recipe_Map.sChemicalRecipes.mRecipeList.add(tRecipe2); + GT_Recipe.GT_Recipe_Map.sChemicalRecipes.reInit(); + } + + tRecipe = GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes.findRecipe( + null, false, 1 << 30, + new FluidStack[]{Materials.SulfuricAcid.getFluid(500)}, + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Platinum, 16), + ItemList.Empty_Board_Elite.get(2) + ); + if (tRecipe != null) { + GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes.mRecipeList.remove(tRecipe); + GT_Recipe tRecipe2 = tRecipe.copy(); + tRecipe2.mInputs = new ItemStack[]{GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Naquadah, 16), ItemList.Empty_Board_Elite.get(2)}; + GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes.mRecipeList.add(tRecipe2); + GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes.reInit(); + } + + tRecipe = GT_Recipe.GT_Recipe_Map.sAssemblerRecipes.findRecipe( + null, false, 1 << 30, + new FluidStack[]{Materials.Polybenzimidazole.getMolten(36)}, + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Polybenzimidazole, 2), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.HSSS, 1) + ); + if (tRecipe != null) { + GT_Recipe.GT_Recipe_Map.sAssemblerRecipes.mRecipeList.remove(tRecipe); + GT_Recipe tRecipe2 = tRecipe.copy(); + tRecipe2.mInputs = new ItemStack[]{GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Polybenzimidazole, 2), GT_OreDictUnificator.get(OrePrefixes.foil, Materials.NaquadahEnriched, 1)}; + GT_Recipe.GT_Recipe_Map.sAssemblerRecipes.mRecipeList.add(tRecipe2); + GT_Recipe.GT_Recipe_Map.sAssemblerRecipes.reInit(); + } + } + + public static void Remover() { + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Begin to remove pure Naquadah, Enriched Naquadah and Naquadria.\n"); + + HashSet remove = new HashSet<>(5000); + HashSet reAdd = new HashSet<>(5000); + + //For Crusher + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if ((OreDictionary.getOreName(oreDictID).startsWith("ore") || OreDictionary.getOreName(oreDictID).startsWith("crushed")) && OreDictionary.getOreName(oreDictID).contains("Naq")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadahEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, enrichedNaquadahEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadriaEarth.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Crusher done!\n"); + + //For Washer + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("crushed") && OreDictionary.getOreName(oreDictID).contains("Naq")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadahEarth.get(OrePrefixes.dustTiny, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, enrichedNaquadahEarth.get(OrePrefixes.dustTiny, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadriaEarth.get(OrePrefixes.dustTiny, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Washer done!\n"); + + //For Thermal Centrifuge + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("crushed") && OreDictionary.getOreName(oreDictID).contains("Naq")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadahEarth.get(OrePrefixes.dustTiny, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, enrichedNaquadahEarth.get(OrePrefixes.dustTiny, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadriaEarth.get(OrePrefixes.dustTiny, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Thermal Centrifuge done!\n"); + + //For Centrifuge + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.mRecipeList) { + ItemStack input = null; + if (recipe.mInputs.length > 0) input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + if (input.isItemEqual(GT_Bees.combs.getStackForType(CombType.DOB))){ + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadahEarth.get(OrePrefixes.dustTiny, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + } + else for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("dustPureNaq") || OreDictionary.getOreName(oreDictID).startsWith("dustImpureNaq") || OreDictionary.getOreName(oreDictID).startsWith("dustSpace") || OreDictionary.getOreName(oreDictID).startsWith("dustNaq")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadahEarth.get(OrePrefixes.dustTiny, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, enrichedNaquadahEarth.get(OrePrefixes.dustTiny, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadriaEarth.get(OrePrefixes.dustTiny, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadahEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, enrichedNaquadahEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadriaEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDustSmall(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadahEarth.get(OrePrefixes.dustSmall, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDustSmall(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, enrichedNaquadahEarth.get(OrePrefixes.dustSmall, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDustSmall(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadriaEarth.get(OrePrefixes.dustSmall, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Centrifuge done!\n"); + + //For Hammer + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sHammerRecipes.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("crushed") && OreDictionary.getOreName(oreDictID).contains("Naq")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadahEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, enrichedNaquadahEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadriaEarth.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sHammerRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sHammerRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sHammerRecipes.reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Hammer done!\n"); + + //For Chemical Reactor + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sChemicalRecipes.mRecipeList) { + if (recipe.mFluidOutputs == null) continue; + boolean isAny = false; + for (int i = 0; i < recipe.mFluidOutputs.length; i ++) { + if (recipe.mFluidOutputs[i] == null) continue; + if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadah.getMolten(1)) || + recipe.mFluidOutputs[i].isFluidEqual(Materials.NaquadahEnriched.getMolten(1)) || + recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadria.getMolten(1))) { + isAny = true; + break; + } + } + if (!isAny) continue; + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < recipe.mFluidOutputs.length; i ++) { + if (recipe.mFluidOutputs[i] == null) continue; + if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadah.getMolten(1))) { + tRecipe.mFluidOutputs[i] = naquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.NaquadahEnriched.getMolten(1))) { + tRecipe.mFluidOutputs[i] = enrichedNaquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadria.getMolten(1))) { + tRecipe.mFluidOutputs[i] = naquadriaGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + } + } + if (!tRecipe.equals(recipe)) { + reAdd.add(tRecipe); + remove.add(recipe); + } + } + GT_Recipe.GT_Recipe_Map.sChemicalRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sChemicalRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sChemicalRecipes.reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Chemical Reactor done!\n"); + + //For Multi Chemical Reactor + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes.mRecipeList) { + if (recipe.mFluidOutputs == null) continue; + boolean isAny = false; + for (int i = 0; i < recipe.mFluidOutputs.length; i ++) { + if (recipe.mFluidOutputs[i] == null) continue; + if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadah.getMolten(1)) || + recipe.mFluidOutputs[i].isFluidEqual(Materials.NaquadahEnriched.getMolten(1)) || + recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadria.getMolten(1))) { + isAny = true; + break; + } + } + if (!isAny) continue; + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < recipe.mFluidOutputs.length; i ++) { + if (recipe.mFluidOutputs[i] == null) continue; + if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadah.getMolten(1))) { + tRecipe.mFluidOutputs[i] = naquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.NaquadahEnriched.getMolten(1))) { + tRecipe.mFluidOutputs[i] = enrichedNaquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadria.getMolten(1))) { + tRecipe.mFluidOutputs[i] = naquadriaGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + } + } + if (!tRecipe.equals(recipe)) { + reAdd.add(tRecipe); + remove.add(recipe); + } + } + GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes.reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Multi Chemical Reactor done!\n"); + + if (Loader.isModLoaded("miscutils")) { + //For Multi Centrifuge + //Blame alk. She made some shit in it, NEI will break down if anyone modify the hash list directly. + GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT.mRecipeList.clear(); + RecipeGen_MultisUsingFluidInsteadOfCells.generateRecipesNotUsingCells(GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes, GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT); + GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT.reInit(); + + //For Simple Washer + for (GT_Recipe recipe : GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("dustImpureNaq")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize, naquadahEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize, enrichedNaquadahEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize, naquadriaEarth.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.mRecipeList.removeAll(remove); + GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.mRecipeList.addAll(reAdd); + GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Simple Washer done!\n"); + } + + //For ByProduct List + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sByProductList.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("ore") && OreDictionary.getOreName(oreDictID).contains("Naq")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize, naquadahEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.NaquadahEnriched.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize, enrichedNaquadahEarth.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadria.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize, naquadriaEarth.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sByProductList.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sByProductList.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sByProductList.reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("ByProduct List done!\n"); + + //For Cauldron Wash + registerCauldronCleaningFor(Materials.Naquadah, naquadahEarth.getBridgeMaterial()); + registerCauldronCleaningFor(Materials.NaquadahEnriched, enrichedNaquadahEarth.getBridgeMaterial()); + registerCauldronCleaningFor(Materials.Naquadria, naquadriaEarth.getBridgeMaterial()); + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace 3! "); + GT_Log.out.print("Cauldron Wash done!\n"); + + //For Crafting Table + CraftingManager.getInstance().getRecipeList().forEach(NaquadahReworkRecipeLoader::replaceInCraftTable); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace Unknown! "); + GT_Log.out.print("Crafting Table done!\n"); + } + + //I don't understand. . . + //I use some private methods in Bartworks because his system runs well. + public static void replaceInCraftTable(Object obj) { + + Constructor cs = null; + PlatinumSludgeOverHaul BartObj = null; + try { + cs = PlatinumSludgeOverHaul.class.getDeclaredConstructor(); + cs.setAccessible(true); + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } + + if (cs == null) return; + + try { + BartObj = (PlatinumSludgeOverHaul)cs.newInstance(); + } catch (IllegalAccessException | InstantiationException | InvocationTargetException e) { + e.printStackTrace(); + } + + Method recipeCheck = null; + + try { + recipeCheck = PlatinumSludgeOverHaul.class.getDeclaredMethod("checkRecipe", Object.class, Materials.class); + recipeCheck.setAccessible(true); + } catch (Exception e) { + e.printStackTrace(); + } + + String inputName = "output"; + String inputItemName = "input"; + if (!(obj instanceof ShapedOreRecipe || obj instanceof ShapelessOreRecipe)){ + if (obj instanceof ShapedRecipes || (obj instanceof ShapelessRecipes)) { + inputName = "recipeOutput"; + inputItemName = "recipeItems"; + } + } + IRecipe recipe = (IRecipe) obj; + ItemStack result = 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; + + //this part here is NOT MIT LICENSED BUT LICSENSED UNDER THE Apache License, Version 2.0! + try { + if (Modifier.isFinal(in.getModifiers())) { + // Do all JREs implement Field with a private ivar called "modifiers"? + Field modifiersField = Field.class.getDeclaredField("modifiers"); + boolean doForceAccess = !modifiersField.isAccessible(); + if (doForceAccess) { + modifiersField.setAccessible(true); + } + try { + modifiersField.setInt(in, in.getModifiers() & ~Modifier.FINAL); + } finally { + if (doForceAccess) { + modifiersField.setAccessible(false); + } + } + } + } catch (NoSuchFieldException ignored) { + // The field class contains always a modifiers field + } catch (IllegalAccessException ignored) { + // The modifiers field is made accessible + } + // END OF APACHE COMMONS COLLECTION COPY + + Object input; + try { + input = in.get(obj); + } catch (IllegalAccessException e) { + e.printStackTrace(); + return; + } + + if (out == null || recipeCheck == null) return; + + if (GT_Utility.areStacksEqual(result, Materials.Naquadah.getDust(1), true)) { + + recipeCheck.setAccessible(true); + boolean isOk = true; + + try { + isOk = (boolean)recipeCheck.invoke(BartObj, input, Materials.Naquadah); + } catch (InvocationTargetException | IllegalAccessException ignored) { + } + + if (isOk) return; + try { + out.set(recipe, naquadahEarth.get(OrePrefixes.dust, 2)); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } else if (GT_Utility.areStacksEqual(result, Materials.NaquadahEnriched.getDust(1), true)) { + + recipeCheck.setAccessible(true); + boolean isOk = true; + + try { + isOk = (boolean)recipeCheck.invoke(BartObj, input, Materials.NaquadahEnriched); + } catch (InvocationTargetException | IllegalAccessException ignored) { + } + + if (isOk) return; + try { + out.set(recipe, enrichedNaquadahEarth.get(OrePrefixes.dust, 2)); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } else if (GT_Utility.areStacksEqual(result, Materials.Naquadria.getDust(1), true)) { + + recipeCheck.setAccessible(true); + boolean isOk = true; + + try { + isOk = (boolean)recipeCheck.invoke(BartObj, input, Materials.Naquadria); + } catch (InvocationTargetException | IllegalAccessException ignored) { + } + + if (isOk) return; + try { + out.set(recipe, naquadriaEarth.get(OrePrefixes.dust, 2)); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + } +} diff --git a/src/main/java/GoodGenerator/Loader/NeutronActivatorLoader.java b/src/main/java/GoodGenerator/Loader/NeutronActivatorLoader.java index 01555eb8d2..191756e3c8 100644 --- a/src/main/java/GoodGenerator/Loader/NeutronActivatorLoader.java +++ b/src/main/java/GoodGenerator/Loader/NeutronActivatorLoader.java @@ -1,6 +1,14 @@ package GoodGenerator.Loader; +import GoodGenerator.util.MyRecipeAdder; +import gregtech.api.enums.OrePrefixes; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import static GoodGenerator.Items.MyMaterial.*; + public class NeutronActivatorLoader { public static void NARecipeLoad() { + } } diff --git a/src/main/java/GoodGenerator/Loader/RecipeLoader_02.java b/src/main/java/GoodGenerator/Loader/RecipeLoader_02.java index 14f07cb571..9cb898810b 100644 --- a/src/main/java/GoodGenerator/Loader/RecipeLoader_02.java +++ b/src/main/java/GoodGenerator/Loader/RecipeLoader_02.java @@ -2,11 +2,9 @@ package GoodGenerator.Loader; import GoodGenerator.util.ItemRefer; import gregtech.api.enums.GT_Values; -import gregtech.api.enums.ItemList; import gregtech.api.enums.Materials; import gregtech.api.enums.OrePrefixes; import gregtech.api.util.GT_OreDictUnificator; -import gregtech.api.util.GT_Utility; import net.minecraft.item.ItemStack; public class RecipeLoader_02 { @@ -26,6 +24,8 @@ public class RecipeLoader_02 { 300, 1920 ); + } + public static void InitLoadRecipe() { } } diff --git a/src/main/java/GoodGenerator/Main/GoodGenerator.java b/src/main/java/GoodGenerator/Main/GoodGenerator.java index 212381a31b..82265b563d 100644 --- a/src/main/java/GoodGenerator/Main/GoodGenerator.java +++ b/src/main/java/GoodGenerator/Main/GoodGenerator.java @@ -11,6 +11,7 @@ import GoodGenerator.Blocks.MyFluids.FluidsBuilder; import com.github.bartimaeusnek.bartworks.API.WerkstoffAdderRegistry; import cpw.mods.fml.common.Loader; import cpw.mods.fml.common.SidedProxy; +import cpw.mods.fml.common.event.FMLLoadCompleteEvent; import cpw.mods.fml.common.event.FMLPostInitializationEvent; import cpw.mods.fml.common.event.FMLPreInitializationEvent; import cpw.mods.fml.common.network.NetworkRegistry; @@ -61,7 +62,9 @@ public final class GoodGenerator { public static void init(FMLInitializationEvent event){ proxy.init(event); RecipeLoader.InitLoadRecipe(); + RecipeLoader_02.InitLoadRecipe(); FuelRecipeLoader.RegisterFuel(); + NaquadahReworkRecipeLoader.RecipeLoad(); } @Mod.EventHandler public static void postInit(FMLPostInitializationEvent event){ @@ -74,4 +77,9 @@ public final class GoodGenerator { Research.addResearch(); } } + @Mod.EventHandler + public void onLoadComplete(FMLLoadCompleteEvent event) { + NaquadahReworkRecipeLoader.SmallRecipeChange(); + NaquadahReworkRecipeLoader.Remover(); + } } \ No newline at end of file diff --git a/src/main/java/GoodGenerator/util/ItemRefer.java b/src/main/java/GoodGenerator/util/ItemRefer.java index 9f880a0726..fbfd87eb81 100644 --- a/src/main/java/GoodGenerator/util/ItemRefer.java +++ b/src/main/java/GoodGenerator/util/ItemRefer.java @@ -31,6 +31,9 @@ public final class ItemRefer { public static ItemRefer Quartz_Crystal_Resonator = getItemStack(quartzCrystalResonator); public static ItemRefer Inverter = getItemStack(inverter); public static ItemRefer Neutron_Source = getItemStack(neutronSource); + public static ItemRefer Naquadah_Mass = getItemStack(naquadahMass); + public static ItemRefer Enriched_Naquadah_Mass = getItemStack(enrichedNaquadahMass); + public static ItemRefer Naquadria_Mass = getItemStack(naquadriaMass); public static ItemRefer Field_Restriction_Casing = getItemStack(MAR_Casing); public static ItemRefer Naquadah_Fuel_Refinery_Casing = getItemStack(FRF_Casings); -- cgit