diff options
Diffstat (limited to 'goodgen/src/main/java/goodgenerator/loader')
10 files changed, 6556 insertions, 0 deletions
diff --git a/goodgen/src/main/java/goodgenerator/loader/AchievementLoader.java b/goodgen/src/main/java/goodgenerator/loader/AchievementLoader.java new file mode 100644 index 0000000000..2df30c8752 --- /dev/null +++ b/goodgen/src/main/java/goodgenerator/loader/AchievementLoader.java @@ -0,0 +1,4 @@ +package goodgenerator.loader; + +public class AchievementLoader { +} diff --git a/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java b/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java new file mode 100644 index 0000000000..f83712c7db --- /dev/null +++ b/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java @@ -0,0 +1,503 @@ +package goodgenerator.loader; + +import static goodgenerator.util.ItemRefer.Compassline_Casing_EV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_HV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_IV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_LV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_LuV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_MV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UEV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UHV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UIV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UMV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UXV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_ZPM; +import static goodgenerator.util.ItemRefer.Component_Assembly_Line; +import static goodgenerator.util.Log.LOGGER; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.HOURS; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.AssemblyLine; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME; + +import java.util.HashMap; + +import javax.annotation.Nullable; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import org.apache.logging.log4j.Level; + +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; +import com.github.technus.tectech.recipe.TT_recipeAdder; + +import cpw.mods.fml.common.registry.GameRegistry; +import goodgenerator.items.MyMaterial; +import goodgenerator.util.StackUtils; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.core.recipe.common.CI; + +public class ComponentAssemblyLineMiscRecipes { + + public static final String[] circuitTierMaterials = { "Primitive", "Basic", "Good", "Advanced", "Data", "Elite", + "Master", "Ultimate", "Superconductor", "Infinite", "Bio", "Optical", "Piko", "Quantum" }; + + static final HashMap<String, Integer> NameToTier = new HashMap<>(); + + static void run() { + for (int i = 0; i < circuitTierMaterials.length; i++) NameToTier.put(circuitTierMaterials[i], i); + // Cry about it + NameToTier.put("Nano", 11); + + generateCasingRecipes(); + generateWrapRecipes(); + // Try and find the ZPM Fluid solidifier + ItemStack solidifier; + try { + Class<?> c = Class.forName("com.dreammaster.gthandler.CustomItemList"); + Object maybeSolidifier = c.getMethod("valueOf", String.class) + .invoke(null, "FluidSolidifierZPM"); + solidifier = (ItemStack) (c.getMethod("get", long.class, Object[].class) + .invoke(maybeSolidifier, 16L, null)); + if (GT_Utility.isStackValid(solidifier)) LOGGER.log(Level.INFO, "ZPM Fluid Solidifier found."); + else throw new NullPointerException(); + } catch (Exception e) { + LOGGER.log(Level.ERROR, "ZPM Fluid Solidifier not found, falling back to IV.", e); + solidifier = ItemList.Machine_IV_FluidSolidifier.get(16); + } + + // The controller itself + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Compassline_Casing_EV.get(1)) + .metadata(RESEARCH_TIME, 1 * HOURS) + .itemInputs( + ItemList.Machine_Multi_Assemblyline.get(16L), + ItemList.Casing_Assembler.get(16L), + ItemList.Casing_Gearbox_TungstenSteel.get(32L), + ComponentType.Robot_Arm.getComponent(8) + .get(16), + ComponentType.Conveyor_Module.getComponent(8) + .get(32), + ComponentType.Electric_Motor.getComponent(7) + .get(32), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Polybenzimidazole, 16), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Iridium, 32), + solidifier, + getALCircuit(8, 16), + getALCircuit(7, 20), + getALCircuit(6, 24)) + .fluidInputs( + new FluidStack(FluidRegistry.getFluid("molten.indalloy140"), 144 * 12), + Materials.Naquadria.getMolten(144 * 16), + Materials.Lubricant.getFluid(5000)) + .itemOutputs(Component_Assembly_Line.get(1)) + .eut(TierEU.RECIPE_UHV / 2) + .duration(30 * SECONDS) + .addTo(AssemblyLine); + } + + /** Recipes for the Component Assembly Line Casings */ + private static void generateCasingRecipes() { + int t = 1; + // lv 1 + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Steel, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Steel, 4), + ComponentType.Robot_Arm.getComponent(t) + .get(4), + ComponentType.Electric_Piston.getComponent(t) + .get(8), + ComponentType.Electric_Motor.getComponent(t) + .get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Steel, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Tin, 6), + getCircuit(t, 16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1))) + .itemOutputs(Compassline_Casing_LV.get(1)) + .duration(16 * SECONDS) + .eut(GT_Values.VP[t]) + .addTo(assemblerRecipes); + // mv 2 + t++; + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Aluminium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Aluminium, 4), + ComponentType.Robot_Arm.getComponent(t) + .get(4), + ComponentType.Electric_Piston.getComponent(t) + .get(8), + ComponentType.Electric_Motor.getComponent(t) + .get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Aluminium, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.AnyCopper, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1))) + .itemOutputs(Compassline_Casing_MV.get(1)) + .duration(16 * SECONDS) + .eut(GT_Values.VP[t]) + .addTo(assemblerRecipes); + // hv 3 + t++; + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.StainlessSteel, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.StainlessSteel, 4), + ComponentType.Robot_Arm.getComponent(t) + .get(4), + ComponentType.Electric_Piston.getComponent(t) + .get(8), + ComponentType.Electric_Motor.getComponent(t) + .get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.StainlessSteel, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Gold, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1))) + .itemOutputs(Compassline_Casing_HV.get(1)) + .duration(16 * SECONDS) + .eut(GT_Values.VP[t]) + .addTo(assemblerRecipes); + // ev 4 + t++; + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Titanium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Titanium, 4), + ComponentType.Robot_Arm.getComponent(t) + .get(4), + ComponentType.Electric_Piston.getComponent(t) + .get(8), + ComponentType.Electric_Motor.getComponent(t) + .get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Titanium, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Aluminium, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1))) + .itemOutputs(Compassline_Casing_EV.get(1)) + .duration(16 * SECONDS) + .eut(GT_Values.VP[t]) + .addTo(assemblerRecipes); + // iv 5 + t++; + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.TungstenSteel, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.TungstenSteel, 4), + ComponentType.Robot_Arm.getComponent(t) + .get(4), + ComponentType.Electric_Piston.getComponent(t) + .get(8), + ComponentType.Electric_Motor.getComponent(t) + .get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.TungstenSteel, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Tungsten, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1))) + .itemOutputs(Compassline_Casing_IV.get(1)) + .duration(16 * SECONDS) + .eut(GT_Values.VP[t]) + .addTo(assemblerRecipes); + + Fluid sold = FluidRegistry.getFluid("molten.indalloy140"); + // Assline Recipes! + // luv 6 + t++; + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Compassline_Casing_IV.get(1)) + .metadata(RESEARCH_TIME, (2250 << t) * TICKS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Europium, 1), + WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.plateDense, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.gearGt, 4), + WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.gearGtSmall, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.VanadiumGallium, 8), + getALCircuit(t, 8), + getALCircuit(t - 1, 16)) + .fluidInputs( + new FluidStack(sold, 144 * t * 4), + CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2))) + .itemOutputs(Compassline_Casing_LuV.get(1)) + .eut(TierEU.RECIPE_IV) + .duration(30 * SECONDS) + .addTo(AssemblyLine); + // zpm 7 + t++; + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Compassline_Casing_LuV.get(1)) + .metadata(RESEARCH_TIME, (2250 << t) * TICKS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Iridium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Iridium, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Iridium, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Iridium, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Naquadah, 8), + getALCircuit(t, 8), + getALCircuit(t - 1, 16)) + .fluidInputs( + new FluidStack(sold, 144 * t * 4), + CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2))) + .itemOutputs(Compassline_Casing_ZPM.get(1)) + .eut(TierEU.RECIPE_LuV) + .duration(30 * SECONDS) + .addTo(AssemblyLine); + // uv 8 + t++; + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Compassline_Casing_ZPM.get(1)) + .metadata(RESEARCH_TIME, (2250 << t) * TICKS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Osmium, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Osmium, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Osmium, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.NaquadahAlloy, 8), + getALCircuit(t, 8), + getALCircuit(t - 1, 16)) + .fluidInputs( + new FluidStack(sold, 144 * t * 4), + CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2))) + .itemOutputs(Compassline_Casing_UV.get(1)) + .eut(TierEU.RECIPE_ZPM) + .duration(30 * SECONDS) + .addTo(AssemblyLine); + // uhv 9 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UV.get(1), + 375 << (t - 2), + 1 << (t - 3), + (int) TierEU.RECIPE_UV, + 1, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.CosmicNeutronium, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.CosmicNeutronium, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.CosmicNeutronium, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Bedrockium, 8), getALCircuit(t, 8), + getALCircuit(t - 1, 16) }, + new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) }, + Compassline_Casing_UHV.get(1), + 50 * SECONDS, + (int) TierEU.RECIPE_UV); + sold = FluidRegistry.getFluid("molten.mutatedlivingsolder"); + // uev 10 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UHV.get(1), + 375 << (t - 2), + 1 << (t - 3), + (int) TierEU.RECIPE_UHV, + 1, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Infinity, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Infinity, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Infinity, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Draconium, 8), getALCircuit(t, 8), + getALCircuit(t - 1, 16) }, + new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) }, + Compassline_Casing_UEV.get(1), + 50 * SECONDS, + (int) TierEU.RECIPE_UHV); + // uiv 11 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UEV.get(1), + 375 << (t - 2), + 1 << (t - 3), + (int) TierEU.RECIPE_UEV, + 1, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.TranscendentMetal, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, MaterialsUEVplus.TranscendentMetal, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, MaterialsUEVplus.TranscendentMetal, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.NetherStar, 8), getALCircuit(t, 8), + getALCircuit(t - 1, 16) }, + new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) }, + Compassline_Casing_UIV.get(1), + 50 * SECONDS, + (int) TierEU.RECIPE_UEV); + // umv 12 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UIV.get(1), + 375 << (t - 2), + 1 << (t - 3), + (int) TierEU.RECIPE_UIV, + 1, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, MaterialsUEVplus.SpaceTime, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, MaterialsUEVplus.SpaceTime, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Quantium, 8), getALCircuit(t, 8), + getALCircuit(t - 1, 16) }, + new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t - 1, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) }, + Compassline_Casing_UMV.get(1), + 50 * 20, + (int) TierEU.RECIPE_UIV); + // uxv 13 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UMV.get(1), + 375 << (t - 2), + 1 << (t - 3), + (int) TierEU.RECIPE_UMV, + 1, + new Object[] { + GT_OreDictUnificator + .get(OrePrefixes.frameGt, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 1), + GT_OreDictUnificator + .get(OrePrefixes.plateDense, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 3), + MyMaterial.shirabon.get(OrePrefixes.plateDense, 3), ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator + .get(OrePrefixes.gearGt, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 2), + MyMaterial.shirabon.get(OrePrefixes.gearGt, 2), + GT_OreDictUnificator + .get(OrePrefixes.gearGtSmall, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 8), + MyMaterial.shirabon.get(OrePrefixes.gearGtSmall, 8), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Infinity, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, MaterialsUEVplus.SpaceTime, 4), getALCircuit(t, 8), + getALCircuit(t - 1, 16) }, + new FluidStack[] { new FluidStack(sold, 144 * t * 4), + MaterialsUEVplus.BlackDwarfMatter.getMolten(144 * t * 2), MaterialsUEVplus.Eternity.getMolten(144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2)) }, + Compassline_Casing_UXV.get(1), + 50 * SECONDS, + (int) TierEU.RECIPE_UMV); + } + + private static void generateWrapRecipes() { + for (int i = 0; i <= 11; i++) { + GT_Values.RA.stdBuilder() + .itemInputs(getCircuit(i, 16), GT_Utility.getIntegratedCircuit(16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(72L)) + .itemOutputs(new ItemStack(Loaders.circuitWrap, 1, i)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + } + GT_Values.RA.stdBuilder() + .itemInputs( + GameRegistry.findItemStack("dreamcraft", "item.PikoCircuit", 16), + GT_Utility.getIntegratedCircuit(16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(72L)) + .itemOutputs(new ItemStack(Loaders.circuitWrap, 1, 12)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GameRegistry.findItemStack("dreamcraft", "item.QuantumCircuit", 16), + GT_Utility.getIntegratedCircuit(16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(72L)) + .itemOutputs(new ItemStack(Loaders.circuitWrap, 1, 13)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + } + + @SuppressWarnings("unused") + private enum ComponentType { + + Electric_Motor, + Electric_Piston, + Robot_Arm, + Electric_Pump, + Field_Generator, + Conveyor_Module, + Emitter, + Sensor; + + public ItemList getComponent(int tier) { + if (tier < 0 || tier > GT_Values.VN.length) throw new IllegalArgumentException("Tier is out of range!"); + return ItemList.valueOf(this.name() + "_" + GT_Values.VN[tier]); + } + } + + private static ItemStack getCircuit(int tier, long amount) { + return GT_OreDictUnificator.get(OrePrefixes.circuit, getCircuitMaterial(tier), amount); + } + + private static Object[] getALCircuit(int tier, int amount) { + return new Object[] { OrePrefixes.circuit.get(getCircuitMaterial(tier)), amount }; + } + + @Nullable + public static Materials getCircuitMaterial(int tier) { + return Materials.getRealMaterial(circuitTierMaterials[tier]); + } +} diff --git a/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java b/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java new file mode 100644 index 0000000000..f1b16089d9 --- /dev/null +++ b/goodgen/src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java @@ -0,0 +1,484 @@ +package goodgenerator.loader; + +import static goodgenerator.util.StackUtils.getTotalItems; +import static goodgenerator.util.StackUtils.mergeStacks; +import static goodgenerator.util.StackUtils.multiplyAndSplitIntoStacks; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.stream.Collectors; + +import javax.annotation.Nullable; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +import org.apache.commons.lang3.tuple.Pair; + +import goodgenerator.util.MyRecipeAdder; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.objects.ItemData; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gregtech.common.items.GT_IntegratedCircuit_Item; + +public class ComponentAssemblyLineRecipeLoader { + + private static final String[] compPrefixes = { "Electric_Motor_", "Electric_Piston_", "Electric_Pump_", + "Robot_Arm_", "Conveyor_Module_", "Emitter_", "Sensor_", "Field_Generator_", }; + private static final String[] blacklistedDictPrefixes = { "circuit" }; + private static final String[] softBlacklistedDictPrefixes = { "Any", "crafting", "nanite" }; + private static final String moltenMHDCSM = "molten.magnetohydrodynamicallyconstrainedstarmatter"; + + private static LinkedHashMap<List<GT_Recipe>, Pair<ItemList, Integer>> allAssemblerRecipes; + private static LinkedHashMap<List<GT_Recipe.GT_Recipe_AssemblyLine>, Pair<ItemList, Integer>> allAsslineRecipes; + + private static final HashMap<OrePrefixes, Double> magnetoConversionMultipliers = new HashMap<>(); + private static final HashMap<OrePrefixes, OrePrefixes> conversion = new HashMap<>(); + + private static final int INPUT_MULTIPLIER = 48; + private static final int OUTPUT_MULTIPLIER = 64; + private static final int FLUID_CONVERSION_STACKSIZE_THRESHOLD = 64; + + public static void run() { + ComponentAssemblyLineMiscRecipes.run(); + conversion.put(OrePrefixes.cableGt01, OrePrefixes.cableGt16); + conversion.put(OrePrefixes.wireGt01, OrePrefixes.wireGt16); + conversion.put(OrePrefixes.cableGt02, OrePrefixes.cableGt16); + conversion.put(OrePrefixes.wireGt02, OrePrefixes.wireGt16); + conversion.put(OrePrefixes.cableGt04, OrePrefixes.cableGt16); + conversion.put(OrePrefixes.wireGt04, OrePrefixes.wireGt16); + conversion.put(OrePrefixes.cableGt08, OrePrefixes.cableGt16); + conversion.put(OrePrefixes.wireGt08, OrePrefixes.wireGt16); + conversion.put(OrePrefixes.plate, OrePrefixes.plateDense); + conversion.put(OrePrefixes.foil, OrePrefixes.plate); + conversion.put(OrePrefixes.stick, OrePrefixes.stickLong); + conversion.put(OrePrefixes.gearGtSmall, OrePrefixes.gearGt); + magnetoConversionMultipliers.put(OrePrefixes.frameGt, 1.0); + magnetoConversionMultipliers.put(OrePrefixes.plate, 1.0); + magnetoConversionMultipliers.put(OrePrefixes.plateDense, 3.0); + magnetoConversionMultipliers.put(OrePrefixes.stick, 1.0 / 2.0); + magnetoConversionMultipliers.put(OrePrefixes.round, 1.0 / 8.0); + magnetoConversionMultipliers.put(OrePrefixes.bolt, 1.0 / 8.0); + magnetoConversionMultipliers.put(OrePrefixes.screw, 1.0 / 8.0); + magnetoConversionMultipliers.put(OrePrefixes.ring, 1.0 / 4.0); + magnetoConversionMultipliers.put(OrePrefixes.foil, 1.0 / 8.0); + magnetoConversionMultipliers.put(OrePrefixes.gearGtSmall, 1.0); + magnetoConversionMultipliers.put(OrePrefixes.rotor, 2.0); + magnetoConversionMultipliers.put(OrePrefixes.stickLong, 1.0); + magnetoConversionMultipliers.put(OrePrefixes.gearGt, 2.0); + magnetoConversionMultipliers.put(OrePrefixes.wireFine, 1.0 / 8.0); + findAllRecipes(); + generateAssemblerRecipes(); + generateAsslineRecipes(); + } + + /** Normal assembler recipes (LV-IV) */ + private static void generateAssemblerRecipes() { + allAssemblerRecipes.forEach((recipeList, info) -> { + for (GT_Recipe recipe : recipeList) { + if (recipe != null) { + ArrayList<ItemStack> fixedInputs = new ArrayList<>(); + ArrayList<FluidStack> fixedFluids = new ArrayList<>(); + + for (int j = 0; j < recipe.mInputs.length; j++) { + ItemStack input = recipe.mInputs[j]; + if (GT_Utility.isStackValid(input) && !(input.getItem() instanceof GT_IntegratedCircuit_Item)) + fixedInputs.addAll(multiplyAndSplitIntoStacks(input, INPUT_MULTIPLIER)); + } + for (int j = 0; j < recipe.mFluidInputs.length; j++) { + FluidStack currFluid = recipe.mFluidInputs[j].copy(); + currFluid.amount = currFluid.amount * INPUT_MULTIPLIER; + fixedFluids.add(currFluid); + } + + fixedInputs = compactItems(fixedInputs, info.getRight()); + replaceIntoFluids(fixedInputs, fixedFluids, 64); + int tier = info.getRight(); + int energy = (int) Math.min(Integer.MAX_VALUE - 7, GT_Values.VP[tier - 1]); + MyRecipeAdder.instance.addComponentAssemblyLineRecipe( + fixedInputs.toArray(new ItemStack[0]), + fixedFluids.toArray(new FluidStack[0]), + info.getLeft() + .get(OUTPUT_MULTIPLIER), + recipe.mDuration * INPUT_MULTIPLIER, + energy, + info.getRight()); + } + } + }); + } + + /** Assembly Line Recipes (LuV+) **/ + private static void generateAsslineRecipes() { + allAsslineRecipes.forEach((recipeList, info) -> { + for (GT_Recipe.GT_Recipe_AssemblyLine recipe : recipeList) { + if (recipe != null) { + int componentCircuit = -1; + for (int i = 0; i < compPrefixes.length; i++) if (info.getLeft() + .toString() + .startsWith(compPrefixes[i])) componentCircuit = i + 1; + if (componentCircuit == -1) { + throw new NullPointerException( + "Wrong circuit. Comp: " + info.getLeft() + .toString()); + } + final boolean addProgrammedCircuit = componentCircuit <= 7; + // Arrays of the item and fluid inputs, that are updated to be multiplied and/or condensed in the + // following code + ArrayList<ItemStack> fixedInputs = new ArrayList<>(); + ArrayList<FluidStack> fixedFluids = new ArrayList<>(); + + // Multiplies the original fluid inputs + for (int j = 0; j < recipe.mFluidInputs.length; j++) { + FluidStack currFluid = recipe.mFluidInputs[j].copy(); + currFluid.amount *= (double) INPUT_MULTIPLIER; + fixedFluids.add(currFluid); + } + + // First pass. + for (ItemStack input : recipe.mInputs) { + if (GT_Utility.isStackValid(input)) { + int count = input.stackSize; + // Mulitplies the input by its multiplier, and adjusts the stacks accordingly + if (!(input.getItem() instanceof GT_IntegratedCircuit_Item)) { + + ItemData data = GT_OreDictUnificator.getAssociation(input); + // trying to fix some circuit oredicting issues + + if (data != null && data.mPrefix == OrePrefixes.circuit) fixedInputs.addAll( + multiplyAndSplitIntoStacks( + GT_OreDictUnificator.get(data.mPrefix, data.mMaterial.mMaterial, count), + INPUT_MULTIPLIER)); + else fixedInputs.addAll(multiplyAndSplitIntoStacks(input, INPUT_MULTIPLIER)); + } + } + } + fixedInputs = compactItems(fixedInputs, info.getRight()); + replaceIntoFluids(fixedInputs, fixedFluids, FLUID_CONVERSION_STACKSIZE_THRESHOLD); + // If it overflows then it tries REALLY HARD to cram as much stuff into there. + if (fixedInputs.size() > (addProgrammedCircuit ? 8 : 9)) + replaceIntoFluids(fixedInputs, fixedFluids, FLUID_CONVERSION_STACKSIZE_THRESHOLD / 2); + if (addProgrammedCircuit) fixedInputs.add(GT_Utility.getIntegratedCircuit(componentCircuit)); + + addEternityForMHDCSM(fixedFluids); + MyRecipeAdder.instance.addComponentAssemblyLineRecipe( + fixedInputs.toArray(new ItemStack[0]), + fixedFluids.toArray(new FluidStack[0]), + info.getLeft() + .get(OUTPUT_MULTIPLIER), // The component output + recipe.mDuration * INPUT_MULTIPLIER, // Takes as long as this many + recipe.mEUt, + info.getRight()); // Casing tier + + // Add a second recipe using Styrene-Butadiene + // Rubber instead of Silicone Rubber. + // This relies on silicone rubber being first in + // @allSyntheticRubber so it's quite fragile, but + // it's also the least invasive change. + if (swapSiliconeForStyreneButadiene(fixedFluids)) { + MyRecipeAdder.instance.addComponentAssemblyLineRecipe( + fixedInputs.toArray(new ItemStack[0]), + fixedFluids.toArray(new FluidStack[0]), + info.getLeft() + .get(OUTPUT_MULTIPLIER), // The component output + recipe.mDuration * INPUT_MULTIPLIER, // Takes as long as this many + recipe.mEUt, + info.getRight()); // Casing tier + } + } + } + }); + } + + /** + * Looks for a matching FluidStack and merges the amount of the converted fluid with the one it found. Otherwise, it + * will add the converted to the fluid inputs. + */ + private static void replaceIntoFluids(List<ItemStack> inputs, List<FluidStack> fluidOutputs, int threshold) { + HashMap<ItemStack, Integer> totals = getTotalItems(inputs.toArray(new ItemStack[0])); + ArrayList<ItemStack> newInputs = new ArrayList<>(); + for (ItemStack input : totals.keySet()) { + int count = totals.get(input); + boolean isConverted = false; + if (OreDictionary.getOreIDs(input).length > 0 && count > threshold) { + FluidStack foundFluidStack = tryConvertItemStackToFluidMaterial(input); + + ItemData data = GT_OreDictUnificator.getAssociation(input); + + // Prevents the uncraftable molten magnetic samarium from being converted into fluid during auto + // generation + if (data != null && data.mMaterial.mMaterial == Materials.SamariumMagnetic) { + input = GT_OreDictUnificator.get(data.mPrefix, Materials.Samarium, 1); + foundFluidStack = tryConvertItemStackToFluidMaterial(input); + } else if (data != null && data.mMaterial.mMaterial == Materials.TengamAttuned) { + input = GT_OreDictUnificator.get(data.mPrefix, Materials.TengamPurified, 1); + foundFluidStack = tryConvertItemStackToFluidMaterial(input); + } + + if (foundFluidStack != null) { + foundFluidStack.amount *= count; + boolean alreadyHasFluid = false; + for (FluidStack fluidstack : fluidOutputs) { + if (foundFluidStack.getFluid() + .equals(fluidstack.getFluid())) { + fluidstack.amount += foundFluidStack.amount; + alreadyHasFluid = true; + break; + } + } + if (!alreadyHasFluid) { + fluidOutputs.add(foundFluidStack); + } + isConverted = true; + } + } + if (!isConverted) { + newInputs.add(GT_Utility.copyAmountUnsafe(count, input)); + } + } + inputs.clear(); + inputs.addAll(newInputs); + } + + /** + * Tries to convert {@code input} into its molten form. Because the internal names for material fluids in GT5u, + * GT++, and BartWorks follow the same naming scheme, this method should work for any {@code ItemStack} from any of + * the 3 material systems. + */ + @Nullable + private static FluidStack tryConvertItemStackToFluidMaterial(ItemStack input) { + ArrayList<String> oreDicts = new ArrayList<>(); + for (int id : OreDictionary.getOreIDs(input)) { + oreDicts.add(OreDictionary.getOreName(id)); + } + oreDictLoop: for (String dict : oreDicts) { + for (String blacklistedPrefix : blacklistedDictPrefixes) { + if (dict.startsWith(blacklistedPrefix)) { + return null; + } + } + for (String blacklistedPrefix : softBlacklistedDictPrefixes) { + if (dict.startsWith(blacklistedPrefix)) { + continue oreDictLoop; + } + } + OrePrefixes orePrefix; + try { + orePrefix = OrePrefixes.valueOf(findBestPrefix(dict)); + } catch (Exception e) { + continue; + } + + String strippedOreDict = dict.substring( + orePrefix.toString() + .length()); + + // Prevents things like AnyCopper or AnyIron from messing the search up. + if (strippedOreDict.contains("Any")) continue; + if (strippedOreDict.contains("PTMEG")) return FluidRegistry.getFluidStack( + "molten.silicone", + (int) (orePrefix.mMaterialAmount / (GT_Values.M / 144)) * input.stackSize); + return FluidRegistry.getFluidStack( + "molten." + strippedOreDict.toLowerCase(), + (int) (orePrefix.mMaterialAmount / (GT_Values.M / 144)) * input.stackSize); + } + return null; + } + + /** + * Gives the longest Ore Prefix that the OreDictionary string starts with. This makes it the most accurate prefix. + * For example: If your OreDictionary is something like {@code gearGtSmallSpaceTime}, a conventional search would + * return something like {@code gearGt} instead of {@code gearGtSmall}. This makes the longer String the most + * accurate. + * + * @param oreDict The Ore Dictionary entry + * @return The longest ore prefix that the OreDict string starts with. This makes it the most accurate prefix. + */ + private static String findBestPrefix(String oreDict) { + int longestPrefixLength = 0; + String matchingPrefix = null; + for (OrePrefixes prefix : OrePrefixes.values()) { + String name = prefix.toString(); + if (oreDict.startsWith(name)) { + if (name.length() > longestPrefixLength) { + longestPrefixLength = name.length(); + matchingPrefix = name; + } + } + } + return matchingPrefix; + } + + /** + * Transforms each {@code ItemStack}, if possible, into a more compact form. For example, a stack of 16 1x cables, + * when passed into the {@code items} array, will be converted into a single 16x cable. Also handles GraviStar and + * neutronium nanite conversion. + */ + private static ArrayList<ItemStack> compactItems(List<ItemStack> items, int tier) { + ArrayList<ItemStack> stacks = new ArrayList<>(); + HashMap<ItemStack, Integer> totals = getTotalItems(items); + for (ItemStack itemstack : totals.keySet()) { + int totalItems = totals.get(itemstack); + ItemData data = GT_OreDictUnificator.getAssociation(itemstack); + boolean isCompacted = false; + + for (String dict : Arrays.stream(OreDictionary.getOreIDs(itemstack)) + .mapToObj(OreDictionary::getOreName) + .collect(Collectors.toList())) { + if (dict.startsWith("circuit")) { + stacks.addAll(getWrappedCircuits(itemstack, totalItems, dict)); + isCompacted = true; + break; + } + if (dict.contains("Magneto")) { + stacks.addAll(getMagnetoConversion(itemstack, totalItems)); + isCompacted = true; + break; + } + } + + if (data != null && !isCompacted) { + OrePrefixes goInto = conversion.get(data.mPrefix); + if (goInto != null && GT_OreDictUnificator.get(goInto, data.mMaterial.mMaterial, 1) != null) { + compactorHelper(data, goInto, stacks, totalItems); + isCompacted = true; + } + } + if (GT_Utility.areStacksEqual(itemstack, ItemList.Gravistar.get(1)) && tier >= 9) { + stacks.addAll(multiplyAndSplitIntoStacks(ItemList.NuclearStar.get(1), totalItems / 16)); + isCompacted = true; + } + if (GT_Utility + .areStacksEqual(itemstack, GT_OreDictUnificator.get(OrePrefixes.nanite, Materials.Neutronium, 1))) { + stacks.addAll( + multiplyAndSplitIntoStacks( + GT_OreDictUnificator.get(OrePrefixes.nanite, Materials.Gold, 1), + totalItems / 16)); + isCompacted = true; + } + if (!isCompacted) stacks.addAll(multiplyAndSplitIntoStacks(itemstack, totalItems)); + } + stacks = mergeStacks(stacks); + return stacks; + } + + /** A helper method for compacting items */ + private static void compactorHelper(ItemData data, OrePrefixes compactInto, ArrayList<ItemStack> output, + int total) { + int materialRatio = (int) ((double) compactInto.mMaterialAmount / data.mPrefix.mMaterialAmount); + output.addAll( + multiplyAndSplitIntoStacks( + GT_OreDictUnificator.get(compactInto, data.mMaterial.mMaterial, 1), + total / materialRatio)); + } + + /** + * Searches the Assembler and Assembly line registry for all the base component recipes. + */ + private static void findAllRecipes() { + allAssemblerRecipes = new LinkedHashMap<>(); + allAsslineRecipes = new LinkedHashMap<>(); + for (String compPrefix : compPrefixes) { + for (int t = 1; t <= 13; t++) { + String vName = GT_Values.VN[t]; + ItemList currentComponent = ItemList.valueOf(compPrefix + vName); + if (currentComponent.hasBeenSet()) { + if (t < 6) { + ArrayList<GT_Recipe> foundRecipes = new ArrayList<>(); + for (GT_Recipe recipe : RecipeMaps.assemblerRecipes.getAllRecipes()) { + if (GT_Utility.areStacksEqual(currentComponent.get(1), recipe.mOutputs[0])) { + foundRecipes.add(recipe); + } + } + allAssemblerRecipes.put(foundRecipes, Pair.of(currentComponent, t)); + } else { + ArrayList<GT_Recipe.GT_Recipe_AssemblyLine> foundRecipes = new ArrayList<>(); + for (GT_Recipe.GT_Recipe_AssemblyLine recipe : GT_Recipe.GT_Recipe_AssemblyLine.sAssemblylineRecipes) { + if (GT_Utility.areStacksEqual(currentComponent.get(1), recipe.mOutput)) { + foundRecipes.add(recipe); + } + } + allAsslineRecipes.put(foundRecipes, Pair.of(currentComponent, t)); + } + } + } + } + } + + private static List<ItemStack> getWrappedCircuits(ItemStack item, int total, String oreDict) { + ArrayList<ItemStack> stacks = new ArrayList<>(); + String circuitMaterial = oreDict.substring(7); + int tier = ComponentAssemblyLineMiscRecipes.NameToTier.get(circuitMaterial); + if (total >= 16) + stacks.addAll(multiplyAndSplitIntoStacks(new ItemStack(Loaders.circuitWrap, 1, tier), total / 16)); + else stacks.addAll(multiplyAndSplitIntoStacks(item, total)); + + return stacks; + } + + private static List<ItemStack> getMagnetoConversion(ItemStack item, int total) { + ArrayList<ItemStack> stacks = new ArrayList<>(); + ItemData data = GT_OreDictUnificator.getAssociation(item); + if (data == null) { + return stacks; + } + if (total >= FLUID_CONVERSION_STACKSIZE_THRESHOLD) { + double multiplier = magnetoConversionMultipliers.get(data.mPrefix); + stacks.addAll( + getWrappedCircuits( + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Infinite, 1), + (int) (total * multiplier), + "circuitInfinite")); + } + stacks.addAll(multiplyAndSplitIntoStacks(item, total)); + return stacks; + } + + private static void addEternityForMHDCSM(ArrayList<FluidStack> fluidInputs) { + boolean eternity = false; + boolean mhdcsm = false; + int mhdcsmAmount = 0; + + for (FluidStack fluidstack : fluidInputs) { + if (fluidstack.getFluid() + .equals(FluidRegistry.getFluid(moltenMHDCSM))) { + mhdcsm = true; + mhdcsmAmount = fluidstack.amount; + } + if (fluidstack.getFluid() + .equals(FluidRegistry.getFluid("molten.eternity"))) { + eternity = true; + } + } + + if (mhdcsm && !eternity) { + // 576 * 48 is substracted because uxv parts have 576L mhdcsm fluid (not solid, so no EIC conversion needed) + // in their assline recipes and each CoAl recipe has 48x recipe inputs + fluidInputs.add(MaterialsUEVplus.Eternity.getMolten(mhdcsmAmount - 576 * 48)); + } + } + + private static boolean swapSiliconeForStyreneButadiene(ArrayList<FluidStack> fluidInputs) { + for (int i = 0; i < fluidInputs.size(); i++) { + FluidStack fluidstack = fluidInputs.get(i); + if (fluidstack.getFluid() + .equals(FluidRegistry.getFluid("molten.silicone"))) { + fluidInputs.set(i, FluidRegistry.getFluidStack("molten.styrenebutadienerubber", fluidstack.amount)); + return true; + } + } + return false; + } +} diff --git a/goodgen/src/main/java/goodgenerator/loader/FuelRecipeLoader.java b/goodgen/src/main/java/goodgenerator/loader/FuelRecipeLoader.java new file mode 100644 index 0000000000..2a1981b201 --- /dev/null +++ b/goodgen/src/main/java/goodgenerator/loader/FuelRecipeLoader.java @@ -0,0 +1,168 @@ +package goodgenerator.loader; + +import static goodgenerator.main.GG_Config_Loader.NaquadahFuelTime; +import static goodgenerator.main.GG_Config_Loader.NaquadahFuelVoltage; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; + +import goodgenerator.items.MyMaterial; +import goodgenerator.util.ItemRefer; +import goodgenerator.util.MyRecipeAdder; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gtPlusPlus.core.material.ELEMENT; + +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.addLiquidMentalFuel( + MyMaterial.naquadahBasedFuelMkVI.getFluidOrGas(1), + MyMaterial.naquadahBasedFuelMkVIDepleted.getFluidOrGas(1), + NaquadahFuelVoltage[8], + NaquadahFuelTime[8]); + // MK III Naquadah Fuel + 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); + + // Alternative higher tier recipe + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.heavyNaquadahFuel.getFluidOrGas(800), + MyMaterial.lightNaquadahFuel.getFluidOrGas(1000), }, + new ItemStack[] { MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 8), + GT_ModHandler.getModItem("miscutils", "itemDustChromaticGlass", 9), + ItemRefer.High_Density_Uranium.get(2), ItemRefer.High_Density_Plutonium.get(1), }, + MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(200), + 2100000, + 100, + 1); + // MK IV Naquadah Fuel + 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); + + // Alternate higher tier recipe + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(2000), + new FluidStack(FluidRegistry.getFluid("molten.hypogen"), 1440) }, + new ItemStack[] { MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 27), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bedrockium, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64), + MyMaterial.orundum.get(OrePrefixes.dust, 64), }, + MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(500), + 75000000, + 160, + 2); + + // MK V Naquadah Fuel + 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); + + // Alternate higher tier recipe + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(2000), + FluidRegistry.getFluidStack("heavyradox", 1000), }, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.SpaceTime, 8), + GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.TranscendentMetal, 16), + MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.dust, 48), }, + MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(750), + 300000000, + 200, + 3); + + // MK VI Naquadah Fuel + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(2000), + FluidRegistry.getFluidStack("molten.shirabon", 1440), }, + new ItemStack[] { ELEMENT.STANDALONE.ASTRAL_TITANIUM.getDust(64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tritanium, 32), }, + MyMaterial.naquadahBasedFuelMkVI.getFluidOrGas(500), + 320000000, + 240, + 3); + + // Alternate higher tier recipe + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(2000), + FluidRegistry.getFluidStack("molten.shirabon", 1440), }, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.WhiteDwarfMatter, 8), + ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN.getDust(64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tritanium, 48), }, + MyMaterial.naquadahBasedFuelMkVI.getFluidOrGas(750), + 530000000, + 240, + 4); + + } +} diff --git a/goodgen/src/main/java/goodgenerator/loader/FuelRodLoader.java b/goodgen/src/main/java/goodgenerator/loader/FuelRodLoader.java new file mode 100644 index 0000000000..9654479861 --- /dev/null +++ b/goodgen/src/main/java/goodgenerator/loader/FuelRodLoader.java @@ -0,0 +1,248 @@ +package goodgenerator.loader; + +import static goodgenerator.util.DescTextLocalization.addText; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +import cpw.mods.fml.common.registry.GameRegistry; +import goodgenerator.items.DepletedFuelRod; +import goodgenerator.items.FuelRod; +import goodgenerator.main.GoodGenerator; + +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 rodLiquidUraniumDepleted; + public static Item rodLiquidUraniumDepleted_2; + public static Item rodLiquidUraniumDepleted_4; + public static Item rodLiquidPlutoniumDepleted; + public static Item rodLiquidPlutoniumDepleted_2; + public static Item rodLiquidPlutoniumDepleted_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 Item rodLiquidUranium; + public static Item rodLiquidUranium_2; + public static Item rodLiquidUranium_4; + public static Item rodLiquidPlutonium; + public static Item rodLiquidPlutonium_2; + public static Item rodLiquidPlutonium_4; + + public static void RegisterRod() { + rodCompressedUraniumDepleted = new DepletedFuelRod( + "rodCompressedUraniumDepleted", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 100); + rodCompressedUraniumDepleted_2 = new DepletedFuelRod( + "rodCompressedUraniumDepleted2", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 200); + rodCompressedUraniumDepleted_4 = new DepletedFuelRod( + "rodCompressedUraniumDepleted4", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 400); + rodCompressedPlutoniumDepleted = new DepletedFuelRod( + "rodCompressedPlutoniumDepleted", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 120); + rodCompressedPlutoniumDepleted_2 = new DepletedFuelRod( + "rodCompressedPlutoniumDepleted2", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 240); + rodCompressedPlutoniumDepleted_4 = new DepletedFuelRod( + "rodCompressedPlutoniumDepleted4", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 480); + rodLiquidUraniumDepleted = new DepletedFuelRod( + "rodLiquidUraniumDepleted", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 800); + rodLiquidUraniumDepleted_2 = new DepletedFuelRod( + "rodLiquidUraniumDepleted2", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 1600); + rodLiquidUraniumDepleted_4 = new DepletedFuelRod( + "rodLiquidUraniumDepleted4", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 3200); + rodLiquidPlutoniumDepleted = new DepletedFuelRod( + "rodLiquidPlutoniumDepleted", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 1000); + rodLiquidPlutoniumDepleted_2 = new DepletedFuelRod( + "rodLiquidPlutoniumDepleted2", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 2000); + rodLiquidPlutoniumDepleted_4 = new DepletedFuelRod( + "rodLiquidPlutoniumDepleted4", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 4000); + + 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); + GameRegistry.registerItem(rodLiquidUraniumDepleted, "rodLiquidUraniumDepleted", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodLiquidUraniumDepleted_2, "rodLiquidUraniumDepleted2", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodLiquidUraniumDepleted_4, "rodLiquidUraniumDepleted4", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodLiquidPlutoniumDepleted, "rodLiquidPlutoniumDepleted", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodLiquidPlutoniumDepleted_2, "rodLiquidPlutoniumDepleted2", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodLiquidPlutoniumDepleted_4, "rodLiquidPlutoniumDepleted4", 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); + rodLiquidUranium = new FuelRod( + "rodLiquidUranium", + 1, + 1200, + 64, + 8000, + 6000, + new ItemStack(rodLiquidUraniumDepleted, 1), + GoodGenerator.GG); + rodLiquidUranium_2 = new FuelRod( + "rodLiquidUranium2", + 2, + 1200, + 64, + 8000, + 6000, + new ItemStack(rodLiquidUraniumDepleted_2, 1), + GoodGenerator.GG); + rodLiquidUranium_4 = new FuelRod( + "rodLiquidUranium4", + 4, + 1200, + 64, + 8000, + 6000, + new ItemStack(rodLiquidUraniumDepleted_4, 1), + GoodGenerator.GG); + rodLiquidPlutonium = new FuelRod( + "rodLiquidPlutonium", + 1, + 1600, + 64, + 10000, + 10000, + 2, + new ItemStack(rodLiquidPlutoniumDepleted, 1), + GoodGenerator.GG); + rodLiquidPlutonium_2 = new FuelRod( + "rodLiquidPlutonium2", + 2, + 1600, + 64, + 10000, + 10000, + 2, + new ItemStack(rodLiquidPlutoniumDepleted_2, 1), + GoodGenerator.GG); + rodLiquidPlutonium_4 = new FuelRod( + "rodLiquidPlutonium4", + 4, + 1600, + 64, + 10000, + 10000, + 2, + new ItemStack(rodLiquidPlutoniumDepleted_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); + GameRegistry.registerItem(rodLiquidUranium, "rodLiquidUranium", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodLiquidUranium_2, "rodLiquidUranium2", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodLiquidUranium_4, "rodLiquidUranium4", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodLiquidPlutonium, "rodLiquidPlutonium", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodLiquidPlutonium_2, "rodLiquidPlutonium2", GoodGenerator.MOD_ID); + GameRegistry.registerItem(rodLiquidPlutonium_4, "rodLiquidPlutonium4", GoodGenerator.MOD_ID); + } +} diff --git a/goodgen/src/main/java/goodgenerator/loader/Loaders.java b/goodgen/src/main/java/goodgenerator/loader/Loaders.java new file mode 100644 index 0000000000..30ca824dc0 --- /dev/null +++ b/goodgen/src/main/java/goodgenerator/loader/Loaders.java @@ -0,0 +1,489 @@ +package goodgenerator.loader; + +import static goodgenerator.util.DescTextLocalization.addText; +import static gregtech.api.enums.Mods.GTPlusPlus; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.registry.GameRegistry; +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.regularBlock.TurbineCasing; +import goodgenerator.blocks.tileEntity.ComponentAssemblyLine; +import goodgenerator.blocks.tileEntity.CoolantTower; +import goodgenerator.blocks.tileEntity.EssentiaHatch; +import goodgenerator.blocks.tileEntity.EssentiaOutputHatch; +import goodgenerator.blocks.tileEntity.EssentiaOutputHatch_ME; +import goodgenerator.blocks.tileEntity.ExtremeHeatExchanger; +import goodgenerator.blocks.tileEntity.FuelRefineFactory; +import goodgenerator.blocks.tileEntity.GTMetaTileEntity.DieselGenerator; +import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronAccelerator; +import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronSensor; +import goodgenerator.blocks.tileEntity.GTMetaTileEntity.YOTTAHatch; +import goodgenerator.blocks.tileEntity.LargeEssentiaGenerator; +import goodgenerator.blocks.tileEntity.LargeEssentiaSmeltery; +import goodgenerator.blocks.tileEntity.LargeFusionComputer1; +import goodgenerator.blocks.tileEntity.LargeFusionComputer2; +import goodgenerator.blocks.tileEntity.LargeFusionComputer3; +import goodgenerator.blocks.tileEntity.LargeFusionComputer4; +import goodgenerator.blocks.tileEntity.LargeFusionComputer5; +import goodgenerator.blocks.tileEntity.MultiNqGenerator; +import goodgenerator.blocks.tileEntity.NeutronActivator; +import goodgenerator.blocks.tileEntity.PreciseAssembler; +import goodgenerator.blocks.tileEntity.SupercriticalFluidTurbine; +import goodgenerator.blocks.tileEntity.UniversalChemicalFuelEngine; +import goodgenerator.blocks.tileEntity.YottaFluidTank; +import goodgenerator.client.render.BlockRenderHandler; +import goodgenerator.crossmod.ic2.CropsLoader; +import goodgenerator.crossmod.nei.NEI_Config; +import goodgenerator.crossmod.thaumcraft.LargeEssentiaEnergyData; +import goodgenerator.items.MyItemBlocks; +import goodgenerator.items.MyItems; +import goodgenerator.items.MyMaterial; +import goodgenerator.items.RadioactiveItem; +import goodgenerator.main.GoodGenerator; +import goodgenerator.util.CrackRecipeAdder; +import goodgenerator.util.MaterialFix; +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.render.TextureFactory; + +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", + GoodGenerator.MOD_ID + ":fluidCore/7", GoodGenerator.MOD_ID + ":fluidCore/8", + GoodGenerator.MOD_ID + ":fluidCore/9", GoodGenerator.MOD_ID + ":fluidCore/10" }); + 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 Item highEnergyMixture = new MyItems( + "highEnergyMixture", + GoodGenerator.GG, + new String[] { GoodGenerator.MOD_ID + ":highEnergyMixture" }); + public static final Item saltyRoot = new MyItems( + "saltyRoot", + GoodGenerator.GG, + new String[] { GoodGenerator.MOD_ID + ":saltyRoot" }); + public static final Item huiCircuit = new MyItems( + "huiCircuit", + addText("huiCircuit.tooltip", 5), + GoodGenerator.GG, + new String[] { GoodGenerator.MOD_ID + ":ciruits/1", GoodGenerator.MOD_ID + ":ciruits/2", + GoodGenerator.MOD_ID + ":ciruits/3", GoodGenerator.MOD_ID + ":ciruits/4", + GoodGenerator.MOD_ID + ":ciruits/5", }); + + public static final Item circuitWrap = new MyItems( + "circuitWrap", + GoodGenerator.GG, + new String[] { GoodGenerator.MOD_ID + ":wraps/0", GoodGenerator.MOD_ID + ":wraps/1", + GoodGenerator.MOD_ID + ":wraps/2", GoodGenerator.MOD_ID + ":wraps/3", GoodGenerator.MOD_ID + ":wraps/4", + GoodGenerator.MOD_ID + ":wraps/5", GoodGenerator.MOD_ID + ":wraps/6", GoodGenerator.MOD_ID + ":wraps/7", + GoodGenerator.MOD_ID + ":wraps/8", GoodGenerator.MOD_ID + ":wraps/9", GoodGenerator.MOD_ID + ":wraps/10", + GoodGenerator.MOD_ID + ":wraps/11", GoodGenerator.MOD_ID + ":wraps/12", GoodGenerator.MOD_ID + ":wraps/13", + GoodGenerator.MOD_ID + ":wraps/14" }); + + 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 FRF_Coil_4 = new Casing( + "FRF_Coil_4", + new String[] { GoodGenerator.MOD_ID + ":FRF_Coils/4" }); + 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 final Block supercriticalFluidTurbineCasing = new TurbineCasing( + "supercriticalFluidTurbineCasing", + "supercriticalFluidTurbineCasing"); + public static final Block pressureResistantWalls = new Casing( + "pressureResistantWalls", + new String[] { GoodGenerator.MOD_ID + ":pressureResistantWalls" }); + public static final Block preciseUnitCasing = new Casing( + "preciseUnitCasing", + new String[] { GoodGenerator.MOD_ID + ":preciseUnitCasing/1", GoodGenerator.MOD_ID + ":preciseUnitCasing/2", + GoodGenerator.MOD_ID + ":preciseUnitCasing/3" }); + public static final Block compactFusionCoil = new Casing( + "compactFusionCoil", + new String[] { GoodGenerator.MOD_ID + ":fuison/1", GoodGenerator.MOD_ID + ":fuison/2", + GoodGenerator.MOD_ID + ":fuison/3", GoodGenerator.MOD_ID + ":fuison/4", + GoodGenerator.MOD_ID + ":fuison/5" }); + public static final Block essentiaFilterCasing = new Casing( + "essentiaFilterCasing", + new String[] { GoodGenerator.MOD_ID + ":essentiaFilterCasing" }); + public static Block essentiaHatch; + public static Block essentiaOutputHatch; + public static Block essentiaOutputHatch_ME; + public static final Block componentAssemblylineCasing = new Casing( + "componentAssemblyLineCasing", + new String[] { GoodGenerator.MOD_ID + ":compAsslineCasing/0", // LV + GoodGenerator.MOD_ID + ":compAsslineCasing/1", // MV + GoodGenerator.MOD_ID + ":compAsslineCasing/2", // HV + GoodGenerator.MOD_ID + ":compAsslineCasing/3", // EV + GoodGenerator.MOD_ID + ":compAsslineCasing/4", // IV + GoodGenerator.MOD_ID + ":compAsslineCasing/5", // LuV + GoodGenerator.MOD_ID + ":compAsslineCasing/6", // ZPM + GoodGenerator.MOD_ID + ":compAsslineCasing/7", // UV + GoodGenerator.MOD_ID + ":compAsslineCasing/8", // UHV + GoodGenerator.MOD_ID + ":compAsslineCasing/9", // UEV + GoodGenerator.MOD_ID + ":compAsslineCasing/10", // UIV + GoodGenerator.MOD_ID + ":compAsslineCasing/11", // UMV + GoodGenerator.MOD_ID + ":compAsslineCasing/12", // UXV + GoodGenerator.MOD_ID + ":compAsslineCasing/13" // MAX + }); + 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 YFH; + public static ItemStack SCTurbine; + public static ItemStack XHE; + public static ItemStack PA; + public static ItemStack LES; + public static ItemStack CT; + public static ItemStack[] LFC = new ItemStack[5]; + + public static ItemStack[] NeutronAccelerators = new ItemStack[9]; + public static ItemStack[] Generator_Diesel = new ItemStack[2]; + + public static ItemStack CompAssline; + // 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); + Loaders.YFH = new YOTTAHatch(IDOffset + 14, "YottaFluidTankHatch", "YOTHatch", 5).getStackForm(1L); + Loaders.SCTurbine = new SupercriticalFluidTurbine( + IDOffset + 15, + "SupercriticalSteamTurbine", + "SC Steam Turbine").getStackForm(1L); + Loaders.XHE = new ExtremeHeatExchanger(IDOffset + 16, "ExtremeHeatExchanger", "Extreme Heat Exchanger") + .getStackForm(1L); + Loaders.PA = new PreciseAssembler(IDOffset + 17, "PreciseAssembler", "Precise Auto-Assembler MT-3662") + .getStackForm(1L); + Loaders.LFC[0] = new LargeFusionComputer1( + IDOffset + 18, + "LargeFusionComputer1", + "Compact Fusion Computer MK-I Prototype").getStackForm(1); + Loaders.LFC[1] = new LargeFusionComputer2( + IDOffset + 19, + "LargeFusionComputer2", + "Compact Fusion Computer MK-II").getStackForm(1L); + Loaders.LFC[2] = new LargeFusionComputer3( + IDOffset + 20, + "LargeFusionComputer3", + "Compact Fusion Computer MK-III").getStackForm(1L); + if (GTPlusPlus.isModLoaded()) { + Loaders.LFC[3] = new LargeFusionComputer4( + IDOffset + 21, + "LargeFusionComputer4", + "Compact Fusion Computer MK-IV Prototype").getStackForm(1L); + Loaders.LFC[4] = new LargeFusionComputer5( + IDOffset + 22, + "LargeFusionComputer5", + "Compact Fusion Computer MK-V").getStackForm(1L); + } + Loaders.Generator_Diesel[0] = new DieselGenerator( + 1113, + "basicgenerator.diesel.tier.04", + "Turbo Supercharging Combustion Generator", + 4).getStackForm(1L); + Loaders.Generator_Diesel[1] = new DieselGenerator( + 1114, + "basicgenerator.diesel.tier.05", + "Ultimate Chemical Energy Releaser", + 5).getStackForm(1L); + Loaders.CT = new CoolantTower(IDOffset + 24, "CoolantTower", "Coolant Tower").getStackForm(1L); + Loaders.CompAssline = new ComponentAssemblyLine( + IDOffset + 25, + "ComponentAssemblyLine", + "Component Assembly Line").getStackForm(1L); + CrackRecipeAdder.registerPipe(30995, MyMaterial.incoloy903, 15000, 8000, true); + CrackRecipeAdder.registerWire(32749, MyMaterial.signalium, 12, 131072, 16, true); + CrackRecipeAdder.registerWire(32737, MyMaterial.lumiium, 8, 524288, 64, true); + } + + 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(FRF_Coil_4, MyItemBlocks.class, "FRF_Coil_4"); + 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 + .registerBlock(supercriticalFluidTurbineCasing, MyItemBlocks.class, "supercriticalFluidTurbineCasing"); + GameRegistry.registerBlock(componentAssemblylineCasing, MyItemBlocks.class, "componentAssemblylineCasing"); + GameRegistry.registerBlock(pressureResistantWalls, MyItemBlocks.class, "pressureResistantWalls"); + GameRegistry.registerBlock(preciseUnitCasing, MyItemBlocks.class, "preciseUnitCasing"); + GameRegistry.registerBlock(compactFusionCoil, MyItemBlocks.class, "compactFusionCoil"); + 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); + GameRegistry.registerItem(highEnergyMixture, "highEnergyMixture", GoodGenerator.MOD_ID); + GameRegistry.registerItem(saltyRoot, "saltyRoot", GoodGenerator.MOD_ID); + GameRegistry.registerItem(huiCircuit, "huiCircuit", GoodGenerator.MOD_ID); + GameRegistry.registerItem(circuitWrap, "circuitWrap", 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"); + GameRegistry.registerTileEntity(EssentiaOutputHatch.class, "EssentiaOutputHatch"); + GameRegistry.registerTileEntity(EssentiaOutputHatch_ME.class, "EssentiaOutputHatch_ME"); + Loaders.LEG = new LargeEssentiaGenerator(IDOffset + 1, "LargeEssentiaGenerator", "Large Essentia Generator") + .getStackForm(1L); + Loaders.LES = new LargeEssentiaSmeltery(IDOffset + 23, "LargeEssentiaSmeltery", "Large Essentia Smeltery") + .getStackForm(1L); + essentiaHatch = new TEBlock("essentiaHatch", new String[] { GoodGenerator.MOD_ID + ":essentiaHatch" }, 1); + essentiaOutputHatch = new TEBlock( + "essentiaOutputHatch", + new String[] { GoodGenerator.MOD_ID + ":essentiaOutputHatch" }, + 2); + essentiaOutputHatch_ME = new TEBlock( + "essentiaOutputHatch_ME", + new String[] { GoodGenerator.MOD_ID + ":essentiaOutputHatch_ME" }, + 3); + GameRegistry.registerBlock(magicCasing, MyItemBlocks.class, "magicCasing"); + GameRegistry.registerBlock(essentiaCell, MyItemBlocks.class, "essentiaCell"); + GameRegistry.registerBlock(essentiaHatch, MyItemBlocks.class, "essentiaHatch"); + GameRegistry.registerBlock(essentiaOutputHatch, MyItemBlocks.class, "essentiaOutputHatch"); + GameRegistry.registerBlock(essentiaFilterCasing, MyItemBlocks.class, "essentiaFilterCasing"); + GameRegistry.registerBlock(essentiaOutputHatch_ME, MyItemBlocks.class, "essentiaOutputHatch_ME"); + + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][0] = TextureFactory.of(magicCasing); + } + } + + public static void addOreDic() { + 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][1] = TextureFactory + .of(yottaFluidTankCasing); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][2] = TextureFactory + .of(supercriticalFluidTurbineCasing); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][3] = TextureFactory + .of(preciseUnitCasing, 0); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][4] = TextureFactory + .of(preciseUnitCasing, 1); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][5] = TextureFactory + .of(preciseUnitCasing, 2); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][6] = TextureFactory + .of(GregTech_API.sBlockConcretes, 8); + } + } + + public static void preInitLoad() { + Register(); + addOreDic(); + addTexturePage(); + compactMod(); + FluidsBuilder.Register(); + FuelRodLoader.RegisterRod(); + } + + public static void initLoad() { + if (FMLCommonHandler.instance() + .getSide() + .isClient()) { + new BlockRenderHandler(); + } + GTMetaTileRegister(); + initLoadRecipes(); + CropsLoader.registerCrops(); + } + + public static void postInitLoad() { + postInitLoadRecipes(); + } + + public static void completeLoad() { + RecipeLoader_02.FinishLoadRecipe(); + MaterialFix.addRecipeForMultiItems(); + ComponentAssemblyLineRecipeLoader.run(); + } + + 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/goodgen/src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java b/goodgen/src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java new file mode 100644 index 0000000000..ad51d7a99d --- /dev/null +++ b/goodgen/src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java @@ -0,0 +1,1376 @@ +package goodgenerator.loader; + +import static goodgenerator.items.MyMaterial.P507; +import static goodgenerator.items.MyMaterial.adamantine; +import static goodgenerator.items.MyMaterial.concentratedEnrichedNaquadahSludge; +import static goodgenerator.items.MyMaterial.enrichedNaquadahEarth; +import static goodgenerator.items.MyMaterial.enrichedNaquadahGoo; +import static goodgenerator.items.MyMaterial.enrichedNaquadahRichSolution; +import static goodgenerator.items.MyMaterial.enrichedNaquadahSulphate; +import static goodgenerator.items.MyMaterial.fluorineRichWasteLiquid; +import static goodgenerator.items.MyMaterial.fluoroantimonicAcid; +import static goodgenerator.items.MyMaterial.galliumHydroxide; +import static goodgenerator.items.MyMaterial.indiumPhosphate; +import static goodgenerator.items.MyMaterial.inertEnrichedNaquadah; +import static goodgenerator.items.MyMaterial.inertNaquadah; +import static goodgenerator.items.MyMaterial.inertNaquadria; +import static goodgenerator.items.MyMaterial.lowQualityNaquadahEmulsion; +import static goodgenerator.items.MyMaterial.lowQualityNaquadahSolution; +import static goodgenerator.items.MyMaterial.lowQualityNaquadriaPhosphate; +import static goodgenerator.items.MyMaterial.lowQualityNaquadriaSolution; +import static goodgenerator.items.MyMaterial.lowQualityNaquadriaSulphate; +import static goodgenerator.items.MyMaterial.magnesiumSulphate; +import static goodgenerator.items.MyMaterial.naquadahAdamantiumSolution; +import static goodgenerator.items.MyMaterial.naquadahEarth; +import static goodgenerator.items.MyMaterial.naquadahGoo; +import static goodgenerator.items.MyMaterial.naquadahRichSolution; +import static goodgenerator.items.MyMaterial.naquadahine; +import static goodgenerator.items.MyMaterial.naquadriaEarth; +import static goodgenerator.items.MyMaterial.naquadriaGoo; +import static goodgenerator.items.MyMaterial.naquadriaRichSolution; +import static goodgenerator.items.MyMaterial.naquadriaSulphate; +import static goodgenerator.items.MyMaterial.titaniumTrifluoride; +import static goodgenerator.items.MyMaterial.towEthyl1Hexanol; +import static goodgenerator.items.MyMaterial.triniumSulphate; +import static goodgenerator.items.MyMaterial.wasteLiquid; +import static goodgenerator.main.GG_Config_Loader.EnableNaquadahRework; +import static gregtech.api.enums.Mods.GTPlusPlus; +import static gregtech.api.recipe.RecipeMaps.autoclaveRecipes; +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.chemicalReactorRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; +import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes; +import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; +import static gregtech.common.items.GT_MetaGenerated_Item_01.registerCauldronCleaningFor; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.HashSet; + +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 com.github.bartimaeusnek.bartworks.system.material.GT_Enhancement.PlatinumSludgeOverHaul; +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; + +import goodgenerator.main.GoodGenerator; +import goodgenerator.util.CrackRecipeAdder; +import goodgenerator.util.ItemRefer; +import goodgenerator.util.MyRecipeAdder; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gregtech.common.items.CombType; +import gregtech.loaders.misc.GT_Bees; +import gtPlusPlus.api.recipe.GTPPRecipeMaps; +import gtPlusPlus.core.item.chemistry.GenericChem; +import gtPlusPlus.core.lib.CORE; + +public class NaquadahReworkRecipeLoader { + + public static void RecipeLoad() { + + if (!EnableNaquadahRework) return; + + if (GTPlusPlus.isModLoaded()) { + try { + // Naquadah (UEV) + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { naquadahEarth.get(OrePrefixes.dust, 32), Materials.Sodium.getDust(64), + Materials.Carbon.getDust(1), GT_Utility.copyAmount(0, GenericChem.mSimpleNaquadahCatalyst) }, + new FluidStack[] { Materials.Hydrogen.getGas(64000L), Materials.Fluorine.getGas(64000L), + Materials.Oxygen.getGas(100L) }, + new FluidStack[] {}, + new ItemStack[] { inertNaquadah.get(OrePrefixes.dust, 1), Materials.Titanium.getDust(64), + Materials.Adamantium.getDust(64), Materials.Gallium.getDust(64) }, + new int[] { 2500, 2500, 2500, 2500 }, + 10 * 20, + (int) GT_Values.VP[10], + 2); + // Enriched Naquadah (UIV) + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { enrichedNaquadahEarth.get(OrePrefixes.dust, 32), Materials.Zinc.getDust(64), + Materials.Carbon.getDust(1), GT_Utility.copyAmount(0, GenericChem.mSimpleNaquadahCatalyst) }, + new FluidStack[] { Materials.SulfuricAcid.getFluid(16000), Materials.Oxygen.getGas(100L) }, + new FluidStack[] { wasteLiquid.getFluidOrGas(32000) }, + new ItemStack[] { inertEnrichedNaquadah.get(OrePrefixes.dust, 1), Materials.Trinium.getDust(64), }, + new int[] { 3300, 3300, 3300 }, + 10 * 20, + (int) GT_Values.VP[11], + 2); + // Naquadria (UMV) + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { naquadriaEarth.get(OrePrefixes.dust, 32), Materials.Magnesium.getDust(64), + GT_Utility.copyAmount(0, GenericChem.mAdvancedNaquadahCatalyst) }, + new FluidStack[] { Materials.PhosphoricAcid.getFluid(16000), Materials.SulfuricAcid.getFluid(16000), + Materials.Oxygen.getGas(100L) }, + new FluidStack[] {}, + new ItemStack[] { inertNaquadria.get(OrePrefixes.dust, 1), Materials.Barium.getDust(64), + Materials.Indium.getDust(64), ItemList.NaquadriaSupersolid.get(1) }, + new int[] { 2500, 2500, 2500, 2500 }, + 5 * 20, + (int) GT_Values.VP[12], + 3); + // Activate Them + MyRecipeAdder.instance.addNeutronActivatorRecipe( + new FluidStack[] { Materials.Nickel.getPlasma(144 * 16) }, + new ItemStack[] { inertNaquadah.get(OrePrefixes.dust, 64), + inertNaquadah.get(OrePrefixes.dust, 32) }, + new FluidStack[] { Materials.Naquadah.getMolten(144 * 9216) }, + new ItemStack[] { Materials.Nickel.getDust(16) }, + 2000, + 600, + 500); + MyRecipeAdder.instance.addNeutronActivatorRecipe( + new FluidStack[] { Materials.Titanium.getPlasma(16 * 144) }, + new ItemStack[] { inertEnrichedNaquadah.get(OrePrefixes.dust, 64), + inertEnrichedNaquadah.get(OrePrefixes.dust, 32) }, + new FluidStack[] { Materials.NaquadahEnriched.getMolten(144 * 9216) }, + new ItemStack[] { Materials.Titanium.getDust(16) }, + 2000, + 900, + 850); + MyRecipeAdder.instance.addNeutronActivatorRecipe( + new FluidStack[] { Materials.Americium.getPlasma(144 * 16) }, + new ItemStack[] { inertNaquadria.get(OrePrefixes.dust, 64), + inertNaquadria.get(OrePrefixes.dust, 32) }, + new FluidStack[] { Materials.Naquadria.getMolten(144 * 9216) }, + new ItemStack[] { Materials.Americium.getDust(16) }, + 2000, + 1100, + 1080); + } catch (Throwable t) { + // Cry about it + } + } + + // Fix shit + GT_Values.RA.stdBuilder() + .itemInputs(lowQualityNaquadriaSolution.get(OrePrefixes.cell, 1)) + .itemOutputs(Materials.Tin.getDust(2)) + .duration(16 * SECONDS + 14 * TICKS) + .eut(4) + .addTo(maceratorRecipes); + + // Naquadah Rework Line + GT_Values.RA.stdBuilder() + .itemInputs(naquadahEarth.get(OrePrefixes.dust, 2), GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(fluoroantimonicAcid.getFluidOrGas(3000)) + .fluidOutputs(lowQualityNaquadahEmulsion.getFluidOrGas(2000)) + .itemOutputs(titaniumTrifluoride.get(OrePrefixes.dust, 4)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .metadata(COIL_HEAT, 3000) + .addTo(blastFurnaceRecipes); + + // TiF3 + 3H = Ti + 3HF + GT_Values.RA.stdBuilder() + .itemInputs(titaniumTrifluoride.get(OrePrefixes.dust, 4), GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Hydrogen.getGas(3000)) + .fluidOutputs(Materials.HydrofluoricAcid.getFluid(3000)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Titanium, 1)) + .duration(6 * SECONDS) + .eut(TierEU.RECIPE_EV) + .metadata(COIL_HEAT, 2000) + .addTo(blastFurnaceRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(0, GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Copper, 1)), + Materials.Hydrogen.getCells(8)) + .fluidInputs(FluidRegistry.getFluidStack("seedoil", 3000)) + .itemOutputs(ItemList.Cell_Empty.get(8)) + .fluidOutputs(towEthyl1Hexanol.getFluidOrGas(1000)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(UniversalChemical); + + // 2C8H18O + H3PO4 =Na,C2H6O= C16H35O3P + 2H2O + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 2)) + .fluidInputs( + towEthyl1Hexanol.getFluidOrGas(2000), + Materials.PhosphoricAcid.getFluid(1000), + Materials.Ethanol.getFluid(2000)) + .fluidOutputs(P507.getFluidOrGas(1000)) + .duration(1 * MINUTES) + .eut(TierEU.RECIPE_EV) + .addTo(multiblockChemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(lowQualityNaquadahSolution.get(OrePrefixes.cell, 36), P507.get(OrePrefixes.cell, 4)) + .itemOutputs(naquadahAdamantiumSolution.get(OrePrefixes.cell, 30), ItemList.Cell_Empty.get(10)) + .fluidOutputs(fluorineRichWasteLiquid.getFluidOrGas(10000)) + .duration(3 * MINUTES + 20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(chemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs(P507.getFluidOrGas(4000), lowQualityNaquadahSolution.getFluidOrGas(36000)) + .fluidOutputs(fluorineRichWasteLiquid.getFluidOrGas(10000), naquadahAdamantiumSolution.getFluidOrGas(30000)) + .duration(3 * MINUTES + 20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(multiblockChemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, 40)) + .fluidInputs(fluorineRichWasteLiquid.getFluidOrGas(1500)) + .fluidOutputs(wasteLiquid.getFluidOrGas(1000)) + .itemOutputs(WerkstoffLoader.Fluorspar.get(OrePrefixes.dust, 60)) + .duration(50 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(UniversalChemical); + + CrackRecipeAdder.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), + 15 * SECONDS, + TierEU.RECIPE_HV); + + 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.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 27)) + .fluidInputs(naquadahRichSolution.getFluidOrGas(5000)) + .itemOutputs(naquadahine.get(OrePrefixes.dust, 30)) + .fluidOutputs(P507.getFluidOrGas(1000)) + .duration(50 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(autoclaveRecipes); + + // NqO2 + C = CO2 + Nq + GT_Values.RA.stdBuilder() + .itemInputs( + naquadahine.get(OrePrefixes.dust, 3), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Carbon, 1)) + .fluidOutputs(Materials.CarbonDioxide.getGas(1000)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Naquadah, 1)) + .duration(2 * SECONDS) + .eut(TierEU.RECIPE_IV) + .metadata(COIL_HEAT, 5000) + .addTo(blastFurnaceRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 27), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(lowQualityNaquadahEmulsion.getFluidOrGas(10000)) + .itemOutputs( + galliumHydroxide.get(OrePrefixes.dust, 64), + galliumHydroxide.get(OrePrefixes.dust, 48), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Antimony, 15)) + .outputChances(6250, 6250, 10000) + .fluidOutputs(lowQualityNaquadahSolution.getFluidOrGas(9000)) + .duration(50 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(enrichedNaquadahEarth.get(OrePrefixes.dust, 4)) + .fluidInputs(P507.getFluidOrGas(1000), Materials.SulfuricAcid.getFluid(18000)) + .fluidOutputs(enrichedNaquadahRichSolution.getFluidOrGas(4000), wasteLiquid.getFluidOrGas(1000)) + .itemOutputs(naquadahEarth.get(OrePrefixes.dust, 1), triniumSulphate.get(OrePrefixes.dust, 1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(multiblockChemicalReactorRecipes); + + // ZnSO4 + 2H = H2SO4 + Zn + GT_Values.RA.stdBuilder() + .itemInputs(WerkstoffLoader.ZincSulfate.get(OrePrefixes.dust, 6)) + .fluidInputs(Materials.Hydrogen.getGas(2000)) + .fluidOutputs(Materials.SulfuricAcid.getFluid(1000)) + .itemOutputs(Materials.Zinc.getDust(1)) + .duration(1 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_ULV) + .addTo(UniversalChemical); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 60)) + .fluidInputs(enrichedNaquadahRichSolution.getFluidOrGas(10000)) + .itemOutputs(concentratedEnrichedNaquadahSludge.get(OrePrefixes.dust, 8)) + .fluidOutputs(P507.getFluidOrGas(2500)) + .duration(50 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(autoclaveRecipes); + + MyRecipeAdder.instance.addNeutronActivatorRecipe( + null, + new ItemStack[] { concentratedEnrichedNaquadahSludge.get(OrePrefixes.dust, 16), }, + null, + new ItemStack[] { enrichedNaquadahSulphate.get(OrePrefixes.dust, 64), + enrichedNaquadahSulphate.get(OrePrefixes.dust, 64), enrichedNaquadahSulphate.get(OrePrefixes.dust, 37), + WerkstoffLoader.Sodiumsulfate.get(OrePrefixes.dust, 64), + WerkstoffLoader.Sodiumsulfate.get(OrePrefixes.dust, 64), + WerkstoffLoader.Sodiumsulfate.get(OrePrefixes.dust, 12), + lowQualityNaquadriaSulphate.get(OrePrefixes.dust, 2), }, + 120, + 480, + 460); + + // Nq+(SO4)2 + 2Zn = Nq+ + 2ZnSO4 + GT_Values.RA.stdBuilder() + .itemInputs( + enrichedNaquadahSulphate.get(OrePrefixes.dust, 11), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Zinc, 2)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.NaquadahEnriched, 1), + WerkstoffLoader.ZincSulfate.get(OrePrefixes.dust, 12)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_IV) + .metadata(COIL_HEAT, 7500) + .addTo(blastFurnaceRecipes); + + // KeSO4 + 2H = Ke + H2SO4 + GT_Values.RA.stdBuilder() + .itemInputs(triniumSulphate.get(OrePrefixes.dust, 6)) + .fluidInputs(Materials.Hydrogen.getGas(2000)) + .fluidOutputs(Materials.SulfuricAcid.getFluid(1000)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Trinium, 1)) + .duration(6 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(multiblockChemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(naquadriaEarth.get(OrePrefixes.dust, 4)) + .fluidInputs(Materials.PhosphoricAcid.getFluid(4000)) + .itemOutputs( + indiumPhosphate.get(OrePrefixes.dust, 6), + lowQualityNaquadriaPhosphate.get(OrePrefixes.dust, 4)) + .outputChances(2000, 10000) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(centrifugeRecipes); + + // Ga(OH)3 + 3Na = Ga + 3NaOH + GT_Values.RA.stdBuilder() + .itemInputs( + galliumHydroxide.get(OrePrefixes.dust, 7), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 3)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Gallium, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SodiumHydroxide, 9)) + .duration(2 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + // 2InPO4 + 3Ca = 2In + Ca3(PO4)2 + GT_Values.RA.stdBuilder() + .itemInputs( + indiumPhosphate.get(OrePrefixes.dust, 12), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcium, 3)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Indium, 2), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.TricalciumPhosphate, 5)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + GT_Values.RA.stdBuilder() + .itemInputs(lowQualityNaquadriaPhosphate.get(OrePrefixes.dust, 10), Materials.SulfuricAcid.getCells(30)) + .fluidOutputs(naquadriaRichSolution.getFluidOrGas(9000)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Barite, 1), ItemList.Cell_Empty.get(30)) + .duration(50 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(UniversalChemical); + + MyRecipeAdder.instance.addNeutronActivatorRecipe( + new FluidStack[] { naquadriaRichSolution.getFluidOrGas(9000) }, + null, + null, + new ItemStack[] { naquadriaSulphate.get(OrePrefixes.dust, 44), + lowQualityNaquadriaSulphate.get(OrePrefixes.dust, 6) }, + 100, + 1100, + 1050); + + GT_Values.RA.stdBuilder() + .itemInputs(lowQualityNaquadriaSulphate.get(OrePrefixes.dust, 3), Materials.Water.getCells(3)) + .fluidInputs(P507.getFluidOrGas(500)) + .fluidOutputs(lowQualityNaquadriaSolution.getFluidOrGas(3500)) + .itemOutputs(ItemList.Cell_Empty.get(3)) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(UniversalChemical); + + CrackRecipeAdder.addUniversalDistillationRecipe( + lowQualityNaquadriaSolution.getFluidOrGas(7000), + new FluidStack[] { P507.getFluidOrGas(1000), naquadriaRichSolution.getFluidOrGas(5400), + Materials.DilutedSulfuricAcid.getFluid(12000) }, + enrichedNaquadahEarth.get(OrePrefixes.dust, 2), + 25 * SECONDS, + TierEU.RECIPE_IV); + + // Nq*(SO4)2 + 2Mg = Nq* + 2MgSO4 + GT_Values.RA.stdBuilder() + .itemInputs( + naquadriaSulphate.get(OrePrefixes.dust, 11), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesium, 2)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Naquadria, 1), + magnesiumSulphate.get(OrePrefixes.dust, 12)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .metadata(COIL_HEAT, 9100) + .addTo(blastFurnaceRecipes); + + // InPO4 + Ga(OH)3 = InGaP + GT_Values.RA.stdBuilder() + .itemInputs( + indiumPhosphate.get(OrePrefixes.dust, 6), + galliumHydroxide.get(OrePrefixes.dust, 7), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.IndiumGalliumPhosphide, 3)) + .duration(15 * TICKS) + .eut(TierEU.RECIPE_ULV) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Ball.get(0)) + .fluidInputs(naquadahGoo.getFluidOrGas(72)) + .itemOutputs(ItemRefer.Naquadah_Mass.get(1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidSolidifierRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Ball.get(0)) + .fluidInputs(enrichedNaquadahGoo.getFluidOrGas(72)) + .itemOutputs(ItemRefer.Enriched_Naquadah_Mass.get(1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidSolidifierRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Ball.get(0)) + .fluidInputs(naquadriaGoo.getFluidOrGas(72)) + .itemOutputs(ItemRefer.Naquadria_Mass.get(1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidSolidifierRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Naquadah_Mass.get(1)) + .itemOutputs(naquadahEarth.get(OrePrefixes.dust, 1), enrichedNaquadahEarth.get(OrePrefixes.dust, 1)) + .outputChances(10000, 100) + .duration(5 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Enriched_Naquadah_Mass.get(1)) + .itemOutputs(enrichedNaquadahEarth.get(OrePrefixes.dust, 1), naquadriaEarth.get(OrePrefixes.dust, 1)) + .outputChances(10000, 100) + .duration(5 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Naquadria_Mass.get(1)) + .itemOutputs(naquadriaEarth.get(OrePrefixes.dust, 1), naquadriaEarth.get(OrePrefixes.dust, 1)) + .outputChances(10000, 100) + .duration(5 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.block, Materials.SiliconSG, 16), + naquadahine.get(OrePrefixes.dust, 3), + ItemList.GalliumArsenideCrystal.get(1L)) + .fluidInputs(Materials.Argon.getGas(8000)) + .itemOutputs(ItemList.Circuit_Silicon_Ingot3.get(1)) + .duration(50 * SECONDS) + .eut(TierEU.RECIPE_IV) + .metadata(COIL_HEAT, 4484) + .addTo(blastFurnaceRecipes); + + // NqO2 + 4Na = 2Na2O + Nq + GT_Values.RA.stdBuilder() + .itemInputs(naquadahine.get(OrePrefixes.dust, 3), Materials.Sodium.getDust(4)) + .itemOutputs(Materials.Naquadah.getDust(1), Materials.SodiumOxide.getDust(6)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(UniversalChemical); + + GT_Values.RA.stdBuilder() + .itemInputs(naquadahEarth.get(OrePrefixes.dust, 2), GT_Utility.getIntegratedCircuit(2)) + .fluidInputs(Materials.Nitrogen.getGas(1000)) + .itemOutputs(Materials.Naquadah.getNuggets(1)) + .duration(2 * MINUTES) + .eut(TierEU.RECIPE_IV) + .metadata(COIL_HEAT, 5000) + .addTo(blastFurnaceRecipes); + + // C2H4 + H2O(g) = C2H6O + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(24)) + .fluidInputs(Materials.Ethylene.getGas(1000), FluidRegistry.getFluidStack("steam", 2000)) + .fluidOutputs(Materials.Ethanol.getFluid(1000)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(multiblockChemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Ethylene.getCells(1), GT_Utility.getIntegratedCircuit(24)) + .fluidInputs(FluidRegistry.getFluidStack("steam", 2000)) + .itemOutputs(Materials.Ethanol.getCells(1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(chemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.ingotHot, Materials.Naquadah, 1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Naquadah, 1)) + .duration(16 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(vacuumFreezerRecipes); + } + + public static void SmallRecipeChange() { + + GT_Recipe tRecipe; + + tRecipe = RecipeMaps.chemicalReactorRecipes.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) { + RecipeMaps.chemicalReactorRecipes.getBackend() + .removeRecipe(tRecipe); + GT_Recipe tRecipe2 = tRecipe.copy(); + tRecipe2.mInputs = new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Naquadah, 8), + ItemList.Empty_Board_Elite.get(2) }; + RecipeMaps.chemicalReactorRecipes.add(tRecipe2); + RecipeMaps.chemicalReactorRecipes.getBackend() + .reInit(); + } + + tRecipe = RecipeMaps.multiblockChemicalReactorRecipes.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) { + RecipeMaps.multiblockChemicalReactorRecipes.getBackend() + .removeRecipe(tRecipe); + GT_Recipe tRecipe2 = tRecipe.copy(); + tRecipe2.mInputs = new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Naquadah, 8), + ItemList.Empty_Board_Elite.get(2) }; + RecipeMaps.multiblockChemicalReactorRecipes.add(tRecipe2); + RecipeMaps.multiblockChemicalReactorRecipes.getBackend() + .reInit(); + } + + tRecipe = RecipeMaps.assemblerRecipes.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) { + RecipeMaps.assemblerRecipes.getBackend() + .removeRecipe(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) }; + RecipeMaps.assemblerRecipes.add(tRecipe2); + RecipeMaps.assemblerRecipes.getBackend() + .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<GT_Recipe> remove = new HashSet<>(5000); + HashSet<GT_Recipe> reAdd = new HashSet<>(5000); + + // For Crusher + for (GT_Recipe recipe : RecipeMaps.maceratorRecipes.getAllRecipes()) { + 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("rawOre") + || OreDictionary.getOreName(oreDictID) + .startsWith("crushed")) + && OreDictionary.getOreName(oreDictID) + .contains("Naq")) { + GT_Recipe tRecipe = recipe.copy(); + boolean modified = false; + 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + RecipeMaps.maceratorRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(RecipeMaps.maceratorRecipes::add); + RecipeMaps.maceratorRecipes.getBackend() + .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 : RecipeMaps.oreWasherRecipes.getAllRecipes()) { + 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(); + boolean modified = false; + 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + RecipeMaps.oreWasherRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(RecipeMaps.oreWasherRecipes::add); + RecipeMaps.oreWasherRecipes.getBackend() + .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 : RecipeMaps.thermalCentrifugeRecipes.getAllRecipes()) { + 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(); + boolean modified = false; + 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + RecipeMaps.thermalCentrifugeRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(RecipeMaps.thermalCentrifugeRecipes::add); + RecipeMaps.thermalCentrifugeRecipes.getBackend() + .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 : RecipeMaps.centrifugeRecipes.getAllRecipes()) { + 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(); + boolean modified = false; + 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 * 2L, + naquadahEarth.get(OrePrefixes.dustTiny, 1)); + modified = true; + } + } + if (modified) { + 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(); + boolean modified = false; + 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + RecipeMaps.centrifugeRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(RecipeMaps.centrifugeRecipes::add); + RecipeMaps.centrifugeRecipes.getBackend() + .reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Centrifuge done!\n"); + + // For Centrifuge (PA) + for (GT_Recipe recipe : RecipeMaps.centrifugeNonCellRecipes.getAllRecipes()) { + 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(); + boolean modified = false; + 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 * 2L, + naquadahEarth.get(OrePrefixes.dustTiny, 1)); + modified = true; + } + } + if (modified) { + 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(); + boolean modified = false; + 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + RecipeMaps.centrifugeNonCellRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(RecipeMaps.centrifugeNonCellRecipes::add); + RecipeMaps.centrifugeNonCellRecipes.getBackend() + .reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Centrifuge (PA) done!\n"); + + // For Hammer + for (GT_Recipe recipe : RecipeMaps.hammerRecipes.getAllRecipes()) { + 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(); + boolean modified = false; + 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + RecipeMaps.hammerRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(RecipeMaps.hammerRecipes::add); + RecipeMaps.hammerRecipes.getBackend() + .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 : RecipeMaps.chemicalReactorRecipes.getAllRecipes()) { + 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(); + boolean modified = 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))) { + tRecipe.mFluidOutputs[i] = naquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + modified = true; + } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.NaquadahEnriched.getMolten(1))) { + tRecipe.mFluidOutputs[i] = enrichedNaquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + modified = true; + } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadria.getMolten(1))) { + tRecipe.mFluidOutputs[i] = naquadriaGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + } + RecipeMaps.chemicalReactorRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(RecipeMaps.chemicalReactorRecipes::add); + RecipeMaps.chemicalReactorRecipes.getBackend() + .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 : RecipeMaps.multiblockChemicalReactorRecipes.getAllRecipes()) { + 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(); + boolean modified = 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))) { + tRecipe.mFluidOutputs[i] = naquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + modified = true; + } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.NaquadahEnriched.getMolten(1))) { + tRecipe.mFluidOutputs[i] = enrichedNaquadahGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + modified = true; + } else if (recipe.mFluidOutputs[i].isFluidEqual(Materials.Naquadria.getMolten(1))) { + tRecipe.mFluidOutputs[i] = naquadriaGoo.getFluidOrGas(recipe.mFluidOutputs[i].amount * 2); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + } + RecipeMaps.multiblockChemicalReactorRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(RecipeMaps.multiblockChemicalReactorRecipes::add); + RecipeMaps.multiblockChemicalReactorRecipes.getBackend() + .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 (GTPlusPlus.isModLoaded()) { + // For Gt++ Multi Centrifuge + // Apparently NEI will break down if one modifies the hash list directly. + // GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT.mRecipeList.clear(); + // RecipeGen_MultisUsingFluidInsteadOfCells.generateRecipesNotUsingCells( + // RecipeMaps.centrifugeRecipes, + // GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT); + // GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT.reInit(); + + // For Simple Washer + for (GT_Recipe recipe : GTPPRecipeMaps.simpleWasherRecipes.getAllRecipes()) { + 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") + || OreDictionary.getOreName(oreDictID) + .startsWith("dustPureNaq")) { + GT_Recipe tRecipe = recipe.copy(); + boolean modified = false; + 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GTPPRecipeMaps.simpleWasherRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(GTPPRecipeMaps.simpleWasherRecipes::add); + GTPPRecipeMaps.simpleWasherRecipes.getBackend() + .reInit(); + + GT_Log.out.print(GoodGenerator.MOD_ID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Simple Washer 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 and copy some private methods in Bartworks because his system runs well. + // Bartworks is under MIT License + /* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A + * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR + * IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + 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/goodgen/src/main/java/goodgenerator/loader/NeutronActivatorLoader.java b/goodgen/src/main/java/goodgenerator/loader/NeutronActivatorLoader.java new file mode 100644 index 0000000000..353277dc1f --- /dev/null +++ b/goodgen/src/main/java/goodgenerator/loader/NeutronActivatorLoader.java @@ -0,0 +1,46 @@ +package goodgenerator.loader; + +import static goodgenerator.items.MyMaterial.*; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import goodgenerator.util.MyRecipeAdder; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class NeutronActivatorLoader { + + public static void NARecipeLoad() { + MyRecipeAdder.instance.addNeutronActivatorRecipe( + new FluidStack[] { thoriumBasedLiquidFuelExcited.getFluidOrGas(200) }, + null, + new FluidStack[] { thoriumBasedLiquidFuelDepleted.getFluidOrGas(200) }, + null, + 10000, + 700, + 500); + + MyRecipeAdder.instance.addNeutronActivatorRecipe( + new FluidStack[] { uraniumBasedLiquidFuel.getFluidOrGas(100) }, + new ItemStack[] { + GT_Utility.copyAmount(0, GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Tungsten, 1)) }, + new FluidStack[] { uraniumBasedLiquidFuelExcited.getFluidOrGas(100) }, + null, + 80, + 550, + 450); + + MyRecipeAdder.instance.addNeutronActivatorRecipe( + new FluidStack[] { plutoniumBasedLiquidFuel.getFluidOrGas(100) }, + new ItemStack[] { + GT_Utility.copyAmount(0, GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Tritanium, 1)) }, + new FluidStack[] { plutoniumBasedLiquidFuelExcited.getFluidOrGas(100) }, + null, + 80, + 600, + 500); + } +} diff --git a/goodgen/src/main/java/goodgenerator/loader/RecipeLoader.java b/goodgen/src/main/java/goodgenerator/loader/RecipeLoader.java new file mode 100644 index 0000000000..0c7ae0e60f --- /dev/null +++ b/goodgen/src/main/java/goodgenerator/loader/RecipeLoader.java @@ -0,0 +1,1466 @@ +package goodgenerator.loader; + +import static gregtech.api.enums.Mods.GTPlusPlus; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.autoclaveRecipes; +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.compressorRecipes; +import static gregtech.api.recipe.RecipeMaps.electrolyzerRecipes; +import static gregtech.api.recipe.RecipeMaps.extruderRecipes; +import static gregtech.api.recipe.RecipeMaps.formingPressRecipes; +import static gregtech.api.recipe.RecipeMaps.fusionRecipes; +import static gregtech.api.recipe.RecipeMaps.implosionRecipes; +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; +import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes; +import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.HOURS; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.ADDITIVE_AMOUNT; +import static gregtech.api.util.GT_RecipeConstants.AssemblyLine; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; +import static gregtech.api.util.GT_RecipeConstants.FUEL_TYPE; +import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE; +import static gregtech.api.util.GT_RecipeConstants.FUSION_THRESHOLD; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; +import static gregtech.loaders.postload.GT_MachineRecipeLoader.solderingMats; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; + +import goodgenerator.items.MyMaterial; +import goodgenerator.util.CrackRecipeAdder; +import goodgenerator.util.ItemRefer; +import goodgenerator.util.MaterialFix; +import goodgenerator.util.MyRecipeAdder; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeConstants; +import gregtech.api.util.GT_Utility; + +public class RecipeLoader { + + public static void RecipeLoad() { + + // Radiation Protection Plate + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Iridium, 8L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahAlloy, 8L), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Lead.getMolten(1152)) + .itemOutputs(ItemRefer.Radiation_Protection_Plate.get(1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Lanthanum, 4L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahAlloy, 8L), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Lead.getMolten(1152)) + .itemOutputs(ItemRefer.Radiation_Protection_Plate.get(1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + Fluid solderIndalloy = FluidRegistry.getFluid("molten.indalloy140") != null + ? FluidRegistry.getFluid("molten.indalloy140") + : FluidRegistry.getFluid("molten.solderingalloy"); + + // LNR Controller + GT_Values.RA.stdBuilder() + .metadata( + RESEARCH_ITEM, + ItemList.Generator_Naquadah_Mark_III.get(1) + .copy()) + .metadata(RESEARCH_TIME, 1 * HOURS + 24 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Adamantium, 8), + ItemRefer.Radiation_Protection_Plate.get(16), + ItemList.Field_Generator_ZPM.get(2), + ItemList.Electric_Pump_ZPM.get(8), + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 4 }, + GT_OreDictUnificator.get(OrePrefixes.wireGt08, Materials.SuperconductorLuV, 8), + GT_OreDictUnificator.get(OrePrefixes.pipeHuge, Materials.Naquadah, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahAlloy, 8), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Osmium, 16)) + .fluidInputs( + Materials.Trinium.getMolten(576), + new FluidStack(solderIndalloy, 4608), + Materials.Lubricant.getFluid(8000)) + .itemOutputs(ItemRefer.Large_Naquadah_Reactor.get(1)) + .eut(TierEU.RECIPE_ZPM) + .duration(13 * MINUTES + 30 * SECONDS) + .addTo(AssemblyLine); + + // LNR Casing + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Radiation_Protection_Plate.get(6), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Europium, 1), + ItemList.Field_Generator_MV.get(1), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemRefer.Field_Restriction_Casing.get(1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + // LNR Frame + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.NaquadahAlloy, 8), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.HSSE, 4), + GT_Utility.getIntegratedCircuit(24)) + .itemOutputs(ItemRefer.Radiation_Proof_Steel_Frame_Box.get(1)) + .duration(16 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + // Uranium Liquid Fuel Process Line + GT_Values.RA.stdBuilder() + .itemInputs( + MyMaterial.graphiteUraniumMixture.get(OrePrefixes.dust, 4), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.TungstenCarbide, 2), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemRefer.Wrapped_Uranium_Ingot.get(1)) + .duration(1 * MINUTES + 10 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Wrapped_Uranium_Ingot.get(4)) + .itemOutputs( + ItemRefer.High_Density_Uranium_Nugget.get(1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.TungstenCarbide, 8)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .metadata(ADDITIVE_AMOUNT, 8) + .addTo(implosionRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.High_Density_Uranium_Nugget.get(9)) + .itemOutputs(ItemRefer.High_Density_Uranium.get(1)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.High_Density_Uranium.get(1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Potassium, 8), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quantium, 4), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Radon.getGas(1000L)) + .fluidOutputs(MyMaterial.uraniumBasedLiquidFuel.getFluidOrGas(1000)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LuV / 2) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs(MyMaterial.uraniumBasedLiquidFuel.getFluidOrGas(10), Materials.Hydrogen.getGas(100L)) + .fluidOutputs(MyMaterial.uraniumBasedLiquidFuelExcited.getFluidOrGas(10)) + .duration(2 * SECONDS) + .eut(TierEU.RECIPE_IV) + .metadata(FUSION_THRESHOLD, 200000000) + .addTo(fusionRecipes); + + // Thorium Liquid Process Line + GT_Values.RA.stdBuilder() + .itemInputs( + MyMaterial.uraniumCarbideThoriumMixture.get(OrePrefixes.dust, 64), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.TungstenSteel, 4), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemRefer.Wrapped_Thorium_Ingot.get(1)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Wrapped_Thorium_Ingot.get(1)) + .itemOutputs( + ItemRefer.High_Density_Thorium_Nugget.get(1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.TungstenSteel, 8)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .metadata(ADDITIVE_AMOUNT, 4) + .addTo(implosionRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.High_Density_Thorium_Nugget.get(9)) + .itemOutputs(ItemRefer.High_Density_Thorium.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.High_Density_Thorium.get(1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lithium, 4), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Draconium, 2), + GT_Utility.getIntegratedCircuit(2)) + .fluidInputs(Materials.Mercury.getFluid(1000L)) + .fluidOutputs(MyMaterial.thoriumBasedLiquidFuel.getFluidOrGas(4000)) + .duration(2 * MINUTES + 30 * SECONDS) + .eut(TierEU.RECIPE_HV / 2) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.thoriumBasedLiquidFuel.get(OrePrefixes.cell, 1), GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Helium.getPlasma(250L)) + .itemOutputs(MyMaterial.thoriumBasedLiquidFuelExcited.get(OrePrefixes.cell, 1)) + .duration(6 * SECONDS) + .eut(TierEU.RECIPE_IV / 2) + .addTo(mixerRecipes); + + // Liquid Plutonium Process Line + GT_Values.RA.stdBuilder() + .itemInputs( + MyMaterial.plutoniumOxideUraniumMixture.get(OrePrefixes.dust, 8), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.HSSS, 4), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemRefer.Wrapped_Plutonium_Ingot.get(1)) + .duration(1 * MINUTES + 30 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Wrapped_Plutonium_Ingot.get(2)) + .itemOutputs( + ItemRefer.High_Density_Plutonium_Nugget.get(1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.HSSS, 8)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .metadata(ADDITIVE_AMOUNT, 16) + .addTo(implosionRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.High_Density_Plutonium_Nugget.get(9)) + .itemOutputs(ItemRefer.High_Density_Plutonium.get(1)) + .duration(1 * MINUTES) + .eut(TierEU.RECIPE_MV) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.High_Density_Plutonium.get(1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Neutronium, 8), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Caesium, 16), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 2), + GT_Utility.getIntegratedCircuit(1)) + .fluidOutputs(MyMaterial.plutoniumBasedLiquidFuel.getFluidOrGas(1000)) + .duration(18 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.Lutetium.getMolten(16), MyMaterial.plutoniumBasedLiquidFuel.getFluidOrGas(20)) + .fluidOutputs(MyMaterial.plutoniumBasedLiquidFuelExcited.getFluidOrGas(20)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LuV / 2) + .metadata(FUSION_THRESHOLD, 220000000) + .addTo(fusionRecipes); + + // Th-232 + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sugar, 24), + MyMaterial.vanadiumPentoxide.get(OrePrefixes.dust, 0), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(FluidRegistry.getFluidStack("nitricacid", 6000)) + .fluidOutputs(MyMaterial.oxalate.getFluidOrGas(3000), Materials.NitricOxide.getGas(6000)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(multiblockChemicalReactorRecipes); + + // Th + 2O = ThO2 + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Thorium, 1)) + .fluidInputs(Materials.Oxygen.getGas(2000)) + .itemOutputs(WerkstoffLoader.Thorianit.get(OrePrefixes.dust, 3)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .metadata(COIL_HEAT, 1200) + .addTo(blastFurnaceRecipes); + + // Th + 8HNO3 =HF= Th(NO3)4 + 4NO2 + 4H2O + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Thorium.getDust(1)) + .fluidInputs(Materials.HydrofluoricAcid.getFluid(100), FluidRegistry.getFluidStack("nitricacid", 8000)) + .fluidOutputs(MyMaterial.thoriumNitrate.getFluidOrGas(1000), Materials.NitrogenDioxide.getGas(4000)) + .duration(2 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(multiblockChemicalReactorRecipes); + + // 4NaOH + Th(NO3)4 = Th(OH)4 + 4NaNO3 + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1), Materials.SodiumHydroxide.getDust(12)) + .fluidInputs(MyMaterial.thoriumNitrate.getFluidOrGas(1000)) + .itemOutputs( + MyMaterial.thoriumHydroxide.get(OrePrefixes.dust, 9), + WerkstoffLoader.SodiumNitrate.get(OrePrefixes.dust, 20)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(UniversalChemical); + + // 2 NaNO3 + H2SO4 = Na2SO4 + 2HNO3 + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1), WerkstoffLoader.SodiumNitrate.get(OrePrefixes.dust, 10)) + .fluidInputs(Materials.SulfuricAcid.getFluid(1000)) + .fluidOutputs(Materials.NitricAcid.getFluid(2000)) + .itemOutputs(WerkstoffLoader.Sodiumsulfate.get(OrePrefixes.dust, 7)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(UniversalChemical); + + // Th(OH)4 + 4HF = ThF4 + 4H2O + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.thoriumHydroxide.get(OrePrefixes.dust, 9), GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.HydrofluoricAcid.getFluid(4000)) + .fluidOutputs(MyMaterial.thoriumTetrafluoride.getFluidOrGas(1000)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + // Zn + 2Cl = ZnCl2 + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Zinc, 1), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Chlorine.getGas(2000)) + .itemOutputs(MyMaterial.zincChloride.get(OrePrefixes.dust, 3)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + // ZnCl2 + 3Ca + ThF4 = ZnTh + CaCl2 + 2CaF2 + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.zincChloride.get(OrePrefixes.dust, 3), Materials.Calcium.getDust(3)) + .fluidInputs(MyMaterial.thorium232Tetrafluoride.getFluidOrGas(1000)) + .fluidOutputs(WerkstoffLoader.CalciumChloride.getFluidOrGas(3000)) + .itemOutputs( + MyMaterial.zincThoriumAlloy.get(OrePrefixes.ingot, 1), + WerkstoffLoader.Fluorspar.get(OrePrefixes.dust, 6)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 3000) + .addTo(blastFurnaceRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.zincThoriumAlloy.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(11)) + .fluidInputs(Materials.Argon.getGas(250)) + .fluidOutputs(Materials.Zinc.getMolten(144)) + .itemOutputs(WerkstoffLoader.Thorium232.get(OrePrefixes.dust, 1)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_HV) + .metadata(COIL_HEAT, 1900) + .addTo(blastFurnaceRecipes); + + // 2V + 5O = V2O5 + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Vanadium, 2), + GT_Utility.getIntegratedCircuit(24)) + .fluidInputs(Materials.Oxygen.getGas(5000)) + .itemOutputs(MyMaterial.vanadiumPentoxide.get(OrePrefixes.dust, 7)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 2500) + .addTo(blastFurnaceRecipes); + + // Atomic Separation Catalyst + ItemStack[] mat1 = new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Blaze, 32), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Firestone, 4) }; + ItemStack[] mat2 = new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Draconium, 4), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quantium, 4), }; + ItemStack[] mat3 = new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Ardite, 4), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Manyullyn, 4) }; + + for (ItemStack m1 : mat1) { + for (ItemStack m2 : mat2) { + for (ItemStack m3 : mat3) { + GT_Values.RA.stdBuilder() + .itemInputs(m1, m2, m3, GT_Utility.getIntegratedCircuit(4)) + .fluidInputs(Materials.Naquadah.getMolten(288)) + .itemOutputs(ItemRefer.Raw_Atomic_Separation_Catalyst.get(63)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(mixerRecipes); + } + } + } + + GT_Values.RA.stdBuilder() + .itemInputs( + WerkstoffLoader.Tiberium.get(OrePrefixes.plate, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Silicon, 8)) + .itemOutputs(MyMaterial.orundum.get(OrePrefixes.plate, 1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_IV / 2) + .addTo(formingPressRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.orundum.get(OrePrefixes.plate, 2), ItemRefer.Raw_Atomic_Separation_Catalyst.get(4)) + .fluidInputs(Materials.Plutonium.getMolten(144)) + .itemOutputs(MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.ingotHot, 1)) + .duration(3 * MINUTES) + .eut(TierEU.RECIPE_HV) + .metadata(COIL_HEAT, 5000) + .addTo(blastFurnaceRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.ingotHot, 1)) + .itemOutputs(MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.ingot, 1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(vacuumFreezerRecipes); + + CrackRecipeAdder.crackerAdder( + MyMaterial.naquadahGas.getFluidOrGas(1000), + MyMaterial.atomicSeparationCatalyst.getMolten(4), + new FluidStack[] { Materials.Helium.getGas(300), WerkstoffLoader.Neon.getFluidOrGas(50), + Materials.Argon.getGas(80), WerkstoffLoader.Krypton.getFluidOrGas(20), + WerkstoffLoader.Xenon.getFluidOrGas(40), Materials.Radon.getGas(14000) }, + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Naquadah, 1), + 6, + 4020, + 300); + + CrackRecipeAdder.crackerAdder( + MyMaterial.lightNaquadahFuel.getFluidOrGas(1000), + MyMaterial.atomicSeparationCatalyst.getMolten(4), + new FluidStack[] { Materials.Radon.getGas(1400), MyMaterial.naquadahGas.getFluidOrGas(400), + Materials.Uranium.getMolten(648), MyMaterial.heavyNaquadahFuel.getFluidOrGas(280), + Materials.Plutonium.getMolten(576), MyMaterial.naquadahAsphalt.getFluidOrGas(140) }, + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Uranium235, 1), + 6, + 4020, + 450); + + CrackRecipeAdder.crackerAdder( + MyMaterial.heavyNaquadahFuel.getFluidOrGas(1000), + MyMaterial.atomicSeparationCatalyst.getMolten(6), + new FluidStack[] { Materials.Radon.getGas(1000), MyMaterial.naquadahGas.getFluidOrGas(450), + MyMaterial.lightNaquadahFuel.getFluidOrGas(560), Materials.Uranium.getMolten(720), + Materials.Lutetium.getMolten(648), MyMaterial.naquadahAsphalt.getFluidOrGas(240) }, + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Plutonium, 1), + 6, + 4020, + 500); + + CrackRecipeAdder.crackerAdder( + MyMaterial.naquadahAsphalt.getFluidOrGas(1000), + MyMaterial.atomicSeparationCatalyst.getMolten(12), + new FluidStack[] { MyMaterial.lightNaquadahFuel.getFluidOrGas(600), Materials.Uranium.getMolten(1152), + Materials.Thorium.getMolten(864), Materials.Plutonium.getMolten(792), Materials.Thulium.getMolten(216), + MyMaterial.heavyNaquadahFuel.getFluidOrGas(350) }, + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Naquadria, 1), + 6, + 4020, + 800); + + // 2C2H6O =H2SO4= C4H10O + H2O + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(2)) + .fluidInputs(Materials.Ethanol.getFluid(1000), Materials.SulfuricAcid.getFluid(1000)) + .fluidOutputs(MyMaterial.ether.getFluidOrGas(500), Materials.DilutedSulfuricAcid.getFluid(1500)) + .duration(25 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(multiblockChemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(Materials.GasolineRaw.getCells(9), Materials.Ethanol.getCells(1)) + .itemOutputs(MyMaterial.ethanolGasoline.get(OrePrefixes.cell, 10)) + .duration(15 * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(UniversalChemical); + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.ether.get(OrePrefixes.cell)) + .metadata(FUEL_VALUE, 537) + .metadata(FUEL_TYPE, 0) + .addTo(GT_RecipeConstants.Fuel); + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.ether.get(OrePrefixes.cell)) + .metadata(FUEL_VALUE, 537) + .metadata(FUEL_TYPE, 1) + .addTo(GT_RecipeConstants.Fuel); + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.ethanolGasoline.get(OrePrefixes.cell)) + .metadata(FUEL_VALUE, 1100) + .metadata(FUEL_TYPE, 0) + .addTo(GT_RecipeConstants.Fuel); + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.cyclopentadiene.get(OrePrefixes.cell)) + .metadata(FUEL_VALUE, 70) + .metadata(FUEL_TYPE, 1) + .addTo(GT_RecipeConstants.Fuel); + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.ironedFuel.get(OrePrefixes.cell)) + .metadata(FUEL_VALUE, 2248) + .metadata(FUEL_TYPE, 0) + .addTo(GT_RecipeConstants.Fuel); + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.ironedKerosene.get(OrePrefixes.cell)) + .metadata(FUEL_VALUE, 1824) + .metadata(FUEL_TYPE, 0) + .addTo(GT_RecipeConstants.Fuel); + + // Sb + 3Cl = SbCl3 + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Antimony, 1)) + .fluidInputs(MyMaterial.ether.getFluidOrGas(1000), Materials.Chlorine.getGas(3000)) + .fluidOutputs(MyMaterial.antimonyTrichloride.getFluidOrGas(1000)) + .duration(3 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(multiblockChemicalReactorRecipes); + + // SbCl3 + 2Cl = SbCl5 + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.antimonyTrichloride.getFluidOrGas(1000), Materials.Chlorine.getGas(2000)) + .fluidOutputs(MyMaterial.antimonyPentachlorideSolution.getFluidOrGas(1000)) + .duration(9 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(multiblockChemicalReactorRecipes); + + CrackRecipeAdder.addUniversalDistillationRecipe( + MyMaterial.antimonyPentachlorideSolution.getFluidOrGas(1000), + new FluidStack[] { MyMaterial.ether.getFluidOrGas(1000), + MyMaterial.antimonyPentachloride.getFluidOrGas(1000) }, + GT_Values.NI, + 30 * SECONDS, + TierEU.RECIPE_MV); + + // SbCl5 + 5HF = SbF5 + 5HCl + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs( + MyMaterial.antimonyPentachloride.getFluidOrGas(1000), + Materials.HydrofluoricAcid.getFluid(5000)) + .fluidOutputs( + MyMaterial.antimonyPentafluoride.getFluidOrGas(1000), + Materials.HydrochloricAcid.getFluid(5000)) + .duration(21 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(multiblockChemicalReactorRecipes); + + // SbH5 + HF = HSbF6 + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs( + MyMaterial.antimonyPentafluoride.getFluidOrGas(1000), + Materials.HydrofluoricAcid.getFluid(1000)) + .fluidOutputs(MyMaterial.fluoroantimonicAcid.getFluidOrGas(1000)) + .duration(42 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(multiblockChemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.NaquadahEnriched, 16), + GT_Utility.getIntegratedCircuit(16)) + .fluidInputs(Materials.HydrofluoricAcid.getFluid(3000)) + .fluidOutputs(MyMaterial.acidNaquadahEmulsion.getFluidOrGas(2000)) + .itemOutputs(MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 3)) + .duration(3 * MINUTES) + .eut(TierEU.RECIPE_EV) + .metadata(COIL_HEAT, 3400) + .addTo(blastFurnaceRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(3), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, 8)) + .fluidInputs(MyMaterial.acidNaquadahEmulsion.getFluidOrGas(1000)) + .fluidOutputs(MyMaterial.naquadahEmulsion.getFluidOrGas(1000)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.AntimonyTrioxide, 1), + WerkstoffLoader.Fluorspar.get(OrePrefixes.dust, 4)) + .duration(12 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(multiblockChemicalReactorRecipes); + + CrackRecipeAdder.addUniversalDistillationRecipe( + MyMaterial.naquadahSolution.getFluidOrGas(20), + new FluidStack[] { MyMaterial.naquadahAsphalt.getFluidOrGas(2), + MyMaterial.heavyNaquadahFuel.getFluidOrGas(5), MyMaterial.lightNaquadahFuel.getFluidOrGas(10), + FluidRegistry.getFluidStack("water", 10), MyMaterial.naquadahGas.getFluidOrGas(60) }, + GT_Values.NI, + 1 * SECONDS, + TierEU.RECIPE_EV); + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.naquadahGas.get(OrePrefixes.cell)) + .metadata(FUEL_VALUE, 1024) + .metadata(FUEL_TYPE, 1) + .addTo(GT_RecipeConstants.Fuel); + + GT_Values.RA.stdBuilder() + .fluidInputs( + MyMaterial.lightNaquadahFuel.getFluidOrGas(780), + MyMaterial.heavyNaquadahFuel.getFluidOrGas(360)) + .fluidOutputs(MyMaterial.naquadahBasedFuelMkI.getFluidOrGas(100)) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .metadata(FUSION_THRESHOLD, 320000000) + .addTo(fusionRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.NetherStar, 4), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.ElectrumFlux, 32)) + .fluidInputs(MyMaterial.naquadahBasedFuelMkI.getFluidOrGas(100), MyMaterial.naquadahGas.getFluidOrGas(1500)) + .fluidOutputs(MyMaterial.naquadahBasedFuelMkII.getFluidOrGas(100)) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_UHV / 2) + .addTo(multiblockChemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 32), + GT_Utility.getIntegratedCircuit(16)) + .fluidInputs(MyMaterial.fluoroantimonicAcid.getFluidOrGas(4000)) + .fluidOutputs(MyMaterial.acidNaquadahEmulsion.getFluidOrGas(8000)) + .itemOutputs(MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 17)) + .duration(3 * MINUTES) + .eut(TierEU.RECIPE_IV / 2) + .metadata(COIL_HEAT, 3400) + .addTo(blastFurnaceRecipes); + + GT_Values.RA.stdBuilder() + .metadata( + RESEARCH_ITEM, + ItemList.Generator_Naquadah_Mark_V.get(1) + .copy()) + .metadata(RESEARCH_TIME, 7 * HOURS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmiridium, 8), + ItemRefer.Advanced_Radiation_Protection_Plate.get(64), + ItemList.Field_Generator_UV.get(8), + ItemList.Electric_Pump_UHV.get(2), + new Object[] { OrePrefixes.circuit.get(Materials.Bio), 4 }, + GT_OreDictUnificator.get(OrePrefixes.pipeHuge, Materials.MysteriousCrystal, 8), + ItemList.Circuit_Wafer_NPIC.get(16), + ItemList.UHV_Coil.get(64), + new Object[] { "craftingLensYellow", 16 }, + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Thulium, 64)) + .fluidInputs( + Materials.Quantium.getMolten(9216L), + Materials.DraconiumAwakened.getMolten(4608L), + MyMaterial.extremelyUnstableNaquadah.getMolten(1440), + new FluidStack(solderIndalloy, 14400)) + .itemOutputs(ItemRefer.Naquadah_Fuel_Refinery.get(1)) + .eut(TierEU.RECIPE_UHV) + .duration(30 * MINUTES) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Radiation_Protection_Plate.get(1)) + .metadata(RESEARCH_TIME, 1 * HOURS + 7 * MINUTES) + .itemInputs( + ItemRefer.Radiation_Protection_Plate.get(1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.ElectrumFlux, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Trinium, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahAlloy, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Osmiridium, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.VibrantAlloy, 4), + ItemRefer.Radiation_Protection_Plate.get(1)) + .fluidInputs(new FluidStack(solderIndalloy, 1152)) + .itemOutputs(ItemRefer.Advanced_Radiation_Protection_Plate.get(1)) + .eut(TierEU.RECIPE_ZPM / 2) + .duration(50 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Field_Restriction_Casing.get(1)) + .metadata(RESEARCH_TIME, 3 * HOURS + 30 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Thulium, 1), + ItemRefer.Advanced_Radiation_Protection_Plate.get(6), + ItemList.Field_Generator_IV.get(2), + GT_OreDictUnificator.get(OrePrefixes.pipeTiny, Materials.Naquadah, 16), + GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.NaquadahAlloy, 32), + GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.NaquadahAlloy, 32), + GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.Manyullyn, 32), + GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.Manyullyn, 32), + MyMaterial.orundum.get(OrePrefixes.plate, 4)) + .fluidInputs(Materials.TungstenSteel.getMolten(1152), new FluidStack(solderIndalloy, 2304)) + .itemOutputs(ItemRefer.Naquadah_Fuel_Refinery_Casing.get(1)) + .eut(TierEU.RECIPE_ZPM / 2) + .duration(25 * SECONDS) + .addTo(AssemblyLine); + + if (NewHorizonsCoreMod.isModLoaded()) { + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.ingot)) + .metadata(RESEARCH_TIME, 4 * HOURS + 10 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmium, 1), + ItemList.Field_Generator_UV.get(2), + ItemList.Electric_Pump_UV.get(8), + GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorZPM, 64), + GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorZPM, 64), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Americium, 8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.BlackPlutonium, 16), + ItemList.Circuit_Wafer_PPIC.get(32), + new Object[] { OrePrefixes.circuit.get(Materials.Infinite), 1L }) + .fluidInputs( + WerkstoffLoader.Krypton.getFluidOrGas(1000), + Materials.ElectrumFlux.getMolten(9216), + Materials.Lubricant.getFluid(128000)) + .itemOutputs(ItemRefer.Field_Restriction_Coil_T1.get(1)) + .eut(TierEU.RECIPE_ZPM) + .duration(15 * MINUTES) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Field_Restriction_Coil_T1.get(1)) + .metadata(RESEARCH_TIME, 4 * HOURS + 50 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 1), + ItemList.Field_Generator_UHV.get(2), + ItemList.Electric_Pump_UHV.get(8), + GT_OreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorUV, 64), + GT_OreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorUV, 64), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Infinity, 8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Neutronium, 16), + ItemList.Circuit_Wafer_PPIC.get(48), + new Object[] { OrePrefixes.circuit.get(Materials.Bio), 1L }) + .fluidInputs( + Materials.Radon.getPlasma(1000), + Materials.DraconiumAwakened.getMolten(9216), + Materials.Lubricant.getFluid(128000)) + .itemOutputs(ItemRefer.Field_Restriction_Coil_T2.get(1)) + .eut(TierEU.RECIPE_ZPM) + .duration(30 * MINUTES) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Field_Restriction_Coil_T2.get(1)) + .metadata(RESEARCH_TIME, 5 * HOURS + 30 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1), + ItemList.Field_Generator_UEV.get(2), + ItemList.Electric_Pump_UEV.get(8), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUHV, 64), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUHV, 64), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Infinity, 16), + ItemList.Circuit_Wafer_PPIC.get(64), + new Object[] { OrePrefixes.circuit.get(Materials.Optical), 1L }) + .fluidInputs( + WerkstoffLoader.Oganesson.getFluidOrGas(1000), + Materials.Neutronium.getMolten(9216), + Materials.Lubricant.getFluid(128000)) + .itemOutputs(ItemRefer.Field_Restriction_Coil_T3.get(1)) + .eut(TierEU.RECIPE_ZPM) + .duration(1 * HOURS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Field_Restriction_Coil_T3.get(1)) + .metadata(RESEARCH_TIME, 7 * HOURS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 1), + ItemList.Field_Generator_UIV.get(2), + ItemList.Electric_Pump_UIV.get(8), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUEV, 64), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUEV, 64), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, MaterialsUEVplus.SpaceTime, 16), + ItemList.Circuit_Wafer_PPIC.get(64), + new Object[] { OrePrefixes.circuit.get(Materials.Piko), 1L }) + .fluidInputs( + MyMaterial.metastableOganesson.getMolten(1000), + MaterialsUEVplus.TranscendentMetal.getMolten(9216), + Materials.Lubricant.getFluid(128000)) + .itemOutputs(ItemRefer.Field_Restriction_Coil_T4.get(1)) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * HOURS) + .addTo(AssemblyLine); + } + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.BorosilicateGlass, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.ReinforceGlass, 6), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.NaquadahAlloy, 32), + ItemList.Field_Generator_HV.get(4), + GT_Utility.getIntegratedCircuit(6)) + .fluidInputs(Materials.Naquadria.getMolten(288)) + .itemOutputs(ItemRefer.Field_Restriction_Glass.get(1)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + + // Ca + O = CaO + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcium, 1)) + .fluidInputs(Materials.Oxygen.getGas(1000)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, 2)) + .duration(10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + // AlN = Al + N + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Aluminum_Nitride_Dust.get(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Aluminium, 1)) + .fluidOutputs(Materials.Nitrogen.getGas(1000L)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(electrolyzerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Aluminum_Nitride_Dust.get(4), + WerkstoffLoader.YttriumOxide.get(OrePrefixes.dust, 5), + GT_Utility.getIntegratedCircuit(9)) + .fluidInputs(FluidRegistry.getFluidStack("advancedglue", 1000)) + .itemOutputs(ItemRefer.Special_Ceramics_Dust.get(9)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Aluminum_Nitride_Dust.get(4), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Uraninite, 5), + GT_Utility.getIntegratedCircuit(9)) + .fluidInputs(FluidRegistry.getFluidStack("advancedglue", 1000)) + .itemOutputs(ItemRefer.Special_Ceramics_Dust.get(9)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Special_Ceramics_Dust.get(2), ItemList.Shape_Extruder_Plate.get(0L)) + .itemOutputs(ItemRefer.Special_Ceramics_Plate.get(1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(extruderRecipes); + + GT_ModHandler.addCraftingRecipe( + ItemRefer.Raw_Cylinder.get(1), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "PPP", "PFP", "PPP", 'P', ItemRefer.Special_Ceramics_Plate.get(1), 'F', + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.StainlessSteel, 1) }); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Raw_Cylinder.get(1), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Titanium, 1), + GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Titanium, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Titanium, 6), + GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(ItemRefer.Titanium_Plated_Cylinder.get(1)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(16), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Saltpeter, 2)) + .fluidInputs(FluidRegistry.getFluidStack("liquidoxygen", 1000), Materials.NitrogenDioxide.getGas(1000)) + .fluidOutputs(FluidRegistry.getFluidStack("combustionpromotor", 500)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(multiblockChemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(16), WerkstoffLoader.SodiumNitrate.get(OrePrefixes.dust, 2)) + .fluidInputs(FluidRegistry.getFluidStack("liquidoxygen", 1000), Materials.NitrogenDioxide.getGas(1000)) + .fluidOutputs(FluidRegistry.getFluidStack("combustionpromotor", 500)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(multiblockChemicalReactorRecipes); + + if (GTPlusPlus.isModLoaded()) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(16), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Saltpeter, 2)) + .fluidInputs( + FluidRegistry.getFluidStack("fluid.hydrogenperoxide", 1000), + Materials.NitrogenDioxide.getGas(1000)) + .fluidOutputs(FluidRegistry.getFluidStack("combustionpromotor", 2000)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(16), WerkstoffLoader.SodiumNitrate.get(OrePrefixes.dust, 2)) + .fluidInputs( + FluidRegistry.getFluidStack("fluid.hydrogenperoxide", 1000), + Materials.NitrogenDioxide.getGas(1000)) + .fluidOutputs(FluidRegistry.getFluidStack("combustionpromotor", 2000)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(multiblockChemicalReactorRecipes); + } + + GT_ModHandler.addCraftingRecipe( + ItemRefer.Universal_Chemical_Fuel_Engine.get(1), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "TZT", "ALB", "WGW", 'T', + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Titanium, 1), 'Z', "circuitUltimate", 'A', + ItemList.Machine_Multi_DieselEngine.get(1), 'B', ItemList.Machine_Multi_ExtremeDieselEngine.get(1), 'L', + ItemList.Hull_LuV, 'W', GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Naquadah, 1), 'G', + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Osmium, 1), }); + + // neutron activator + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, Materials.PolyvinylChloride, 4), + GT_OreDictUnificator.get(OrePrefixes.itemCasing, Materials.Plastic, 4), + GT_Utility.getIntegratedCircuit(8)) + .fluidInputs(FluidRegistry.getFluidStack("dye.chemical.dyecyan", 144)) + .itemOutputs(ItemRefer.Plastic_Case.get(1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, Materials.PolyvinylChloride, 4), + GT_OreDictUnificator.get(OrePrefixes.itemCasing, Materials.Plastic, 4), + GT_Utility.getIntegratedCircuit(8)) + .fluidInputs(FluidRegistry.getFluidStack("dye.watermixed.dyecyan", 144)) + .itemOutputs(ItemRefer.Plastic_Case.get(1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + + GT_ModHandler.addCraftingRecipe( + ItemRefer.Plastic_Case.get(1), + new Object[] { "PCP", "CDC", "PCP", 'P', + GT_OreDictUnificator.get(OrePrefixes.stick, Materials.PolyvinylChloride, 1), 'C', + GT_OreDictUnificator.get(OrePrefixes.itemCasing, Materials.Plastic, 1), 'D', "dyeCyan" }); + + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemList.Circuit_Board_Coated_Basic.get(1), ItemList.Circuit_Chip_ULPIC.get(1), + ItemList.ULV_Coil.get(2), ItemList.Battery_RE_ULV_Tantalum.get(1) }, + new FluidStack[] { Materials.RedAlloy.getMolten(144), Materials.Aluminium.getMolten(144) }, + ItemRefer.Micro_Heater.get(1), + 120, + 40, + 1); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Quartzite, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 4)) + .fluidInputs(Materials.Water.getFluid(1000)) + .itemOutputs(ItemRefer.Quartz_Wafer.get(1)) + .outputChances(3333) + .requiresCleanRoom() + .duration(5 * MINUTES) + .eut(TierEU.RECIPE_LV) + .addTo(autoclaveRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Quartzite, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 4)) + .fluidInputs(FluidRegistry.getFluidStack("ic2distilledwater", 1000)) + .itemOutputs(ItemRefer.Quartz_Wafer.get(1)) + .requiresCleanRoom() + .duration(1 * MINUTES + 15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(autoclaveRecipes); + + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemRefer.Quartz_Wafer.get(1), ItemRefer.Special_Ceramics_Plate.get(2), + ItemRefer.Micro_Heater.get(1), ItemList.Circuit_Chip_ILC.get(4) }, + new FluidStack[] { Materials.EnergeticAlloy.getMolten(72), Materials.Silver.getMolten(18) }, + ItemRefer.Quartz_Crystal_Resonator.get(1), + 480, + 40, + 1); + + for (Materials tMat : solderingMats) { + int tMultiplier = tMat.contains(SubTag.SOLDERING_MATERIAL_GOOD) ? 1 + : tMat.contains(SubTag.SOLDERING_MATERIAL_BAD) ? 4 : 2; + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Quartz_Crystal_Resonator.get(2), + ItemRefer.Plastic_Case.get(1), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Good, 1), + ItemList.Cover_Screen.get(1), + GT_OreDictUnificator.get(OrePrefixes.componentCircuit, Materials.Diode, 16L), + GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.Aluminium, 8)) + .fluidInputs(tMat.getMolten(144 * tMultiplier)) + .itemOutputs(ItemRefer.Inverter.get(1)) + .duration(12 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Quartz_Crystal_Resonator.get(2), + ItemRefer.Plastic_Case.get(1), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Good, 1), + ItemList.Cover_Screen.get(1), + ItemList.Circuit_Parts_DiodeASMD.get(4), + GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.Aluminium, 8)) + .fluidInputs(tMat.getMolten(144 * tMultiplier)) + .itemOutputs(ItemRefer.Inverter.get(1)) + .duration(12 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + if (NewHorizonsCoreMod.isModLoaded()) { + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Circuit_Board_Multifiberglass_Elite.get(1), + GT_ModHandler.getModItem("dreamcraft", "item.EngravedGoldChip", 16), + ItemList.Circuit_Chip_SoC2.get(8), + ItemList.Circuit_Chip_NOR.get(32), + MyMaterial.signalium.get(OrePrefixes.bolt, 32), + GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.Aluminium, 8), + GT_ModHandler.getIC2Item("reactorVent", 1L, 1)) + .fluidInputs(tMat.getMolten(288 * tMultiplier)) + .itemOutputs(ItemRefer.HiC_T1.get(1)) + .duration(1 * MINUTES) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Circuit_Board_Multifiberglass_Elite.get(1), + GT_ModHandler.getModItem("dreamcraft", "item.EngravedGoldChip", 16), + ItemList.Circuit_Chip_SoC2.get(8), + ItemList.Circuit_Chip_NOR.get(32), + MyMaterial.signalium.get(OrePrefixes.bolt, 32), + GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.Aluminium, 8), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.TinAlloy, 1)) + .fluidInputs(tMat.getMolten(288 * tMultiplier)) + .itemOutputs(ItemRefer.HiC_T1.get(1)) + .duration(1 * MINUTES) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + } + } + + GT_ModHandler.addCraftingRecipe( + Loaders.NeutronAccelerators[0].copy(), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "WPM", "CHI", "WPM", 'W', GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Lead, 1), + 'P', GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Lead, 1), 'M', + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Lead, 1), 'C', + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Wood, 1), 'H', ItemList.Hull_ULV, 'I', + ItemRefer.Inverter.get(1), }); + + GT_ModHandler.addCraftingRecipe( + Loaders.NeutronAccelerators[1].copy(), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "WPM", "CHI", "WPM", 'W', GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Tin, 1), + 'P', GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Lead, 1), 'M', + ItemList.Electric_Motor_LV, 'C', "plateAnyRubber", 'H', ItemList.Hull_LV, 'I', + ItemRefer.Inverter.get(1), }); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Inverter.get(1), + ItemList.Hull_MV.get(1L), + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.AnyCopper, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Plastic, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Beryllium, 2), + ItemList.Electric_Motor_MV.get(2)) + .itemOutputs(Loaders.NeutronAccelerators[2].copy()) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Inverter.get(1), + ItemList.Hull_HV.get(1L), + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Gold, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.PolyvinylChloride, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Beryllium, 2), + ItemList.Electric_Motor_HV.get(2)) + .itemOutputs(Loaders.NeutronAccelerators[3].copy()) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Loaders.NeutronAccelerators[5].copy()) + .metadata(RESEARCH_TIME, 16 * MINUTES) + .itemInputs( + ItemRefer.Inverter.get(2), + ItemList.Hull_LuV.get(1L), + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.YttriumBariumCuprate, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NetherStar, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Polybenzimidazole, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NeodymiumMagnetic, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NeodymiumMagnetic, 4), + ItemList.Electric_Motor_LuV.get(2), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorMV, 4)) + .fluidInputs(Materials.Argon.getGas(3000)) + .itemOutputs(Loaders.NeutronAccelerators[6].copy()) + .eut(TierEU.RECIPE_LuV) + .duration(15 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Loaders.NeutronAccelerators[6].copy()) + .metadata(RESEARCH_TIME, 16 * MINUTES) + .itemInputs( + ItemRefer.Inverter.get(2), + ItemList.Hull_ZPM.get(1L), + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.VanadiumGallium, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NetherStar, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Polybenzimidazole, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.SamariumMagnetic, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.SamariumMagnetic, 4), + ItemList.Electric_Motor_ZPM.get(2), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorEV, 4)) + .fluidInputs(WerkstoffLoader.Xenon.getFluidOrGas(3000)) + .itemOutputs(Loaders.NeutronAccelerators[7].copy()) + .eut(TierEU.RECIPE_ZPM) + .duration(15 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Loaders.NeutronAccelerators[7].copy()) + .metadata(RESEARCH_TIME, 16 * MINUTES) + .itemInputs( + ItemRefer.Inverter.get(4), + ItemList.Hull_UV.get(1L), + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.NaquadahAlloy, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NetherStar, 2), + GT_OreDictUnificator.get(OrePrefixes.plateTriple, Materials.Polybenzimidazole, 4), + ItemList.ZPM_Coil.get(4), + GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.NickelZincFerrite, 16), + ItemList.ZPM_Coil.get(4), + ItemList.Electric_Motor_UV.get(2), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorLuV, 4)) + .fluidInputs(WerkstoffLoader.Oganesson.getFluidOrGas(3000)) + .itemOutputs(Loaders.NeutronAccelerators[8].copy()) + .eut(TierEU.RECIPE_UV) + .duration(15 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Casing_IV.get(1L), + ItemList.Cover_ActivityDetector.get(1L), + ItemList.Cover_Screen.get(1L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.VibrantAlloy, 4), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Data, 1), + ItemList.Sensor_HV.get(2), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Helium.getGas(1000)) + .itemOutputs(Loaders.NS.copy()) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_ModHandler.addCraftingRecipe( + ItemRefer.Neutron_Source.get(1), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { " P ", "PUP", " P ", 'P', + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Steel, 1), 'U', + ItemRefer.High_Density_Uranium.get(1) }); + + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemRefer.HiC_T2.get(2), ItemList.Emitter_EV.get(2), ItemRefer.Neutron_Source.get(1) }, + new FluidStack[] { Materials.StainlessSteel.getMolten(576), Materials.TungstenCarbide.getMolten(144) }, + Loaders.NA.copy(), + 7680, + 100, + 1); + } + + public static void InitLoadRecipe() { + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Inverter.get(1), + ItemList.Hull_EV.get(1L), + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Aluminium, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.StyreneButadieneRubber, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.IronMagnetic, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.TungstenCarbide, 2), + ItemList.Electric_Motor_EV.get(2)) + .itemOutputs(Loaders.NeutronAccelerators[4].copy()) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Inverter.get(1), + ItemList.Hull_IV.get(1L), + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Tungsten, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Silicone, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.SteelMagnetic, 4), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.TungstenCarbide, 2), + ItemList.Electric_Motor_IV.get(2)) + .itemOutputs(Loaders.NeutronAccelerators[5].copy()) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + // Al2O3 + 2N + 3C = 2AlN + 3CO + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sapphire, 5), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 3)) + .fluidInputs(FluidRegistry.getFluidStack("liquidnitrogen", 2000)) + .fluidOutputs(Materials.CarbonMonoxide.getGas(3000)) + .itemOutputs(ItemRefer.Aluminum_Nitride_Dust.get(2)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .metadata(COIL_HEAT, 4600) + .addTo(blastFurnaceRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.GreenSapphire, 5), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 3)) + .fluidInputs(FluidRegistry.getFluidStack("liquidnitrogen", 2000)) + .fluidOutputs(Materials.CarbonMonoxide.getGas(3000)) + .itemOutputs(ItemRefer.Aluminum_Nitride_Dust.get(2)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .metadata(COIL_HEAT, 4600) + .addTo(blastFurnaceRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Aluminiumoxide, 5), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 3)) + .fluidInputs(FluidRegistry.getFluidStack("liquidnitrogen", 2000)) + .fluidOutputs(Materials.CarbonMonoxide.getGas(3000)) + .itemOutputs(ItemRefer.Aluminum_Nitride_Dust.get(2)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .metadata(COIL_HEAT, 4600) + .addTo(blastFurnaceRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 1), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.ingotHot)) + .duration(6 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .metadata(COIL_HEAT, 7000) + .addTo(blastFurnaceRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.ingotHot, 1)) + .itemOutputs(MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.ingot, 1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(vacuumFreezerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.naquadahBasedFuelMkVIDepleted.getFluidOrGas(1000)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1)) + .outputChances(1000, 500, 400, 50, 20, 5) + .fluidOutputs(MyMaterial.metastableOganesson.getMolten(122)) + .duration(12 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LuV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.naquadahBasedFuelMkVDepleted.getFluidOrGas(1000)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1)) + .outputChances(1000, 500, 400, 50, 20, 5) + .fluidOutputs(WerkstoffLoader.Oganesson.getFluidOrGas(182)) + .duration(12 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LuV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.naquadahBasedFuelMkIVDepleted.getFluidOrGas(1000)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sunnarium, 32), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sunnarium, 32)) + .outputChances(9900, 9500, 9000, 8000, 5000, 3000) + .fluidOutputs(WerkstoffLoader.Oganesson.getFluidOrGas(864)) + .duration(2 * MINUTES + 5 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.naquadahBasedFuelMkIIIDepleted.getFluidOrGas(1000)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bedrockium, 32), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bedrockium, 32), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bedrockium, 32)) + .outputChances(9500, 9000, 8000, 7000, 5000, 4000) + .fluidOutputs(WerkstoffLoader.Oganesson.getFluidOrGas(720)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.naquadahBasedFuelMkIIDepleted.getFluidOrGas(1000)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 32), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Americium, 32), + WerkstoffLoader.Californium.get(OrePrefixes.dust, 32)) + .outputChances(9000, 8500, 5000, 4000, 2000) + .fluidOutputs(WerkstoffLoader.Oganesson.getFluidOrGas(144)) + .duration(6 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(1000)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lead, 16L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bismuth, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Barium, 6L)) + .outputChances(6000, 1000, 5000) + .fluidOutputs(WerkstoffLoader.Xenon.getFluidOrGas(10)) + .duration(50 * SECONDS) + .eut(TierEU.RECIPE_EV / 2) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.thoriumBasedLiquidFuelDepleted.getFluidOrGas(1000)) + .itemOutputs( + WerkstoffLoader.Thorium232.get(OrePrefixes.dust, 64), + WerkstoffLoader.Thorium232.get(OrePrefixes.dust, 16), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Praseodymium, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Praseodymium, 32), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Boron, 2), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Indium, 4)) + .outputChances(10000, 8000, 10000, 8000, 3000, 5000) + .duration(1 * MINUTES + 15 * SECONDS) + .eut(TierEU.RECIPE_EV / 2) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(1000)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tritanium, 9), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cerium, 4), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Gold, 2)) + .outputChances(5000, 8000, 7500) + .fluidOutputs(WerkstoffLoader.Krypton.getFluidOrGas(144)) + .duration(2 * MINUTES + 5 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.thoriumTetrafluoride.getFluidOrGas(1000)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Thorium, 1)) + .fluidOutputs(MyMaterial.thorium232Tetrafluoride.getFluidOrGas(750)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.naquadahEmulsion.getFluidOrGas(1000)) + .itemOutputs( + MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 4), + MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 2), + MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 1), + MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 1), + MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 1), + MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 1)) + .outputChances(8000, 7500, 5000, 2000, 500, 100) + .fluidOutputs(MyMaterial.naquadahSolution.getFluidOrGas(500)) + .duration(40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.naquadahBasedFuelMkIDepleted.getFluidOrGas(1000)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 48), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 32), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Neodymium, 32), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Europium, 32)) + .outputChances(9000, 8500, 5000, 4000, 2000) + .fluidOutputs(WerkstoffLoader.Xenon.getFluidOrGas(144)) + .duration(5 * MINUTES) + .eut(TierEU.RECIPE_EV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.radioactiveSludge.get(OrePrefixes.dust, 4)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcium, 2), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcium, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Uranium, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Plutonium, 1), + WerkstoffLoader.Tiberium.get(OrePrefixes.dust, 1)) + .outputChances(10000, 9500, 8000, 2500, 2000, 2000) + .fluidOutputs(Materials.Radon.getGas(20)) + .duration(45 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(centrifugeRecipes); + } + + public static void Fixer() { + MaterialFix.MaterialFluidExtractionFix(MyMaterial.atomicSeparationCatalyst); + MaterialFix.MaterialFluidExtractionFix(MyMaterial.extremelyUnstableNaquadah); + MaterialFix.MaterialFluidExtractionFix(MyMaterial.metastableOganesson); + MaterialFix.MaterialFluidExtractionFix(MyMaterial.shirabon); + } +} diff --git a/goodgen/src/main/java/goodgenerator/loader/RecipeLoader_02.java b/goodgen/src/main/java/goodgenerator/loader/RecipeLoader_02.java new file mode 100644 index 0000000000..70517fe781 --- /dev/null +++ b/goodgen/src/main/java/goodgenerator/loader/RecipeLoader_02.java @@ -0,0 +1,1772 @@ +package goodgenerator.loader; + +import static gregtech.api.enums.Mods.GTPlusPlus; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.autoclaveRecipes; +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.cannerRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes; +import static gregtech.api.recipe.RecipeMaps.distillationTowerRecipes; +import static gregtech.api.recipe.RecipeMaps.distilleryRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidCannerRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.recipe.RecipeMaps.fusionRecipes; +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; +import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes; +import static gregtech.api.recipe.RecipeMaps.plasmaForgeRecipes; +import static gregtech.api.recipe.RecipeMaps.unpackagerRecipes; +import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.HOURS; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeConstants.AssemblyLine; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; +import static gregtech.api.util.GT_RecipeConstants.FUSION_THRESHOLD; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; +import com.github.technus.tectech.recipe.TT_recipeAdder; + +import goodgenerator.items.MyMaterial; +import goodgenerator.util.CrackRecipeAdder; +import goodgenerator.util.ItemRefer; +import goodgenerator.util.MyRecipeAdder; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.core.item.chemistry.GenericChem; +import gtPlusPlus.core.material.ALLOY; +import gtPlusPlus.core.material.ELEMENT; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import ic2.core.Ic2Items; + +public class RecipeLoader_02 { + + public static void RecipeLoad() { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.StainlessSteel, 1), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.BlueAlloy, 1), + GT_OreDictUnificator.get(OrePrefixes.wireGt01, Materials.SuperconductorHV, 32), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Beryllium, 32), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Elite, 1)) + .itemOutputs(ItemRefer.Speeding_Pipe.get(1)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + // Compact MK1 Fusion Disassembly Recipe + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Compact_Fusion_Coil_T0.get(1)) + .itemOutputs(ItemList.Casing_Coil_Superconductor.get(3)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + + // Compact MK2 Fusion Disassembly Recipe + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Compact_Fusion_Coil_T1.get(1)) + .itemOutputs(ItemList.Casing_Fusion_Coil.get(3)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_UV) + .addTo(assemblerRecipes); + + // Compact MK3 Fusion Disassembly Recipe + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Compact_Fusion_Coil_T2.get(1)) + .itemOutputs(ItemList.Casing_Fusion_Coil.get(3)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_UHV) + .addTo(assemblerRecipes); + + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.zircaloy2, 500, 480, 2800, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.zircaloy2, 513, 480, 2800, false); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.zircaloy4, 500, 480, 2800, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.zircaloy4, 513, 480, 2800, false); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.incoloy903, 2400, 1920, 3700, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.adamantiumAlloy, 2500, 1920, 5500, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.marM200, 200, 7680, 5000, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.marM200, 220, 7680, 5000, false); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.signalium, 1600, 30720, 4000, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.lumiium, 1600, 30720, 4000, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.artheriumSn, 500, 122880, 6500, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.titaniumBetaC, 400, 7680, 5300, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.dalisenite, 800, 491520, 8700, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.hikarium, 1200, 30720, 5400, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.tairitsu, 1200, 1966080, 7400, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.preciousMetalAlloy, 2400, 7864320, 10000, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.enrichedNaquadahAlloy, 2400, 7864320, 11000, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.metastableOganesson, 600, 7864320, 12000, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.shirabon, 600, 31457280, 13000, true); + CrackRecipeAdder.reAddBlastRecipe(MyMaterial.atomicSeparationCatalyst, 35000, 120, 5000, false); + + GT_ModHandler.removeFurnaceSmelting(MyMaterial.dalisenite.get(OrePrefixes.dust)); // :doom: + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.dalisenite.get(OrePrefixes.ingotHot, 1)) + .itemOutputs(MyMaterial.dalisenite.get(OrePrefixes.ingot, 1)) + .duration(16 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(vacuumFreezerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.shirabon.get(OrePrefixes.ingotHot, 1)) + .itemOutputs(MyMaterial.shirabon.get(OrePrefixes.ingot, 1)) + .duration(2 * MINUTES) + .eut(TierEU.RECIPE_UHV) + .addTo(vacuumFreezerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + MyMaterial.zircaloy4.get(OrePrefixes.plate, 4), + MyMaterial.zircaloy2.get(OrePrefixes.ring, 2), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Advanced_Fuel_Rod.get(1), ItemRefer.High_Density_Uranium.get(1)) + .itemOutputs(ItemRefer.Fuel_Rod_U_1.get(1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(cannerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_U_1.get(2), + MyMaterial.zircaloy2.get(OrePrefixes.stick, 4), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemRefer.Fuel_Rod_U_2.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_U_2.get(2), + MyMaterial.zircaloy2.get(OrePrefixes.stick, 4), + GT_Utility.getIntegratedCircuit(5)) + .itemOutputs(ItemRefer.Fuel_Rod_U_4.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_U_1.get(4), + MyMaterial.zircaloy2.get(OrePrefixes.stickLong, 6), + GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(ItemRefer.Fuel_Rod_U_4.get(1)) + .duration(11 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Advanced_Fuel_Rod.get(1), ItemRefer.High_Density_Plutonium.get(1)) + .itemOutputs(ItemRefer.Fuel_Rod_Pu_1.get(1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(cannerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_Pu_1.get(2), + MyMaterial.zircaloy2.get(OrePrefixes.stick, 4), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemRefer.Fuel_Rod_Pu_2.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_Pu_2.get(2), + MyMaterial.zircaloy2.get(OrePrefixes.stick, 4), + GT_Utility.getIntegratedCircuit(5)) + .itemOutputs(ItemRefer.Fuel_Rod_Pu_4.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_Pu_1.get(4), + MyMaterial.zircaloy2.get(OrePrefixes.stickLong, 6), + GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(ItemRefer.Fuel_Rod_Pu_4.get(1)) + .duration(11 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_ModHandler.addCraftingRecipe( + ItemRefer.YOTTank_Casing.get(1), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "BPB", "FOF", "BPB", 'B', + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.BlackSteel, 1), 'P', + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.StainlessSteel, 1), 'F', + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Polytetrafluoroethylene, 1), 'O', + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.BlackSteel, 1), }); + + GT_ModHandler.addCraftingRecipe( + ItemRefer.YOTTank.get(1), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SPS", "ECE", "SLS", 'S', + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.BlueSteel, 1), 'P', ItemList.Cover_Screen.get(1), + 'E', "circuitData", 'L', GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Enderium, 1), 'C', + ItemRefer.YOTTank_Casing.get(1) }); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Output_IV.get(1), + GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiPart", 1, 440), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.CertusQuartz, 8), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Plastic.getMolten(144)) + .itemOutputs(Loaders.YFH) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Large_Fluid_Cell_Steel.get(12L), + GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.Tin, 4), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Plastic.getMolten(144)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T1.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Large_Fluid_Cell_Aluminium.get(3L), + GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.Tin, 4), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Plastic.getMolten(144)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T1.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Large_Fluid_Cell_StainlessSteel.get(2L), + GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.Tin, 4), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Plastic.getMolten(144)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T1.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Large_Fluid_Cell_Titanium.get(64L), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Titanium, 8), + GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.BlackSteel, 4), + GT_Utility.getIntegratedCircuit(2)) + .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(2304)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T2.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Large_Fluid_Cell_TungstenSteel.get(18L), + GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.BlackSteel, 4), + GT_Utility.getIntegratedCircuit(2)) + .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(2304)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T2.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Large_Fluid_Cell_Chrome.get(4L), + GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.BlackSteel, 4), + GT_Utility.getIntegratedCircuit(2)) + .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(2304)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T2.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fluid_Storage_Core_T1.get(32), + ItemRefer.Fluid_Storage_Core_T1.get(32), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.BlackSteel, 16), + GT_Utility.getIntegratedCircuit(10)) + .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(2304)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T2.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + Fluid solderIndalloy = FluidRegistry.getFluid("molten.indalloy140") != null + ? FluidRegistry.getFluid("molten.indalloy140") + : FluidRegistry.getFluid("molten.solderingalloy"); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T2.get(1)) + .metadata(RESEARCH_TIME, 17 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.StainlessSteel, 4), + ItemList.Electric_Pump_HV.get(8), + ItemList.Quantum_Tank_LV.get(1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Osmium, 8), + GT_ModHandler.getModItem("GalacticraftMars", "item.null", 1L, 6), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Polycaprolactam, 32)) + .fluidInputs(new FluidStack(solderIndalloy, 2304), Materials.Lubricant.getFluid(4000)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T3.get(1)) + .eut(TierEU.RECIPE_LuV) + .duration(20 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T3.get(1)) + .metadata(RESEARCH_TIME, 34 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Titanium, 4), + ItemList.Electric_Pump_EV.get(8), + ItemList.Quantum_Tank_LV.get(4), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Europium, 8), + GT_ModHandler.getModItem("GalacticraftMars", "item.null", 4L, 6), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.StyreneButadieneRubber, 64), + GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.TungstenSteel, 64)) + .fluidInputs(new FluidStack(solderIndalloy, 18432), Materials.Lubricant.getFluid(16000)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T4.get(1)) + .eut(TierEU.RECIPE_ZPM) + .duration(20 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T4.get(1)) + .metadata(RESEARCH_TIME, 1 * HOURS + 8 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.MysteriousCrystal, 4), + ItemList.Electric_Pump_IV.get(8), + ItemList.Quantum_Tank_HV.get(8), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Neutronium, 8), + GT_ModHandler.getModItem("GalacticraftMars", "item.null", 16L, 6), + GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, Materials.Polycaprolactam, 24), + GT_OreDictUnificator.get(OrePrefixes.pipeHuge, Materials.Titanium, 64)) + .fluidInputs( + Materials.Draconium.getMolten(2304), + Materials.Titanium.getMolten(288), + Materials.Lubricant.getFluid(64000)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T5.get(1)) + .eut(TierEU.RECIPE_UV) + .duration(20 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T5.get(1)) + .metadata(RESEARCH_TIME, 2 * HOURS + 15 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 4), + ItemList.Electric_Pump_LuV.get(8), + ItemList.Quantum_Tank_EV.get(16), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Infinity, 16), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.DraconiumAwakened, 16), + GT_ModHandler.getModItem("GalacticraftMars", "item.null", 64L, 6), + ItemList.Machine_IV_Compressor.get(64)) + .fluidInputs( + Materials.Draconium.getMolten(2304), + Materials.Titanium.getMolten(288), + Materials.Lubricant.getFluid(64000)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T6.get(1)) + .eut(TierEU.RECIPE_UHV) + .duration(20 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T6.get(1)) + .metadata(RESEARCH_TIME, 4 * HOURS + 30 * MINUTES) + .itemInputs( + GT_ModHandler.getModItem("GalacticraftMars", "item.null", 64L, 6), + ItemList.Electric_Pump_ZPM.get(8), + GT_ModHandler.getModItem("Avaritia", "Neutronium_Compressor", 1L, 0), + ItemList.Quantum_Tank_EV.get(32), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 8), + GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, Materials.InfinityCatalyst, 8), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.DraconiumAwakened, 16)) + .fluidInputs( + Materials.Draconium.getMolten(23040), + new FluidStack(solderIndalloy, 2304), + Materials.InfinityCatalyst.getMolten(1140)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T7.get(1)) + .eut(TierEU.RECIPE_UEV) + .duration(20 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T7.get(1)) + .metadata(RESEARCH_TIME, 9 * HOURS) + .itemInputs( + GT_ModHandler.getModItem("GalacticraftMars", "item.null", 64L, 6), + ItemList.Electric_Pump_UV.get(8), + GT_ModHandler.getModItem("Avaritia", "Neutronium_Compressor", 2L, 0), + ItemList.Quantum_Tank_EV.get(64), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 16), + GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, Materials.Infinity, 24), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.DraconiumAwakened, 16)) + .fluidInputs( + Materials.Draconium.getMolten(36864), + new FluidStack(solderIndalloy, 30240), + Materials.InfinityCatalyst.getMolten(5670)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T8.get(1)) + .eut(TierEU.RECIPE_UIV) + .duration(20 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T8.get(1)) + .metadata(RESEARCH_TIME, 180 * HOURS) + .itemInputs( + GT_ModHandler.getModItem("GalacticraftMars", "item.null", 64L, 6), + ItemList.Electric_Pump_UHV.get(8), + GT_ModHandler.getModItem("Avaritia", "Neutronium_Compressor", 2L, 0), + ItemList.Quantum_Tank_IV.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 32), + GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, Materials.Infinity, 36), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.DraconiumAwakened, 8)) + .fluidInputs( + Materials.Draconium.getMolten(36864), + new FluidStack(solderIndalloy, 30240), + MaterialsUEVplus.TranscendentMetal.getMolten(1440), + Materials.InfinityCatalyst.getMolten(5670)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T9.get(1)) + .eut(TierEU.RECIPE_UMV) + .duration(20 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Fluid_Storage_Core_T9.get(1)) + .metadata(RESEARCH_TIME, 360 * HOURS) + .itemInputs( + GT_ModHandler.getModItem("GalacticraftMars", "item.null", 64L, 6), + ItemList.Electric_Pump_UEV.get(8), + GT_ModHandler.getModItem("Avaritia", "Neutronium_Compressor", 4L, 0), + ItemList.Quantum_Tank_IV.get(16), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 32), + GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, Materials.CosmicNeutronium, 24), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, MaterialsUEVplus.SpaceTime, 4)) + .fluidInputs( + Materials.Draconium.getMolten(36864), + new FluidStack(solderIndalloy, 46080), + MaterialsUEVplus.TranscendentMetal.getMolten(4320), + Materials.InfinityCatalyst.getMolten(17010)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T10.get(1)) + .eut(TierEU.RECIPE_UXV) + .duration(20 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.BlackSteel, 1), + ItemRefer.Fluid_Storage_Core_T1.get(10), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Steel, 4), + ItemList.Electric_Pump_HV.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.StainlessSteel, 4), + GT_Utility.getIntegratedCircuit(5)) + .fluidInputs(Materials.Plastic.getMolten(144)) + .itemOutputs(ItemRefer.YOTTank_Cell_T1.get(1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.TungstenSteel, 1), + ItemRefer.Fluid_Storage_Core_T2.get(10), + WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.plate, 4), + ItemList.Electric_Pump_EV.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Enderium, 4), + GT_Utility.getIntegratedCircuit(5)) + .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(144)) + .itemOutputs(ItemRefer.YOTTank_Cell_T2.get(1)) + .duration(50 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T2.get(1)) + .metadata(RESEARCH_TIME, 17 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Naquadah, 1), + ItemRefer.Fluid_Storage_Core_T3.get(10), + new Object[] { OrePrefixes.circuit.get(Materials.Master), 8 }, + ItemList.Electric_Pump_IV.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.NiobiumTitanium, 8), + MyMaterial.adamantiumAlloy.get(OrePrefixes.plate, 32)) + .fluidInputs( + Materials.Quantium.getMolten(1440), + FluidRegistry.getFluidStack("ic2coolant", 8000), + Materials.Lubricant.getFluid(8000)) + .itemOutputs(ItemRefer.YOTTank_Cell_T3.get(1)) + .eut(TierEU.RECIPE_LuV) + .duration(50 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T3.get(1)) + .metadata(RESEARCH_TIME, 34 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Neutronium, 1), + ItemRefer.Fluid_Storage_Core_T4.get(10), + new Object[] { OrePrefixes.circuit.get(Materials.Ultimate), 8 }, + ItemList.Electric_Pump_LuV.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.MysteriousCrystal, 8), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.ElectrumFlux, 32)) + .fluidInputs( + Materials.Draconium.getMolten(1440), + FluidRegistry.getFluidStack("ic2coolant", 16000), + Materials.Lubricant.getFluid(16000)) + .itemOutputs(ItemRefer.YOTTank_Cell_T4.get(1)) + .eut(TierEU.RECIPE_ZPM) + .duration(50 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T4.get(1)) + .metadata(RESEARCH_TIME, 1 * HOURS + 8 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 1), + ItemRefer.Fluid_Storage_Core_T5.get(10), + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 8 }, + ItemList.Electric_Pump_ZPM.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.DraconiumAwakened, 8), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Neutronium, 64)) + .fluidInputs( + Materials.Draconium.getMolten(1440), + FluidRegistry.getFluidStack("ic2coolant", 16000), + Materials.Lubricant.getFluid(16000)) + .itemOutputs(ItemRefer.YOTTank_Cell_T5.get(1)) + .eut(TierEU.RECIPE_UV) + .duration(50 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T5.get(1)) + .metadata(RESEARCH_TIME, 2 * HOURS + 15 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1), + ItemRefer.Fluid_Storage_Core_T6.get(2), + new Object[] { OrePrefixes.circuit.get(Materials.Infinite), 8L }, + ItemList.Electric_Pump_UV.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.NetherStar, 8), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Infinity, 64)) + .fluidInputs( + Materials.DraconiumAwakened.getMolten(1440), + FluidRegistry.getFluidStack("ic2coolant", 46080), + Materials.Lubricant.getFluid(32000)) + .itemOutputs(ItemRefer.YOTTank_Cell_T6.get(1)) + .eut(TierEU.RECIPE_UHV) + .duration(50 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T6.get(1)) + .metadata(RESEARCH_TIME, 4 * HOURS + 30 * MINUTES) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1), + ItemRefer.Fluid_Storage_Core_T7.get(2), + new Object[] { OrePrefixes.circuit.get(Materials.Bio), 8L }, + ItemList.Electric_Pump_UHV.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.NetherStar, 16), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.CosmicNeutronium, 32), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Infinity, 32)) + .fluidInputs( + Materials.DraconiumAwakened.getMolten(14400), + FluidRegistry.getFluidStack("supercoolant", 46080), + Materials.Lubricant.getFluid(46080)) + .itemOutputs(ItemRefer.YOTTank_Cell_T7.get(1)) + .eut(TierEU.RECIPE_UEV) + .duration(50 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T7.get(1)) + .metadata(RESEARCH_TIME, 9 * HOURS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1), + ItemRefer.Fluid_Storage_Core_T8.get(2), + new Object[] { OrePrefixes.circuit.get(Materials.Optical), 8L }, + ItemList.Electric_Pump_UEV.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.NetherStar, 12), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.CosmicNeutronium, 12), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.DraconiumAwakened, 12), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Infinity, 64)) + .fluidInputs( + Materials.DraconiumAwakened.getMolten(14400), + FluidRegistry.getFluidStack("supercoolant", 46080), + Materials.Lubricant.getFluid(46080)) + .itemOutputs(ItemRefer.YOTTank_Cell_T8.get(1)) + .eut(TierEU.RECIPE_UIV) + .duration(50 * SECONDS) + .addTo(AssemblyLine); + + if (NewHorizonsCoreMod.isModLoaded()) { + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T8.get(1)) + .metadata(RESEARCH_TIME, 18 * HOURS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 2), + ItemRefer.Fluid_Storage_Core_T9.get(2), + new Object[] { OrePrefixes.circuit.get(Materials.Piko), 8L }, + ItemList.Electric_Pump_UIV.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.NetherStar, 12), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.CosmicNeutronium, 12), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.DraconiumAwakened, 12), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Infinity, 64)) + .fluidInputs( + Materials.DraconiumAwakened.getMolten(14400), + FluidRegistry.getFluidStack("supercoolant", 46080), + Materials.Lubricant.getFluid(46080)) + .itemOutputs(ItemRefer.YOTTank_Cell_T9.get(1)) + .eut(TierEU.RECIPE_UMV) + .duration(50 * SECONDS) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.YOTTank_Cell_T9.get(1)) + .metadata(RESEARCH_TIME, 36 * HOURS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 2), + ItemRefer.Fluid_Storage_Core_T10.get(2), + new Object[] { OrePrefixes.circuit.get(Materials.Quantum), 12L }, + ItemList.Electric_Pump_UMV.get(8), + GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.NetherStar, 64), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.CosmicNeutronium, 12), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.DraconiumAwakened, 12), + GT_OreDictUnificator.get(OrePrefixes.plate, MaterialsUEVplus.SpaceTime, 10)) + .fluidInputs( + Materials.DraconiumAwakened.getMolten(14400), + MaterialsUEVplus.TranscendentMetal.getMolten(1440), + FluidRegistry.getFluidStack("supercoolant", 46080), + Materials.Lubricant.getFluid(46080)) + .itemOutputs(ItemRefer.YOTTank_Cell_T10.get(1)) + .eut(TierEU.RECIPE_UXV) + .duration(50 * SECONDS) + .addTo(AssemblyLine); + } + + // Craft 2x64X Tier to 1X+1 Tier + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fluid_Storage_Core_T6.get(64), + ItemRefer.Fluid_Storage_Core_T6.get(64), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T7.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fluid_Storage_Core_T7.get(64), + ItemRefer.Fluid_Storage_Core_T7.get(64), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T8.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fluid_Storage_Core_T8.get(64), + ItemRefer.Fluid_Storage_Core_T8.get(64), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T9.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fluid_Storage_Core_T9.get(64), + ItemRefer.Fluid_Storage_Core_T9.get(64), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemRefer.Fluid_Storage_Core_T10.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.YOTTank_Cell_T1.get(1)) + .itemOutputs( + ItemRefer.Fluid_Storage_Core_T1.get(10), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.BlackSteel, 1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.YOTTank_Cell_T2.get(1)) + .itemOutputs( + ItemRefer.Fluid_Storage_Core_T2.get(10), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.TungstenSteel, 1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.YOTTank_Cell_T3.get(1)) + .itemOutputs( + ItemRefer.Fluid_Storage_Core_T3.get(10), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Naquadah, 1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.YOTTank_Cell_T4.get(1)) + .itemOutputs( + ItemRefer.Fluid_Storage_Core_T4.get(10), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Neutronium, 1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.YOTTank_Cell_T5.get(1)) + .itemOutputs( + ItemRefer.Fluid_Storage_Core_T5.get(10), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.YOTTank_Cell_T6.get(1)) + .itemOutputs( + ItemRefer.Fluid_Storage_Core_T6.get(2), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.YOTTank_Cell_T7.get(1)) + .itemOutputs( + ItemRefer.Fluid_Storage_Core_T7.get(2), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.YOTTank_Cell_T8.get(1)) + .itemOutputs( + ItemRefer.Fluid_Storage_Core_T8.get(2), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.YOTTank_Cell_T9.get(1)) + .itemOutputs( + ItemRefer.Fluid_Storage_Core_T9.get(2), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.YOTTank_Cell_T10.get(1)) + .itemOutputs( + ItemRefer.Fluid_Storage_Core_T10.get(2), + GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(WerkstoffLoader.Tiberium.get(OrePrefixes.dust, 1)) + .itemOutputs( + WerkstoffLoader.Tiberium.get(OrePrefixes.gem, 1), + WerkstoffLoader.Tiberium.get(OrePrefixes.gem, 1)) + .outputChances(10000, 2000) + .fluidInputs(MyMaterial.naquadahGas.getFluidOrGas(250)) + .duration(400) + .eut(TierEU.RECIPE_HV) + .addTo(autoclaveRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Firestone.getGems(1)) + .fluidInputs(MyMaterial.lightNaquadahFuel.getFluidOrGas(144)) + .itemOutputs(WerkstoffLoader.Tiberium.get(OrePrefixes.gem, 1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(chemicalBathRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Diamond.getGems(1)) + .fluidInputs(MyMaterial.heavyNaquadahFuel.getFluidOrGas(144)) + .itemOutputs(WerkstoffLoader.Tiberium.get(OrePrefixes.gem, 1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(chemicalBathRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.HeavyFuel.getFluid(1000)) + .fluidOutputs( + Materials.Toluene.getFluid(400), + Materials.Benzene.getFluid(400), + Materials.Phenol.getFluid(250)) + .duration(6 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(distillationTowerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Coal.getGems(1)) + .itemOutputs(Materials.Ash.getDust(1)) + .outputChances(10) + .fluidOutputs(FluidRegistry.getFluidStack("fluid.coaltar", 250)) + .duration(3 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(fluidExtractionRecipes); + + if (OreDictionary.getOres("fuelCoke") + .size() > 0) { + GT_Values.RA.stdBuilder() + .itemInputs( + OreDictionary.getOres("fuelCoke") + .get(0)) + .itemOutputs(Materials.Ash.getDust(1)) + .outputChances(10) + .fluidOutputs(FluidRegistry.getFluidStack("fluid.coaltar", 250)) + .duration(3 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(fluidExtractionRecipes); + } + + if (GTPlusPlus.isModLoaded()) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(24)) + .fluidInputs(FluidRegistry.getFluidStack("fluid.coaltaroil", 100)) + .fluidOutputs(MyMaterial.cyclopentadiene.getFluidOrGas(30)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(distilleryRecipes); + } + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(24)) + .fluidInputs(Materials.WoodTar.getFluid(500)) + .fluidOutputs(MyMaterial.cyclopentadiene.getFluidOrGas(20)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(distilleryRecipes); + + // FeCl2 + Cl = FeCl3 + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.ferrousChloride.get(OrePrefixes.cell, 1), GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Chlorine.getGas(1000)) + .itemOutputs(Materials.IronIIIChloride.getCells(1)) + .duration(2 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + // FeCl3 + H = FeCl2 + HCl + GT_Values.RA.stdBuilder() + .itemInputs(Materials.IronIIIChloride.getCells(1), GT_Utility.getIntegratedCircuit(7)) + .fluidInputs(Materials.Hydrogen.getGas(1000)) + .fluidOutputs(Materials.HydrochloricAcid.getFluid(1000)) + .itemOutputs(MyMaterial.ferrousChloride.get(OrePrefixes.cell, 1)) + .duration(4 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(UniversalChemical); + + // NH3 + 2C2H6O = C4H11N + 2H2O + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Ammonia.getCells(1), GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Ethanol.getFluid(2000)) + .fluidOutputs(Materials.Water.getFluid(2000)) + .itemOutputs(MyMaterial.diethylamine.get(OrePrefixes.cell, 1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(UniversalChemical); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(2)) + .fluidInputs( + MyMaterial.cyclopentadiene.getFluidOrGas(2000), + MyMaterial.ferrousChloride.getFluidOrGas(1000), + MyMaterial.diethylamine.getFluidOrGas(8000), + Materials.Ice.getSolid(4000)) + .fluidOutputs(MyMaterial.impureFerroceneMixture.getFluidOrGas(15000)) + .duration(2 * MINUTES) + .eut(TierEU.RECIPE_MV) + .addTo(multiblockChemicalReactorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.ether.get(OrePrefixes.cell, 1), GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(MyMaterial.impureFerroceneMixture.getFluidOrGas(7500)) + .itemOutputs(MyMaterial.ferroceneSolution.get(OrePrefixes.cell, 1)) + .fluidOutputs(MyMaterial.ferroceneWaste.getFluidOrGas(5000)) + .duration(40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(mixerRecipes); + + CrackRecipeAdder.addUniversalDistillationRecipe( + MyMaterial.ferroceneWaste.getFluidOrGas(1000), + new FluidStack[] { Materials.Water.getFluid(400), MyMaterial.diethylamine.getFluidOrGas(800), + MyMaterial.ether.getFluidOrGas(500) }, + GT_Values.NI, + 30 * SECONDS, + TierEU.RECIPE_MV); + + CrackRecipeAdder.addUniversalDistillationRecipe( + MyMaterial.ferroceneSolution.getFluidOrGas(2000), + new FluidStack[] { MyMaterial.ether.getFluidOrGas(1000) }, + MyMaterial.ferrocene.get(OrePrefixes.dust, 1), + 30 * SECONDS, + TierEU.RECIPE_MV); + + if (GTPlusPlus.isModLoaded()) { + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.ferrocene.get(OrePrefixes.dust, 4), Materials.SodiumHydroxide.getDust(8)) + .fluidInputs( + FluidRegistry.getFluidStack("fluid.kerosene", 40000), + Materials.Naphtha.getFluid(3000), + MyMaterial.diethylamine.getFluidOrGas(1000)) + .fluidOutputs(MyMaterial.ironedKerosene.getFluidOrGas(44000)) + .duration(2 * MINUTES) + .eut(TierEU.RECIPE_EV) + .addTo(multiblockChemicalReactorRecipes); + } + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.ferrocene.get(OrePrefixes.dust, 4)) + .fluidInputs( + FluidRegistry.getFluidStack("combustionpromotor", 4000), + Materials.Naphtha.getFluid(40000), + Materials.LightFuel.getFluid(3000), + Materials.LPG.getFluid(1000), + Materials.Tetranitromethane.getFluid(2000)) + .fluidOutputs(MyMaterial.ironedFuel.getFluidOrGas(50000)) + .duration(2 * MINUTES) + .eut(TierEU.RECIPE_IV) + .addTo(multiblockChemicalReactorRecipes); + + GT_ModHandler.addCraftingRecipe( + ItemRefer.Combustion_Generator_EV.get(1), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "PCP", "MHM", "GWG", 'G', + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Titanium, 1), 'C', "circuitData", 'W', + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Aluminium, 1), 'P', + ItemList.Electric_Piston_EV, 'H', ItemList.Hull_EV, 'M', ItemList.Electric_Motor_EV }); + + GT_ModHandler.addCraftingRecipe( + ItemRefer.Combustion_Generator_IV.get(1), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "PCP", "MHM", "GWG", 'G', + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.TungstenSteel, 1), 'C', "circuitElite", 'W', + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Tungsten, 1), 'P', + ItemList.Electric_Piston_IV, 'H', ItemList.Hull_IV, 'M', ItemList.Electric_Motor_IV }); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Advanced_Fuel_Rod.get(1)) + .fluidInputs(MyMaterial.uraniumBasedLiquidFuelExcited.getFluidOrGas(250)) + .itemOutputs(ItemRefer.Fuel_Rod_LU_1.get(1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(fluidCannerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Advanced_Fuel_Rod.get(1)) + .fluidInputs(MyMaterial.plutoniumBasedLiquidFuelExcited.getFluidOrGas(250)) + .itemOutputs(ItemRefer.Fuel_Rod_LPu_1.get(1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(fluidCannerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_LPu_1.get(2), + MyMaterial.zircaloy2.get(OrePrefixes.stick, 4), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemRefer.Fuel_Rod_LPu_2.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_LPu_2.get(2), + MyMaterial.zircaloy2.get(OrePrefixes.stick, 4), + GT_Utility.getIntegratedCircuit(5)) + .itemOutputs(ItemRefer.Fuel_Rod_LPu_4.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_LPu_1.get(4), + MyMaterial.zircaloy2.get(OrePrefixes.stickLong, 6), + GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(ItemRefer.Fuel_Rod_LPu_4.get(1)) + .duration(11 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_LU_1.get(2), + MyMaterial.zircaloy2.get(OrePrefixes.stick, 4), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemRefer.Fuel_Rod_LU_2.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_LU_2.get(2), + MyMaterial.zircaloy2.get(OrePrefixes.stick, 4), + GT_Utility.getIntegratedCircuit(5)) + .itemOutputs(ItemRefer.Fuel_Rod_LU_4.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemRefer.Fuel_Rod_LU_1.get(4), + MyMaterial.zircaloy2.get(OrePrefixes.stickLong, 6), + GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(ItemRefer.Fuel_Rod_LU_4.get(1)) + .duration(11 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + MyRecipeAdder.instance.addExtremeHeatExchangerRecipe( + FluidRegistry.getFluidStack("lava", 20000), + FluidRegistry.getFluidStack("ic2pahoehoelava", 20000), + FluidRegistry.getFluidStack("ic2distilledwater", 20000), + FluidRegistry.getFluidStack("steam", 3200000), + FluidRegistry.getFluidStack("ic2superheatedsteam", 1600000), + 10000); + + MyRecipeAdder.instance.addExtremeHeatExchangerRecipe( + FluidRegistry.getFluidStack("ic2hotcoolant", 16000), + FluidRegistry.getFluidStack("ic2coolant", 16000), + FluidRegistry.getFluidStack("ic2distilledwater", 20000), + FluidRegistry.getFluidStack("ic2superheatedsteam", 3200000), + FluidRegistry.getFluidStack("supercriticalsteam", 32000), + 8000); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushedPurified, Materials.Lepidolite, 1)) + .fluidInputs(Materials.HydrochloricAcid.getFluid(1000)) + .itemOutputs( + Materials.RockSalt.getDust(1), + MyMaterial.lithiumChloride.get(OrePrefixes.dust, 3), + Materials.Cryolite.getDust(4)) + .outputChances(8000, 8000, 8000) + .duration(7 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(chemicalBathRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(MyMaterial.marM200.get(OrePrefixes.ingot, 18), Materials.Cerium.getIngots(1)) + .fluidInputs(MyMaterial.lithiumChloride.getMolten(144)) + .itemOutputs(MyMaterial.marCeM200.get(OrePrefixes.ingotHot, 19)) + .duration(4 * MINUTES + 45 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .metadata(COIL_HEAT, 4500) + .addTo(blastFurnaceRecipes); + + GT_ModHandler.addCraftingRecipe( + ItemRefer.SC_Turbine_Casing.get(1), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "PhP", "GCG", "PwP", 'G', MyMaterial.marM200.get(OrePrefixes.gearGt, 1), 'C', + ItemList.Casing_Turbine.get(1), 'P', MyMaterial.marCeM200.get(OrePrefixes.plate, 1), }); + + GT_Values.RA.stdBuilder() + .itemInputs( + MyMaterial.marM200.get(OrePrefixes.gearGt, 2), + MyMaterial.marCeM200.get(OrePrefixes.plate, 4), + ItemList.Casing_Turbine.get(1)) + .itemOutputs(ItemRefer.SC_Turbine_Casing.get(1)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_ModHandler.addCraftingRecipe( + ItemRefer.SC_Fluid_Turbine.get(1), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "NPN", "GHG", "IPI", 'N', "circuitMaster", 'P', MyMaterial.marM200.get(OrePrefixes.plate, 1), + 'H', ItemList.Hull_IV.get(1), 'G', MyMaterial.marCeM200.get(OrePrefixes.gearGt, 1), 'I', + MyMaterial.incoloy903.get(OrePrefixes.pipeLarge, 1) }); + + GT_Values.RA.stdBuilder() + .itemInputs( + MyMaterial.marM200.get(OrePrefixes.plate, 2), + MyMaterial.marCeM200.get(OrePrefixes.gearGt, 2), + MyMaterial.incoloy903.get(OrePrefixes.pipeLarge, 2), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Master, 2), + ItemList.Hull_IV.get(1)) + .itemOutputs(ItemRefer.SC_Fluid_Turbine.get(1)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + MyMaterial.incoloy903.get(OrePrefixes.plate, 4), + MyMaterial.marCeM200.get(OrePrefixes.plate, 4), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.NiobiumTitanium, 1), + GT_Utility.getIntegratedCircuit(8)) + .itemOutputs(ItemRefer.Pressure_Resistant_Wall.get(1)) + .duration(50 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_ModHandler.addCraftingRecipe( + ItemRefer.Extreme_Heat_Exchanger.get(1), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "EPE", "PHP", "SPS", 'P', + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.TungstenSteel, 1), 'H', + ItemList.Hull_IV.get(1), 'S', MyMaterial.marM200.get(OrePrefixes.plate, 1), 'E', + GT_ModHandler.getIC2Item("reactorHeatSwitchDiamond", 1L, 1) }); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Salty_Root.get(1)) + .fluidInputs(GT_ModHandler.getWater(100)) + .itemOutputs(Materials.Salt.getDust(1), Materials.RockSalt.getDust(1), Materials.Saltpeter.getDust(1)) + .outputChances(9500, 8000, 5000) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(chemicalBathRecipes); + + if (NewHorizonsCoreMod.isModLoaded()) { + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Robot_Arm_IV.get(4), + ItemRefer.HiC_T1.get(4), + ItemList.Tool_DataOrb.get(3), + GT_OreDictUnificator.get(OrePrefixes.cableGt08, Materials.Titanium, 4), + MyMaterial.hikarium.get(OrePrefixes.gearGt, 4), + MyMaterial.marM200.get(OrePrefixes.plateDouble, 2), + ItemRefer.IC2_Ir_Plate.get(2), + MyMaterial.lumiium.get(OrePrefixes.bolt, 48)) + .fluidInputs(Materials.Palladium.getMolten(1152)) + .itemOutputs(ItemRefer.Precise_Assembler.get(1)) + .duration(1 * MINUTES + 30 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Casing_ZPM.get(3), + ItemList.Robot_Arm_EV.get(2), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, MyMaterial.lumiium.getBridgeMaterial(), 2), + MyMaterial.marCeM200.get(OrePrefixes.plateDouble, 2), + ItemRefer.HiC_T1.get(1), + MyMaterial.signalium.get(OrePrefixes.bolt, 32), + MyMaterial.titaniumBetaC.get(OrePrefixes.gearGtSmall, 8)) + .fluidInputs(Materials.BlackSteel.getMolten(576)) + .itemOutputs(ItemRefer.Precise_Electronic_Unit_T1.get(2)) + .duration(40 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemRefer.HiC_T1.get(2), + GT_ModHandler.getModItem("dreamcraft", "item.EngravedDiamondCrystalChip", 8), + ItemList.Circuit_Chip_NAND.get(16), GT_ModHandler.getIC2Item("reactorVentCore", 1L, 1) }, + new FluidStack[] { Materials.Plastic.getMolten(288), MyMaterial.signalium.getMolten(144), + MyMaterial.lumiium.getMolten(72), Materials.Enderium.getMolten(72) }, + ItemRefer.HiC_T2.get(1), + 30720, + 100, + 1); + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemRefer.HiC_T1.get(2), + GT_ModHandler.getModItem("dreamcraft", "item.EngravedDiamondCrystalChip", 8), + ItemList.Circuit_Chip_NAND.get(16), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Aluminium, 2) }, + new FluidStack[] { Materials.Plastic.getMolten(288), MyMaterial.signalium.getMolten(144), + MyMaterial.lumiium.getMolten(72), Materials.Enderium.getMolten(72) }, + ItemRefer.HiC_T2.get(1), + 30720, + 100, + 1); + + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemRefer.HiC_T2.get(2), ItemList.Circuit_Parts_Crystal_Chip_Master.get(8), + ItemList.Circuit_Chip_CrystalSoC2.get(1), GT_ModHandler.getIC2Item("reactorVentDiamond", 1L, 1) }, + new FluidStack[] { MyMaterial.adamantiumAlloy.getMolten(576), MyMaterial.signalium.getMolten(288), + MyMaterial.lumiium.getMolten(144), Materials.TungstenCarbide.getMolten(72) }, + ItemRefer.HiC_T3.get(1), + 122880, + 100, + 2); + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemRefer.HiC_T2.get(2), ItemList.Circuit_Parts_Crystal_Chip_Master.get(8), + ItemList.Circuit_Chip_CrystalSoC2.get(1), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.StainlessSteel, 2) }, + new FluidStack[] { MyMaterial.adamantiumAlloy.getMolten(576), MyMaterial.signalium.getMolten(288), + MyMaterial.lumiium.getMolten(144), Materials.TungstenCarbide.getMolten(72) }, + ItemRefer.HiC_T3.get(1), + 122880, + 100, + 2); + + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemRefer.HiC_T3.get(2), + GT_ModHandler.getModItem("dreamcraft", "item.EngravedEnergyChip", 8), + ItemList.Circuit_Chip_QuantumCPU.get(16), GT_ModHandler.getIC2Item("reactorVentGold", 1L, 1) }, + new FluidStack[] { MyMaterial.marM200.getMolten(1152), MyMaterial.signalium.getMolten(576), + MyMaterial.lumiium.getMolten(288), MyMaterial.artheriumSn.getMolten(144) }, + ItemRefer.HiC_T4.get(1), + 491520, + 100, + 3); + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemRefer.HiC_T3.get(2), + GT_ModHandler.getModItem("dreamcraft", "item.EngravedEnergyChip", 8), + ItemList.Circuit_Chip_QuantumCPU.get(16), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.EnergeticAlloy, 2) }, + new FluidStack[] { MyMaterial.marM200.getMolten(1152), MyMaterial.signalium.getMolten(576), + MyMaterial.lumiium.getMolten(288), MyMaterial.artheriumSn.getMolten(144) }, + ItemRefer.HiC_T4.get(1), + 491520, + 100, + 3); + + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemRefer.HiC_T4.get(2), + GT_ModHandler.getModItem("dreamcraft", "item.EngravedManyullynCrystalChip", 8), + ItemList.Circuit_Chip_BioCPU.get(1), Ic2Items.reactorVentSpread }, + new FluidStack[] { MyMaterial.titaniumBetaC.getMolten(1728), MyMaterial.signalium.getMolten(1152), + MyMaterial.lumiium.getMolten(576), MyMaterial.dalisenite.getMolten(288) }, + ItemRefer.HiC_T5.get(1), + 1966080, + 100, + 3); + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemRefer.HiC_T4.get(2), + GT_ModHandler.getModItem("dreamcraft", "item.EngravedManyullynCrystalChip", 8), + ItemList.Circuit_Chip_BioCPU.get(1), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.TungstenCarbide, 2) }, + new FluidStack[] { MyMaterial.titaniumBetaC.getMolten(1728), MyMaterial.signalium.getMolten(1152), + MyMaterial.lumiium.getMolten(576), MyMaterial.dalisenite.getMolten(288) }, + ItemRefer.HiC_T5.get(1), + 1966080, + 100, + 3); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Casing_UV.get(3), + ItemList.Robot_Arm_LuV.get(2), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.ElectrumFlux, 4), + ItemRefer.HiC_T2.get(1), + ItemRefer.Precise_Electronic_Unit_T1.get(1), + MyMaterial.marCeM200.get(OrePrefixes.bolt, 32), + MyMaterial.artheriumSn.get(OrePrefixes.gearGtSmall, 8)) + .fluidInputs(MyMaterial.adamantiumAlloy.getMolten(1152)) + .itemOutputs(ItemRefer.Precise_Electronic_Unit_T2.get(4)) + .duration(4 * MINUTES) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Casing_MAX.get(3), + ItemList.Field_Generator_ZPM.get(2), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Bedrockium, 4), + ItemRefer.HiC_T3.get(1), + ItemRefer.Precise_Electronic_Unit_T2.get(1), + MyMaterial.titaniumBetaC.get(OrePrefixes.bolt, 32), + MyMaterial.dalisenite.get(OrePrefixes.gearGtSmall, 8)) + .fluidInputs(MyMaterial.artheriumSn.getMolten(1152)) + .itemOutputs(ItemRefer.Precise_Electronic_Unit_T3.get(4)) + .duration(4 * MINUTES) + .eut(TierEU.RECIPE_UV) + .addTo(assemblerRecipes); + } + + // Compact MK1 Fusion Coil + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemList.Casing_Coil_Superconductor.get(3), ItemRefer.HiC_T2.get(1), + ItemRefer.Special_Ceramics_Plate.get(2) }, + new FluidStack[] { MyMaterial.marM200.getMolten(1152), MyMaterial.zircaloy4.getMolten(288) }, + ItemRefer.Compact_Fusion_Coil_T0.get(1), + 9001, + 1200, + 1); + + // Compact MK2 Fusion Coil + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemList.Casing_Fusion_Coil.get(3), ItemRefer.Quartz_Crystal_Resonator.get(2), + ItemRefer.HiC_T3.get(1), }, + new FluidStack[] { MyMaterial.artheriumSn.getMolten(576), MyMaterial.titaniumBetaC.getMolten(144) }, + ItemRefer.Compact_Fusion_Coil_T1.get(1), + 14000, + 800, + 2); + + // Compact MK3 Fusion Coil + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { ItemList.Casing_Fusion_Coil.get(3), ItemRefer.Radiation_Protection_Plate.get(2), + ItemList.QuantumStar.get(4), ItemRefer.HiC_T4.get(1) }, + new FluidStack[] { MyMaterial.dalisenite.getMolten(576), MyMaterial.hikarium.getMolten(144) }, + ItemRefer.Compact_Fusion_Coil_T2.get(1), + 114514, + 800, + 3); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.FusionComputer_LuV.get(48), + ItemRefer.HiC_T1.get(8), + MyMaterial.marCeM200.get(OrePrefixes.plate, 32), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Master, 8), + ItemList.Circuit_Wafer_HPIC.get(16), + ItemList.Field_Generator_LuV.get(4), + MyMaterial.marM200.get(OrePrefixes.stickLong, 8)) + .fluidInputs(MyMaterial.adamantiumAlloy.getMolten(9216)) + .itemOutputs(ItemRefer.Compact_Fusion_MK1.get(1)) + .duration(1 * MINUTES) + .eut(TierEU.RECIPE_LuV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Compact_Fusion_MK1.get(1)) + .metadata(RESEARCH_TIME, 20 * MINUTES) + .itemInputs( + ItemList.FusionComputer_ZPMV.get(48), + new Object[] { "circuitUltimate", 1 }, + new Object[] { "circuitUltimate", 1 }, + new Object[] { "circuitUltimate", 1 }, + new Object[] { "circuitUltimate", 1 }, + ItemList.Circuit_Wafer_UHPIC.get(32), + ItemList.ZPM_Coil.get(16), + ItemList.Neutron_Reflector.get(4), + ItemRefer.HiC_T2.get(8), + ItemList.Field_Generator_ZPM.get(8), + MyMaterial.artheriumSn.get(OrePrefixes.gearGtSmall, 32)) + .fluidInputs( + MyMaterial.marCeM200.getMolten(2304), + WerkstoffLoader.HDCS.getMolten(1152), + MyMaterial.artheriumSn.getMolten(288)) + .itemOutputs(ItemRefer.Compact_Fusion_MK2.get(1)) + .eut(TierEU.RECIPE_ZPM / 2) + .duration(5 * MINUTES) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, ItemRefer.Compact_Fusion_MK2.get(1)) + .metadata(RESEARCH_TIME, 20 * MINUTES) + .itemInputs( + ItemList.FusionComputer_UV.get(48), + new Object[] { "circuitSuperconductor", 1 }, + new Object[] { "circuitSuperconductor", 1 }, + new Object[] { "circuitSuperconductor", 1 }, + new Object[] { "circuitSuperconductor", 1 }, + ItemList.Circuit_Wafer_NPIC.get(64), + ItemList.UV_Coil.get(16), + ItemRefer.Advanced_Radiation_Protection_Plate.get(8), + ItemRefer.HiC_T3.get(8), + ItemList.Field_Generator_UV.get(8), + WerkstoffLoader.HDCS.get(OrePrefixes.gearGtSmall, 64)) + .fluidInputs( + MyMaterial.titaniumBetaC.getMolten(2304), + MyMaterial.dalisenite.getMolten(1152), + Materials.Americium.getMolten(288)) + .itemOutputs(ItemRefer.Compact_Fusion_MK3.get(1)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * MINUTES) + .addTo(AssemblyLine); + + // Compact MK4 Fusion Coil + if (GTPlusPlus.isModLoaded()) { + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { GT_ModHandler.getModItem("miscutils", "gtplusplus.blockcasings.3", 3, 13), + ItemRefer.HiC_T5.get(1), GT_ModHandler.getModItem("miscutils", "item.itemBufferCore4", 1), }, + new FluidStack[] { FluidRegistry.getFluidStack("molten.energycrystal", 1152), + FluidRegistry.getFluidStack("molten.laurenium", 144) }, + ItemRefer.Compact_Fusion_Coil_T3.get(1), + 520000, + 2000, + 3); + + // Compact MK4 Fusion Disassembly Recipe + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Compact_Fusion_Coil_T3.get(1)) + .itemOutputs(GregtechItemList.Casing_Fusion_Internal.get(3)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_UEV) + .addTo(assemblerRecipes); + + TT_recipeAdder.addResearchableAssemblylineRecipe( + ItemRefer.Compact_Fusion_MK3.get(1), + 2_560_000, + 4_096, + (int) TierEU.RECIPE_UHV, + 256, + new Object[] { GregtechItemList.FusionComputer_UV2.get(48), new Object[] { "circuitInfinite", 1 }, + new Object[] { "circuitInfinite", 1 }, new Object[] { "circuitInfinite", 1 }, + new Object[] { "circuitInfinite", 1 }, ItemList.Circuit_Wafer_PPIC.get(64), + ItemList.UHV_Coil.get(16), ALLOY.TITANSTEEL.getPlateDense(8), ItemRefer.HiC_T4.get(8), + ItemList.Field_Generator_UHV.get(8), + MyMaterial.enrichedNaquadahAlloy.get(OrePrefixes.gearGtSmall, 64) }, + new FluidStack[] { GenericChem.TEFLON.getFluidStack(2304), MyMaterial.dalisenite.getMolten(1152), + ALLOY.BOTMIUM.getFluidStack(288) }, + ItemRefer.Compact_Fusion_MK4.get(1), + 6000, + (int) TierEU.RECIPE_UV); + + // Compact MK5 Fusion Coil + MyRecipeAdder.instance.addPreciseAssemblerRecipe( + new ItemStack[] { GregtechItemList.Casing_Fusion_Internal2.get(3), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Bio, 1), ItemRefer.HiC_T5.get(4), + CI.getEnergyCore(5, 1), }, + new FluidStack[] { ALLOY.BLACK_TITANIUM.getFluidStack(1152), + MyMaterial.metastableOganesson.getMolten(576) }, + ItemRefer.Compact_Fusion_Coil_T4.get(1), + (int) TierEU.RECIPE_UHV, + 2000, + 3); + + // Compact MK5 Computer + TT_recipeAdder.addResearchableAssemblylineRecipe( + ItemRefer.Compact_Fusion_MK4.get(1), + 10_240_000, + 16_384, + (int) TierEU.RECIPE_UEV, + 256, + new Object[] { GregtechItemList.FusionComputer_UV3.get(48), new Object[] { "circuitBio", 1 }, + new Object[] { "circuitBio", 1 }, new Object[] { "circuitBio", 1 }, + new Object[] { "circuitBio", 1 }, ItemList.Circuit_Wafer_QPIC.get(64), ItemList.UHV_Coil.get(64), + ELEMENT.STANDALONE.HYPOGEN.getPlateDense(8), ItemRefer.HiC_T5.get(8), + ItemList.Field_Generator_UEV.get(8), + MyMaterial.metastableOganesson.get(OrePrefixes.gearGtSmall, 64) }, + new FluidStack[] { MyMaterial.tairitsu.getMolten(2304), ALLOY.OCTIRON.getFluidStack(1152), + ELEMENT.STANDALONE.RHUGNOR.getFluidStack(288) }, + ItemRefer.Compact_Fusion_MK5.get(1), + 6000, + (int) TierEU.RECIPE_UHV); + + // Compact MK5 Fusion Disassembly Recipe + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Compact_Fusion_Coil_T4.get(1)) + .itemOutputs(GregtechItemList.Casing_Fusion_Internal2.get(3)) + .duration(1 * MINUTES) + .eut(TierEU.RECIPE_UIV) + .addTo(assemblerRecipes); + } + + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Antimony.getDust(8), GT_Utility.getIntegratedCircuit(24)) + .fluidInputs( + MyMaterial.ether.getFluidOrGas(1000), + Materials.Fluorine.getGas(40000), + Materials.Ice.getSolid(8000)) + .fluidOutputs(MyMaterial.antimonyPentafluorideSolution.getFluidOrGas(8000)) + .duration(40 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(multiblockChemicalReactorRecipes); + + CrackRecipeAdder.addUniversalDistillationRecipe( + MyMaterial.antimonyPentafluorideSolution.getFluidOrGas(4000), + new FluidStack[] { MyMaterial.antimonyPentafluoride.getFluidOrGas(4000), + MyMaterial.ether.getFluidOrGas(500) }, + GT_Values.NI, + 5 * SECONDS, + TierEU.RECIPE_MV); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.pipeHuge, Materials.Plastic, 2), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Steel, 1), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Concrete.getMolten(2304)) + .itemOutputs(ItemRefer.Coolant_Tower.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + } + + public static void InitLoadRecipe() { + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_U_Depleted_1.get(1)) + .itemOutputs( + ItemRefer.Advanced_Fuel_Rod.get(1), + Materials.Uranium.getDust(8), + Materials.Plutonium.getDust(2), + Materials.Graphite.getDust(8), + Materials.Uranium235.getDust(1), + Materials.Plutonium241.getDust(1)) + .outputChances(10000, 10000, 10000, 9000, 5000, 3000) + .fluidOutputs(WerkstoffLoader.Neon.getFluidOrGas(32)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_U_Depleted_2.get(1)) + .itemOutputs( + ItemRefer.Advanced_Fuel_Rod.get(2), + Materials.Uranium.getDust(16), + Materials.Plutonium.getDust(4), + Materials.Graphite.getDust(16), + Materials.Uranium235.getDust(2), + Materials.Plutonium241.getDust(2)) + .outputChances(10000, 10000, 10000, 9000, 5000, 3000) + .fluidOutputs(WerkstoffLoader.Neon.getFluidOrGas(64)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_U_Depleted_4.get(1)) + .itemOutputs( + ItemRefer.Advanced_Fuel_Rod.get(4), + Materials.Uranium.getDust(32), + Materials.Plutonium.getDust(8), + Materials.Graphite.getDust(32), + Materials.Uranium235.getDust(4), + Materials.Plutonium241.getDust(4)) + .outputChances(10000, 10000, 10000, 9000, 5000, 3000) + .fluidOutputs(WerkstoffLoader.Neon.getFluidOrGas(128)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_Pu_Depleted_1.get(1)) + .itemOutputs( + ItemRefer.Advanced_Fuel_Rod.get(1), + Materials.Plutonium.getDust(5), + Materials.Plutonium241.getDust(2), + Materials.Carbon.getDust(2), + Materials.Uranium.getDust(1), + Materials.Uranium235.getDust(1)) + .outputChances(10000, 10000, 10000, 9000, 5000, 3000) + .fluidOutputs(Materials.Argon.getGas(32)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_Pu_Depleted_2.get(1)) + .itemOutputs( + ItemRefer.Advanced_Fuel_Rod.get(2), + Materials.Plutonium.getDust(10), + Materials.Plutonium241.getDust(4), + Materials.Carbon.getDust(4), + Materials.Uranium.getDust(2), + Materials.Uranium235.getDust(2)) + .outputChances(10000, 10000, 10000, 9000, 5000, 3000) + .fluidOutputs(Materials.Argon.getGas(64)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_Pu_Depleted_4.get(1)) + .itemOutputs( + ItemRefer.Advanced_Fuel_Rod.get(4), + Materials.Plutonium.getDust(20), + Materials.Plutonium241.getDust(8), + Materials.Carbon.getDust(8), + Materials.Uranium.getDust(4), + Materials.Uranium235.getDust(4)) + .outputChances(10000, 10000, 10000, 9000, 5000, 3000) + .fluidOutputs(Materials.Argon.getGas(128)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_LPu_Depleted_1.get(1)) + .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(1)) + .fluidOutputs(MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(250)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_LPu_Depleted_2.get(1)) + .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(2)) + .fluidOutputs(MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(500)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_LPu_Depleted_4.get(1)) + .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(4)) + .fluidOutputs(MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(1000)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_LU_Depleted_1.get(1)) + .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(1)) + .fluidOutputs(MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(250)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_LU_Depleted_2.get(1)) + .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(2)) + .fluidOutputs(MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(500)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.Fuel_Rod_LU_Depleted_4.get(1)) + .itemOutputs(ItemRefer.Advanced_Fuel_Rod.get(4)) + .fluidOutputs(MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(1000)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + Materials.Glowstone.getDust(4), + Materials.Redstone.getDust(2), + Materials.Aluminium.getDust(1), + GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(ItemRefer.High_Energy_Mixture.get(4)) + .duration(12 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.High_Energy_Mixture.get(2)) + .fluidInputs(Materials.PhosphoricAcid.getFluid(4000)) + .itemOutputs(MyMaterial.lumiinessence.get(OrePrefixes.dust, 1)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_HV / 2) + .addTo(fluidSolidifierRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + Materials.AnnealedCopper.getDust(4), + Materials.Ardite.getDust(2), + Materials.RedAlloy.getDust(2), + GT_Utility.getIntegratedCircuit(4)) + .fluidInputs(Materials.Redstone.getMolten(288)) + .itemOutputs(MyMaterial.signalium.get(OrePrefixes.dust, 1)) + .duration(12 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + Materials.TinAlloy.getDust(4), + Materials.SterlingSilver.getDust(2), + MyMaterial.lumiinessence.get(OrePrefixes.dust, 2), + GT_Utility.getIntegratedCircuit(4)) + .fluidInputs(Materials.Glowstone.getMolten(288)) + .itemOutputs(MyMaterial.lumiium.get(OrePrefixes.dust, 1)) + .duration(12 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs(MyMaterial.enrichedNaquadahAlloy.getMolten(144), WerkstoffLoader.Oganesson.getFluidOrGas(250)) + .fluidOutputs(MyMaterial.metastableOganesson.getMolten(36)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_UV) + .metadata(FUSION_THRESHOLD, 1000000000) + .addTo(fusionRecipes); + + MyRecipeAdder.instance.addNeutronActivatorRecipe( + null, + new ItemStack[] { MyMaterial.metastableOganesson.get(OrePrefixes.dust) }, + new FluidStack[] { WerkstoffLoader.Oganesson.getFluidOrGas(250) }, + null, + 2000, + 1100, + 1000); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemRefer.HiC_T5.get(0)) + .fluidInputs( + MyMaterial.metastableOganesson.getMolten(1152), + MyMaterial.preciousMetalAlloy.getMolten(2304), + MaterialsUEVplus.SpaceTime.getMolten(288), + MaterialsUEVplus.DimensionallyTranscendentResidue.getFluid(5000)) + .fluidOutputs(MyMaterial.shirabon.getMolten(144)) + .duration(10 * SECONDS) + .eut(1500000000) + .metadata(COIL_HEAT, 13500) + .addTo(plasmaForgeRecipes); + } + + public static void FinishLoadRecipe() { + for (GT_Recipe plasmaFuel : RecipeMaps.plasmaFuels.getAllRecipes()) { + FluidStack tPlasma = GT_Utility.getFluidForFilledItem(plasmaFuel.mInputs[0], true); + if (tPlasma == null) { + continue; + } + int tUnit = plasmaFuel.mSpecialValue; + if (tUnit > 200_000) { + tPlasma.amount = 1500; + } else if (tUnit > 100_000) { + tPlasma.amount = 1000; + } else if (tUnit > 50_000) { + tPlasma.amount = 800; + } else if (tUnit > 10_000) { + tPlasma.amount = 500; + } else { + tPlasma.amount = 100; + } + + String tPlasmaName = FluidRegistry.getFluidName(tPlasma); + + if (tPlasmaName.split("\\.", 2).length == 2) { + String tOutName = tPlasmaName.split("\\.", 2)[1]; + FluidStack output = FluidRegistry.getFluidStack(tOutName, tPlasma.amount); + if (output == null) output = FluidRegistry.getFluidStack("molten." + tOutName, tPlasma.amount); + if (output != null) { + long waterAmount = (long) tUnit * 3 * tPlasma.amount / 160; + long criticalSteamAmount = (long) tUnit * 3 * tPlasma.amount / 100; + MyRecipeAdder.instance.addExtremeHeatExchangerRecipe( + tPlasma, + output, + FluidRegistry.getFluidStack("ic2distilledwater", (int) waterAmount), + FluidRegistry.getFluidStack("ic2superheatedsteam", 0), // Plasma always outputs SC steam. + FluidRegistry.getFluidStack("supercriticalsteam", (int) criticalSteamAmount), + 1); + } + } + } + } +} |