From 92238a0f3b06a80683f50dfd2d6e9164d2d0f1ab Mon Sep 17 00:00:00 2001 From: GlodBlock <1356392126@qq.com> Date: Tue, 7 Dec 2021 23:02:17 +0800 Subject: rename package --- .../goodgenerator/loader/AchievementLoader.java | 4 + .../goodgenerator/loader/FuelRecipeLoader.java | 79 + .../java/goodgenerator/loader/FuelRodLoader.java | 56 + src/main/java/goodgenerator/loader/Loaders.java | 215 +++ .../loader/NaquadahReworkRecipeLoader.java | 1125 ++++++++++++ .../loader/NeutronActivatorLoader.java | 24 + .../java/goodgenerator/loader/RecipeLoader.java | 1904 ++++++++++++++++++++ .../java/goodgenerator/loader/RecipeLoader_02.java | 670 +++++++ 8 files changed, 4077 insertions(+) create mode 100644 src/main/java/goodgenerator/loader/AchievementLoader.java create mode 100644 src/main/java/goodgenerator/loader/FuelRecipeLoader.java create mode 100644 src/main/java/goodgenerator/loader/FuelRodLoader.java create mode 100644 src/main/java/goodgenerator/loader/Loaders.java create mode 100644 src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java create mode 100644 src/main/java/goodgenerator/loader/NeutronActivatorLoader.java create mode 100644 src/main/java/goodgenerator/loader/RecipeLoader.java create mode 100644 src/main/java/goodgenerator/loader/RecipeLoader_02.java (limited to 'src/main/java/goodgenerator/loader') diff --git a/src/main/java/goodgenerator/loader/AchievementLoader.java b/src/main/java/goodgenerator/loader/AchievementLoader.java new file mode 100644 index 0000000000..2df30c8752 --- /dev/null +++ b/src/main/java/goodgenerator/loader/AchievementLoader.java @@ -0,0 +1,4 @@ +package goodgenerator.loader; + +public class AchievementLoader { +} diff --git a/src/main/java/goodgenerator/loader/FuelRecipeLoader.java b/src/main/java/goodgenerator/loader/FuelRecipeLoader.java new file mode 100644 index 0000000000..73e97830a2 --- /dev/null +++ b/src/main/java/goodgenerator/loader/FuelRecipeLoader.java @@ -0,0 +1,79 @@ +package goodgenerator.loader; + +import goodgenerator.items.MyMaterial; +import goodgenerator.util.ItemRefer; +import goodgenerator.util.MyRecipeAdder; +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_OreDictUnificator; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import static goodgenerator.main.GG_Config_Loader.NaquadahFuelTime; +import static goodgenerator.main.GG_Config_Loader.NaquadahFuelVoltage; + +public class FuelRecipeLoader { + public static void RegisterFuel(){ + //MyRecipeAdder.instance.addLiquidMentalFuel(Materials.NaquadahEnriched.getMolten(1L),Materials.Naquadah.getMolten(1L),32768,100); + //MyRecipeAdder.instance.addLiquidMentalFuel(Materials.Naquadria.getMolten(1L),Materials.Naquadah.getMolten(1L),262144,120); + MyRecipeAdder.instance.addLiquidMentalFuel(MyMaterial.uraniumBasedLiquidFuelExcited.getFluidOrGas(1),MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(1),NaquadahFuelVoltage[0],NaquadahFuelTime[0]); + MyRecipeAdder.instance.addLiquidMentalFuel(MyMaterial.thoriumBasedLiquidFuelExcited.getFluidOrGas(1),MyMaterial.thoriumBasedLiquidFuelDepleted.getFluidOrGas(1),NaquadahFuelVoltage[1],NaquadahFuelTime[1]); + MyRecipeAdder.instance.addLiquidMentalFuel(MyMaterial.plutoniumBasedLiquidFuelExcited.getFluidOrGas(1),MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(1),NaquadahFuelVoltage[2],NaquadahFuelTime[2]); + MyRecipeAdder.instance.addLiquidMentalFuel(MyMaterial.naquadahBasedFuelMkI.getFluidOrGas(1),MyMaterial.naquadahBasedFuelMkIDepleted.getFluidOrGas(1),NaquadahFuelVoltage[3],NaquadahFuelTime[3]); + MyRecipeAdder.instance.addLiquidMentalFuel(MyMaterial.naquadahBasedFuelMkII.getFluidOrGas(1),MyMaterial.naquadahBasedFuelMkIIDepleted.getFluidOrGas(1),NaquadahFuelVoltage[4],NaquadahFuelTime[4]); + MyRecipeAdder.instance.addLiquidMentalFuel(MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(1),MyMaterial.naquadahBasedFuelMkIIIDepleted.getFluidOrGas(1),NaquadahFuelVoltage[5],NaquadahFuelTime[5]); + MyRecipeAdder.instance.addLiquidMentalFuel(MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(1),MyMaterial.naquadahBasedFuelMkIVDepleted.getFluidOrGas(1),NaquadahFuelVoltage[6],NaquadahFuelTime[6]); + MyRecipeAdder.instance.addLiquidMentalFuel(MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(1),MyMaterial.naquadahBasedFuelMkVDepleted.getFluidOrGas(1),NaquadahFuelVoltage[7],NaquadahFuelTime[7]); + + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[]{ + MyMaterial.heavyNaquadahFuel.getFluidOrGas(800), + MyMaterial.lightNaquadahFuel.getFluidOrGas(1000), + }, + new ItemStack[]{ + MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust,4), + WerkstoffLoader.Tiberium.get(OrePrefixes.dust,27), + ItemRefer.High_Density_Uranium.get(2), + ItemRefer.High_Density_Plutonium.get(1), + }, + MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(100), + 1100000, + 100, + 1 + ); + + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[]{ + MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(2000), + Materials.Praseodymium.getMolten(9216L) + }, + new ItemStack[]{ + MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust,27), + GT_OreDictUnificator.get(OrePrefixes.dust,Materials.NetherStar,64), + GT_OreDictUnificator.get(OrePrefixes.dust,Materials.DraconiumAwakened,64), + MyMaterial.orundum.get(OrePrefixes.dust,32), + }, + MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(250), + 46000000, + 160, + 2 + ); + + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[]{ + MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(2000), + FluidRegistry.getFluidStack("heavyradox",1000), + }, + new ItemStack[]{ + GT_OreDictUnificator.get(OrePrefixes.dust,Materials.Infinity,16), + MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.dust, 32), + }, + MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(500), + 100000000, + 200, + 2 + ); + } +} diff --git a/src/main/java/goodgenerator/loader/FuelRodLoader.java b/src/main/java/goodgenerator/loader/FuelRodLoader.java new file mode 100644 index 0000000000..ead118983d --- /dev/null +++ b/src/main/java/goodgenerator/loader/FuelRodLoader.java @@ -0,0 +1,56 @@ +package goodgenerator.loader; + +import goodgenerator.items.FuelRod; +import goodgenerator.items.RadioactiveItem; +import goodgenerator.main.GoodGenerator; +import cpw.mods.fml.common.registry.GameRegistry; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +import static goodgenerator.util.DescTextLocalization.addText; + +public class FuelRodLoader { + + public static Item rodCompressedUraniumDepleted; + public static Item rodCompressedUraniumDepleted_2; + public static Item rodCompressedUraniumDepleted_4; + public static Item rodCompressedPlutoniumDepleted; + public static Item rodCompressedPlutoniumDepleted_2; + public static Item rodCompressedPlutoniumDepleted_4; + public static Item rodCompressedUranium; + public static Item rodCompressedUranium_2; + public static Item rodCompressedUranium_4; + public static Item rodCompressedPlutonium; + public static Item rodCompressedPlutonium_2; + public static Item rodCompressedPlutonium_4; + + public static void RegisterRod() { + rodCompressedUraniumDepleted = new RadioactiveItem("rodCompressedUraniumDepleted", addText("depletedfuelrod.tooltip", 1), GoodGenerator.GG, 100); + rodCompressedUraniumDepleted_2 = new RadioactiveItem("rodCompressedUraniumDepleted2", addText("depletedfuelrod.tooltip", 1), GoodGenerator.GG, 200); + rodCompressedUraniumDepleted_4 = new RadioactiveItem("rodCompressedUraniumDepleted4", addText("depletedfuelrod.tooltip", 1), GoodGenerator.GG, 400); + rodCompressedPlutoniumDepleted = new RadioactiveItem("rodCompressedPlutoniumDepleted", addText("depletedfuelrod.tooltip", 1), GoodGenerator.GG, 120); + rodCompressedPlutoniumDepleted_2 = new RadioactiveItem("rodCompressedPlutoniumDepleted2", addText("depletedfuelrod.tooltip", 1), GoodGenerator.GG, 240); + rodCompressedPlutoniumDepleted_4 = new RadioactiveItem("rodCompressedPlutoniumDepleted4", addText("depletedfuelrod.tooltip", 1), GoodGenerator.GG, 480); + + GameRegistry.registerItem(rodCompressedUraniumDepleted, "rodCompressedUraniumDepleted", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodCompressedUraniumDepleted_2, "rodCompressedUraniumDepleted2", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodCompressedUraniumDepleted_4, "rodCompressedUraniumDepleted4", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodCompressedPlutoniumDepleted, "rodCompressedPlutoniumDepleted", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodCompressedPlutoniumDepleted_2, "rodCompressedPlutoniumDepleted2", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodCompressedPlutoniumDepleted_4, "rodCompressedPlutoniumDepleted4", GoodGenerator.MOD_ID); + + rodCompressedUranium = new FuelRod("rodCompressedUranium", 1, 100, 4, 800, 70000, new ItemStack(rodCompressedUraniumDepleted, 1), GoodGenerator.GG); + rodCompressedUranium_2 = new FuelRod("rodCompressedUranium2", 2, 100, 4, 1600, 70000, new ItemStack(rodCompressedUraniumDepleted_2, 1), GoodGenerator.GG); + rodCompressedUranium_4 = new FuelRod("rodCompressedUranium4", 4, 100, 4, 3200, 70000, new ItemStack(rodCompressedUraniumDepleted_4, 1), GoodGenerator.GG); + rodCompressedPlutonium = new FuelRod("rodCompressedPlutonium", 1, 50, 4, 1000, 30000, 6, new ItemStack(rodCompressedPlutoniumDepleted, 1), GoodGenerator.GG); + rodCompressedPlutonium_2 = new FuelRod("rodCompressedPlutonium2", 2, 50, 4, 2000, 30000, 6, new ItemStack(rodCompressedPlutoniumDepleted_2, 1), GoodGenerator.GG); + rodCompressedPlutonium_4 = new FuelRod("rodCompressedPlutonium4", 4, 50, 4, 4000, 30000, 6, new ItemStack(rodCompressedPlutoniumDepleted_4, 1), GoodGenerator.GG); + + GameRegistry.registerItem(rodCompressedUranium, "rodCompressedUranium", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodCompressedUranium_2, "rodCompressedUranium2", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodCompressedUranium_4, "rodCompressedUranium4", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodCompressedPlutonium, "rodCompressedPlutonium", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodCompressedPlutonium_2, "rodCompressedPlutonium2", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodCompressedPlutonium_4, "rodCompressedPlutonium4", GoodGenerator.MOD_ID); + } +} diff --git a/src/main/java/goodgenerator/loader/Loaders.java b/src/main/java/goodgenerator/loader/Loaders.java new file mode 100644 index 0000000000..95c956a85a --- /dev/null +++ b/src/main/java/goodgenerator/loader/Loaders.java @@ -0,0 +1,215 @@ +package goodgenerator.loader; + +import goodgenerator.blocks.myFluids.FluidsBuilder; +import goodgenerator.blocks.regularBlock.Casing; +import goodgenerator.blocks.regularBlock.ComplexTextureCasing; +import goodgenerator.blocks.regularBlock.Frame; +import goodgenerator.blocks.regularBlock.TEBlock; +import goodgenerator.blocks.tileEntity.*; +import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronAccelerator; +import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronSensor; +import goodgenerator.crossmod.nei.IMCForNEI; +import goodgenerator.crossmod.nei.NEI_Config; +import goodgenerator.crossmod.thaumcraft.LargeEssentiaEnergyData; +import goodgenerator.items.MyItemBlocks; +import goodgenerator.items.MyItems; +import goodgenerator.items.RadioactiveItem; +import goodgenerator.items.nuclear.NuclearMetaItemGenerator; +import goodgenerator.main.GoodGenerator; +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.render.TextureFactory; +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +import static goodgenerator.util.DescTextLocalization.addText; + +public class Loaders { + + public static final int IDOffset = 32001; + public static final byte GoodGeneratorTexturePage = 12; + + public static final Item _null_ = new MyItems("_null_", null); + + public static final Item radiationProtectionPlate = new MyItems("radiationProtectionPlate", GoodGenerator.GG); + public static final Item wrappedUraniumIngot = new MyItems("wrappedUraniumIngot", GoodGenerator.GG); + public static final Item highDensityUraniumNugget = new RadioactiveItem("highDensityUraniumNugget", GoodGenerator.GG, 200); + public static final Item highDensityUranium = new RadioactiveItem("highDensityUranium", GoodGenerator.GG, 1800); + public static final Item wrappedThoriumIngot = new MyItems("wrappedThoriumIngot", GoodGenerator.GG); + public static final Item highDensityThoriumNugget = new RadioactiveItem("highDensityThoriumNugget", GoodGenerator.GG, 50); + public static final Item highDensityThorium = new RadioactiveItem("highDensityThorium", GoodGenerator.GG, 450); + public static final Item wrappedPlutoniumIngot = new MyItems("wrappedPlutoniumIngot", GoodGenerator.GG); + public static final Item highDensityPlutoniumNugget = new RadioactiveItem("highDensityPlutoniumNugget", GoodGenerator.GG, 450); + public static final Item highDensityPlutonium = new RadioactiveItem("highDensityPlutonium", GoodGenerator.GG, 4050); + public static final Item rawAtomicSeparationCatalyst = new MyItems("rawAtomicSeparationCatalyst", GoodGenerator.GG); + public static final Item advancedRadiationProtectionPlate = new MyItems("advancedRadiationProtectionPlate", GoodGenerator.GG); + public static final Item aluminumNitride = new MyItems("aluminumNitride", "AlN", GoodGenerator.GG); + public static final Item specialCeramics = new MyItems("specialCeramics", GoodGenerator.GG); + public static final Item specialCeramicsPlate = new MyItems("specialCeramicsPlate", GoodGenerator.GG); + public static final Item radioactiveWaste = new RadioactiveItem("radioactiveWaste", GoodGenerator.GG, 400); + public static final Item plasticCase = new MyItems("plasticCase", GoodGenerator.GG); + public static final Item quartzWafer = new MyItems("quartzWafer", GoodGenerator.GG); + public static final Item microHeater = new MyItems("microHeater", GoodGenerator.GG); + 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 Item advancedFuelRod = new MyItems("advancedFuelRod", GoodGenerator.GG); + public static final Item fluidCore = new MyItems("fluidCore", GoodGenerator.GG, new String[]{GoodGenerator.MOD_ID+":fluidCore/1", GoodGenerator.MOD_ID+":fluidCore/2", GoodGenerator.MOD_ID+":fluidCore/3", GoodGenerator.MOD_ID+":fluidCore/4", GoodGenerator.MOD_ID+":fluidCore/5", GoodGenerator.MOD_ID+":fluidCore/6"}); + public static final Item upgradeEssentia = new MyItems("upgradeEssentia", GoodGenerator.GG, new String[]{GoodGenerator.MOD_ID+":upgradeEssentia/null", GoodGenerator.MOD_ID+":upgradeEssentia/air", GoodGenerator.MOD_ID+":upgradeEssentia/thermal", GoodGenerator.MOD_ID+":upgradeEssentia/unstable", GoodGenerator.MOD_ID+":upgradeEssentia/victus", GoodGenerator.MOD_ID+":upgradeEssentia/tainted", GoodGenerator.MOD_ID+":upgradeEssentia/mechanics", GoodGenerator.MOD_ID+":upgradeEssentia/spirit", GoodGenerator.MOD_ID+":upgradeEssentia/radiation", GoodGenerator.MOD_ID+":upgradeEssentia/electric"}); + + 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"}); + public static final Block FRF_Coil_1 = new Casing("FRF_Coil_1", new String[]{GoodGenerator.MOD_ID+":FRF_Coils/1"}); + public static final Block FRF_Coil_2 = new Casing("FRF_Coil_2", new String[]{GoodGenerator.MOD_ID+":FRF_Coils/2"}); + public static final Block FRF_Coil_3 = new Casing("FRF_Coil_3", new String[]{GoodGenerator.MOD_ID+":FRF_Coils/3"}); + public static final Block radiationProtectionSteelFrame = new Frame("radiationProtectionSteelFrame", new String[]{GoodGenerator.MOD_ID+":radiationProtectionSteelFrame"}); + public static final Block fieldRestrictingGlass = new Frame("fieldRestrictingGlass", new String[]{GoodGenerator.MOD_ID+":fieldRestrictingGlass"}); + public static final Block rawCylinder = new Casing("rawCylinder", new String[]{GoodGenerator.MOD_ID+":rawCylinder"}); + public static final Block titaniumPlatedCylinder = new Casing("titaniumPlatedCylinder", new String[]{GoodGenerator.MOD_ID+":titaniumPlatedCylinder"}); + public static final Block magicCasing = new Casing("magicCasing", new String[]{GoodGenerator.MOD_ID+":MagicCasing"}); + public static final Block essentiaCell = new Casing("essentiaCell", new String[]{GoodGenerator.MOD_ID+":essentiaCell/1",GoodGenerator.MOD_ID+":essentiaCell/2",GoodGenerator.MOD_ID+":essentiaCell/3",GoodGenerator.MOD_ID+":essentiaCell/4"}); + public static final Block speedingPipe = new ComplexTextureCasing("speedingPipe", new String[]{GoodGenerator.MOD_ID+":speedingPipe_SIDE"}, new String[]{GoodGenerator.MOD_ID+":speedingPipe_TOP"}); + public static final Block yottaFluidTankCell = new Casing("yottaFluidTankCell", new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCell/1", GoodGenerator.MOD_ID+":yottaFluidTankCell/2", GoodGenerator.MOD_ID+":yottaFluidTankCell/3", GoodGenerator.MOD_ID+":yottaFluidTankCell/4", GoodGenerator.MOD_ID+":yottaFluidTankCell/5", + GoodGenerator.MOD_ID+":yottaFluidTankCell/6", GoodGenerator.MOD_ID+":yottaFluidTankCell/7", GoodGenerator.MOD_ID+":yottaFluidTankCell/8", GoodGenerator.MOD_ID+":yottaFluidTankCell/9", GoodGenerator.MOD_ID+":yottaFluidTankCell/10",}); + public static final Block yottaFluidTankCasing = new ComplexTextureCasing("yottaFluidTankCasing", new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCasing_SIDE"}, new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCasing_TOP"}); + + public static Block essentiaHatch; + + public static ItemStack MAR; + public static ItemStack FRF; + public static ItemStack UCFE; + public static ItemStack LEG; + public static ItemStack NS; + public static ItemStack NA; + public static ItemStack YFT; + + public static ItemStack[] NeutronAccelerators = new ItemStack[9]; + + public static Item Isotope = new NuclearMetaItemGenerator(); + + public static void GTMetaTileRegister(){ + 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); + for (int i = 0; i < 9; i ++) { + Loaders.NeutronAccelerators[i] = new NeutronAccelerator(IDOffset + 2 + i, "Neutron Accelerator " + GT_Values.VN[i], "Neutron Accelerator " + GT_Values.VN[i], i).getStackForm(1L); + } + Loaders.NS = new NeutronSensor(IDOffset + 11, "Neutron Sensor", "Neutron Sensor", 5).getStackForm(1L); + Loaders.NA = new NeutronActivator(IDOffset + 12, "NeutronActivator", "Neutron Activator").getStackForm(1L); + Loaders.YFT = new YottaFluidTank(IDOffset + 13, "YottaFluidTank", "YOTTank").getStackForm(1L); + } + + public static void Register() { + + GameRegistry.registerItem(_null_, "_null_", GoodGenerator.MOD_ID); + NEI_Config.hide(_null_); + + GameRegistry.registerBlock(MAR_Casing, MyItemBlocks.class, "MAR_Casing"); + GameRegistry.registerBlock(radiationProtectionSteelFrame, MyItemBlocks.class, "radiationProtectionSteelFrame"); + GameRegistry.registerBlock(fieldRestrictingGlass, MyItemBlocks.class, "fieldRestrictingGlass"); + GameRegistry.registerBlock(FRF_Casings, MyItemBlocks.class, "FRF_Casings"); + GameRegistry.registerBlock(FRF_Coil_1, MyItemBlocks.class, "FRF_Coil_1"); + GameRegistry.registerBlock(FRF_Coil_2, MyItemBlocks.class, "FRF_Coil_2"); + GameRegistry.registerBlock(FRF_Coil_3, MyItemBlocks.class, "FRF_Coil_3"); + GameRegistry.registerBlock(rawCylinder, MyItemBlocks.class, "rawCylinder"); + GameRegistry.registerBlock(titaniumPlatedCylinder, MyItemBlocks.class, "titaniumPlatedCylinder"); + GameRegistry.registerBlock(speedingPipe, MyItemBlocks.class, "speedingPipe"); + GameRegistry.registerBlock(yottaFluidTankCell, MyItemBlocks.class, "yottaFluidTankCells"); + GameRegistry.registerBlock(yottaFluidTankCasing, MyItemBlocks.class, "yottaFluidTankCasing"); + GameRegistry.registerItem(radiationProtectionPlate, "radiationProtectionPlate", GoodGenerator.MOD_ID); + GameRegistry.registerItem(wrappedUraniumIngot, "wrappedUraniumIngot", GoodGenerator.MOD_ID); + GameRegistry.registerItem(highDensityUraniumNugget, "highDensityUraniumNugget", GoodGenerator.MOD_ID); + GameRegistry.registerItem(highDensityUranium, "highDensityUranium", GoodGenerator.MOD_ID); + GameRegistry.registerItem(wrappedThoriumIngot, "wrappedThoriumIngot", GoodGenerator.MOD_ID); + GameRegistry.registerItem(highDensityThoriumNugget, "highDensityThoriumNugget", GoodGenerator.MOD_ID); + GameRegistry.registerItem(highDensityThorium, "highDensityThorium", GoodGenerator.MOD_ID); + GameRegistry.registerItem(wrappedPlutoniumIngot, "wrappedPlutoniumIngot", GoodGenerator.MOD_ID); + GameRegistry.registerItem(highDensityPlutoniumNugget, "highDensityPlutoniumNugget", GoodGenerator.MOD_ID); + GameRegistry.registerItem(highDensityPlutonium, "highDensityPlutonium", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rawAtomicSeparationCatalyst, "rawAtomicSeparationCatalyst", GoodGenerator.MOD_ID); + GameRegistry.registerItem(advancedRadiationProtectionPlate, "advancedRadiationProtectionPlate", GoodGenerator.MOD_ID); + GameRegistry.registerItem(aluminumNitride, "aluminumNitride", GoodGenerator.MOD_ID); + GameRegistry.registerItem(specialCeramics, "specialCeramics", GoodGenerator.MOD_ID); + GameRegistry.registerItem(specialCeramicsPlate, "specialCeramicsPlate", GoodGenerator.MOD_ID); + GameRegistry.registerItem(radioactiveWaste, "radioactiveWaste", GoodGenerator.MOD_ID); + GameRegistry.registerItem(plasticCase, "plasticCase", GoodGenerator.MOD_ID); + GameRegistry.registerItem(quartzWafer, "quartzWafer", GoodGenerator.MOD_ID); + GameRegistry.registerItem(microHeater, "microHeater", GoodGenerator.MOD_ID); + 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); + GameRegistry.registerItem(advancedFuelRod, "advancedFuelRod", GoodGenerator.MOD_ID); + GameRegistry.registerItem(fluidCore, "fluidCore", GoodGenerator.MOD_ID); + } + + public static void compactMod() { + if (Loader.isModLoaded("Thaumcraft")) { + LargeEssentiaEnergyData.processEssentiaData(); + GameRegistry.registerItem(upgradeEssentia, "upgradeEssentia", GoodGenerator.MOD_ID); + GameRegistry.registerTileEntity(EssentiaHatch.class, "EssentiaHatch"); + Loaders.LEG = new LargeEssentiaGenerator(IDOffset + 1, "LargeEssentiaGenerator", "Large Essentia Generator").getStackForm(1L); + essentiaHatch = new TEBlock("essentiaHatch", new String[]{GoodGenerator.MOD_ID + ":essentiaHatch"}, 1); + GameRegistry.registerBlock(magicCasing, MyItemBlocks.class, "magicCasing"); + GameRegistry.registerBlock(essentiaCell, MyItemBlocks.class, "essentiaCell"); + GameRegistry.registerBlock(essentiaHatch, MyItemBlocks.class, "essentiaHatch"); + } + } + + public static void addOreDic(){ + OreDictionary.registerOre("blockGlass", fieldRestrictingGlass); + OreDictionary.registerOre("blockGlassZPM", fieldRestrictingGlass); + OreDictionary.registerOre("dustAluminumNitride", aluminumNitride); + } + + public static void addTexturePage(){ + if (Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage] == null){ + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage] = new ITexture[128]; + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][0] = TextureFactory.of(magicCasing); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][1] = TextureFactory.of(yottaFluidTankCasing); + } + } + + public static void preInitLoad(){ + Register(); + addOreDic(); + addTexturePage(); + compactMod(); + FluidsBuilder.Register(); + FuelRodLoader.RegisterRod(); + } + + public static void initLoad(){ + GTMetaTileRegister(); + initLoadRecipes(); + IMCForNEI.IMCSender(); + } + + public static void postInitLoad(){ + postInitLoadRecipes(); + } + + public static void initLoadRecipes(){ + RecipeLoader.InitLoadRecipe(); + RecipeLoader_02.InitLoadRecipe(); + FuelRecipeLoader.RegisterFuel(); + NaquadahReworkRecipeLoader.RecipeLoad(); + } + + public static void postInitLoadRecipes(){ + RecipeLoader.RecipeLoad(); + RecipeLoader.Fixer(); + RecipeLoader_02.RecipeLoad(); + NeutronActivatorLoader.NARecipeLoad(); + } +} diff --git a/src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java b/src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java new file mode 100644 index 0000000000..7c3361eac4 --- /dev/null +++ b/src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java @@ -0,0 +1,1125 @@ +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 goodgenerator.main.GG_Config_Loader.EnableNaquadahRework; +import static gregtech.common.items.GT_MetaGenerated_Item_01.registerCauldronCleaningFor; + +public class NaquadahReworkRecipeLoader { + + public static void RecipeLoad(){ + + if (!EnableNaquadahRework) return; + + //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, + 120, + 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(32000) + }, + new FluidStack[]{ + enrichedNaquadahRichSolution.getFluidOrGas(4000), + wasteLiquid.getFluidOrGas(1000) + }, + new ItemStack[]{ + naquadahEarth.get(OrePrefixes.dust, 1), + triniumSulphate.get(OrePrefixes.dust, 1) + }, + 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), + 100, + 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[]{2000, 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(30000) + }, + 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, + 1920 + ); + + GT_Values.RA.addUniversalDistillationRecipe( + lowQualityNaquadriaSolution.getFluidOrGas(7000), + new FluidStack[]{ + P507.getFluidOrGas(1000), + naquadriaRichSolution.getFluidOrGas(5400), + Materials.DilutedSulfuricAcid.getFluid(12000) + }, + 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, + 100, + 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, 2), + 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 + ); + + GT_Values.RA.addBlastRecipe( + naquadahEarth.get(OrePrefixes.dust, 2), + GT_Utility.getIntegratedCircuit(2), + Materials.Nitrogen.getGas(1000), + null, + Materials.Naquadah.getNuggets(3), + null, + 2400, + 7680, + 5000 + ); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[]{ + GT_Utility.getIntegratedCircuit(24) + }, + new FluidStack[]{ + Materials.Ethylene.getGas(1000), + FluidRegistry.getFluidStack("steam", 2000) + }, + new FluidStack[]{ + Materials.Ethanol.getFluid(1000) + }, + null, + 400, + 480 + ); + + GT_Values.RA.addChemicalRecipeForBasicMachineOnly( + Materials.Ethylene.getCells(1), + GT_Utility.getIntegratedCircuit(24), + FluidRegistry.getFluidStack("steam", 2000), + null, + Materials.Ethanol.getCells(1), + null, + 400, + 480 + ); + + GT_Values.RA.addVacuumFreezerRecipe( + GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Naquadah, 1), + GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Naquadah, 1), + 330, + 7680 + ); + } + + 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, 8), 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, 8), 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), + GT_Utility.getIntegratedCircuit(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() { + + if (!EnableNaquadahRework) return; + + 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] = na