From 311ab89f93558233a40079f7cb16605b141b5346 Mon Sep 17 00:00:00 2001 From: Johann Bernhardt Date: Sun, 12 Dec 2021 19:38:06 +0100 Subject: Move sources and resources --- .../core/recipe/Gregtech_Recipe_Adder.java | 100 + .../core/recipe/LOADER_Machine_Components.java | 216 ++ .../gtPlusPlus/core/recipe/RECIPES_Extruder.java | 47 + .../gtPlusPlus/core/recipe/RECIPES_GREGTECH.java | 2270 +++++++++++++++ .../gtPlusPlus/core/recipe/RECIPES_General.java | 509 ++++ .../core/recipe/RECIPES_LaserEngraver.java | 135 + .../gtPlusPlus/core/recipe/RECIPES_MTWRAPPER.java | 27 + .../core/recipe/RECIPES_MachineComponents.java | 410 +++ .../gtPlusPlus/core/recipe/RECIPES_Machines.java | 2926 ++++++++++++++++++++ .../core/recipe/RECIPES_Old_Circuits.java | 458 +++ .../core/recipe/RECIPES_RareEarthProcessing.java | 226 ++ .../core/recipe/RECIPES_SeleniumProcessing.java | 222 ++ .../gtPlusPlus/core/recipe/RECIPES_Shapeless.java | 35 + .../java/gtPlusPlus/core/recipe/RECIPES_Tools.java | 181 ++ .../gtPlusPlus/core/recipe/RECIPE_Batteries.java | 52 + .../gtPlusPlus/core/recipe/ShapedRecipeObject.java | 43 + .../java/gtPlusPlus/core/recipe/common/CI.java | 1343 +++++++++ 17 files changed, 9200 insertions(+) create mode 100644 src/main/java/gtPlusPlus/core/recipe/Gregtech_Recipe_Adder.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/LOADER_Machine_Components.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_Extruder.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_General.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_LaserEngraver.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_MTWRAPPER.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_MachineComponents.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_Machines.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_Old_Circuits.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_RareEarthProcessing.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_SeleniumProcessing.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_Shapeless.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPES_Tools.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/RECIPE_Batteries.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/ShapedRecipeObject.java create mode 100644 src/main/java/gtPlusPlus/core/recipe/common/CI.java (limited to 'src/main/java/gtPlusPlus/core/recipe') diff --git a/src/main/java/gtPlusPlus/core/recipe/Gregtech_Recipe_Adder.java b/src/main/java/gtPlusPlus/core/recipe/Gregtech_Recipe_Adder.java new file mode 100644 index 0000000000..b5fc9c3995 --- /dev/null +++ b/src/main/java/gtPlusPlus/core/recipe/Gregtech_Recipe_Adder.java @@ -0,0 +1,100 @@ +package gtPlusPlus.core.recipe; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_ModHandler; + +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class Gregtech_Recipe_Adder { + + private static int euT; + private static int ticks; + private static ItemStack inputStack1; + private static ItemStack inputStack2; + private static ItemStack outputStack1; + private static ItemStack outputStack2; + + public static void addRecipe( + final Item maceratorInput, final int maceratorInputAmount1, + final Item maceratorOutput, final int maceratorOutputAmount1, + final Item compressorInput, final int compressorInputAmount1, + final Item compressorOutput, final int compressorOutputAmount1, + final Item blastFurnaceInput, final int blastFurnaceInputAmount1, + final Item blastFurnaceOutput, final int blastFurnaceOutputAmount1, + final Item blastFurnaceInput2, final int blastFurnaceInputAmount2, + final Item blastFurnaceOutput2, final int blastFurnaceOutputAmount2, + final Item smeltingInput, final int smeltingInputAmount1, + final Item smeltingOutput, final int smeltingOutputAmount1, + + final int euPerTick, final int timeInTicks, + final boolean addMaceratorRecipe, final boolean addCompressorRecipe, final boolean addBlastFurnaceRecipe, final int blastFurnaceTemp, final boolean addSmeltingRecipe, final boolean addMixerRecipe){ + euT = euPerTick; + ticks = timeInTicks; + + resetVars(); + if (addMaceratorRecipe){ + inputStack1 = ItemUtils.getSimpleStack(maceratorInput, maceratorInputAmount1); + outputStack1 = ItemUtils.getSimpleStack(maceratorOutput, maceratorOutputAmount1); + addMaceratorRecipe(inputStack1, outputStack1); + } + resetVars(); + if (addCompressorRecipe){ + inputStack1 = ItemUtils.getSimpleStack(compressorInput, compressorInputAmount1); + outputStack1 = ItemUtils.getSimpleStack(compressorOutput, compressorOutputAmount1); + addCompressorRecipe(inputStack1, outputStack1); + } + resetVars(); + if (addBlastFurnaceRecipe){ + inputStack1 = ItemUtils.getSimpleStack(blastFurnaceInput, blastFurnaceInputAmount1); + inputStack2 = ItemUtils.getSimpleStack(blastFurnaceInput2, blastFurnaceInputAmount2); + outputStack1 = ItemUtils.getSimpleStack(blastFurnaceOutput, blastFurnaceOutputAmount1); + outputStack2 = ItemUtils.getSimpleStack(blastFurnaceOutput2, blastFurnaceOutputAmount2); + addBlastFurnaceRecipe(inputStack1, inputStack2, outputStack1, outputStack2, blastFurnaceTemp); + } + resetVars(); + if (addSmeltingRecipe){ + inputStack1 = ItemUtils.getSimpleStack(smeltingInput, smeltingInputAmount1); + outputStack1 = ItemUtils.getSimpleStack(smeltingOutput, smeltingOutputAmount1); + addSmeltingRecipe(inputStack1, outputStack1); + } + resetVars(); + + } + + private static void resetVars(){ + inputStack1 = null; + inputStack2 = null; + outputStack1 = null; + outputStack2 = null; + } + + private static void addMaceratorRecipe(final ItemStack input1, final ItemStack output1){ + GT_ModHandler.addPulverisationRecipe(input1, output1); + } + + private static void addCompressorRecipe(final ItemStack input1, final ItemStack output1){ + GT_ModHandler.addCompressionRecipe(input1, output1); + } + + private static void addBlastFurnaceRecipe(final ItemStack input1, final ItemStack input2, final ItemStack output1, final ItemStack output2, final int tempRequired){ + Logger.INFO("Registering Blast Furnace Recipes."); + GT_Values.RA.addBlastRecipe( + input1, + input2, + GT_Values.NF, GT_Values.NF, + output1, + output2, + ticks, + euT, + tempRequired); + } + + private static void addSmeltingRecipe(final ItemStack input1, final ItemStack output1){ + GT_ModHandler.addSmeltingRecipe(input1, output1); + } + +} diff --git a/src/main/java/gtPlusPlus/core/recipe/LOADER_Machine_Components.java b/src/main/java/gtPlusPlus/core/recipe/LOADER_Machine_Components.java new file mode 100644 index 0000000000..460b29e802 --- /dev/null +++ b/src/main/java/gtPlusPlus/core/recipe/LOADER_Machine_Components.java @@ -0,0 +1,216 @@ +package gtPlusPlus.core.recipe; + +import gregtech.api.enums.ItemList; + +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; + +public class LOADER_Machine_Components { + + public static void initialise(){ + + registerDefaultComponents(); + + if (!CORE.GTNH){ + if(CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK){ + registerGTExperimentalComponents(); + } + else { + registerGTStandardComponents(); + } + } + else { + registerGTNHComponents(); + } + } + + private static void registerDefaultComponents(){ + //Machine Components + CI.electricMotor_LV = ItemList.Electric_Motor_LV.get(1); + CI.electricMotor_MV = ItemList.Electric_Motor_MV.get(1); + CI.electricMotor_HV = ItemList.Electric_Motor_HV.get(1); + CI.electricMotor_EV = ItemList.Electric_Motor_EV.get(1); + CI.electricMotor_IV = ItemList.Electric_Motor_IV.get(1); + CI.electricPump_LV = ItemList.Electric_Pump_LV.get(1); + CI.electricPump_MV = ItemList.Electric_Pump_MV.get(1); + CI.electricPump_HV = ItemList.Electric_Pump_HV.get(1); + CI.electricPump_EV = ItemList.Electric_Pump_EV.get(1); + CI.electricPump_IV = ItemList.Electric_Pump_IV.get(1); + CI.electricPiston_LV = ItemList.Electric_Piston_LV.get(1); + CI.electricPiston_MV = ItemList.Electric_Piston_MV.get(1); + CI.electricPiston_HV = ItemList.Electric_Piston_HV.get(1); + CI.electricPiston_EV = ItemList.Electric_Piston_EV.get(1); + CI.electricPiston_IV = ItemList.Electric_Piston_IV.get(1); + CI.robotArm_LV = ItemList.Robot_Arm_LV.get(1); + CI.robotArm_MV = ItemList.Robot_Arm_MV.get(1); + CI.robotArm_HV = ItemList.Robot_Arm_HV.get(1); + CI.robotArm_EV = ItemList.Robot_Arm_EV.get(1); + CI.robotArm_IV = ItemList.Robot_Arm_IV.get(1); + CI.conveyorModule_LV = ItemList.Conveyor_Module_LV.get(1); + CI.conveyorModule_MV = ItemList.Conveyor_Module_MV.get(1); + CI.conveyorModule_HV = ItemList.Conveyor_Module_HV.get(1); + CI.conveyorModule_EV = ItemList.Conveyor_Module_EV.get(1); + CI.conveyorModule_IV = ItemList.Conveyor_Module_IV.get(1); + CI.emitter_LV = ItemList.Emitter_LV.get(1); + CI.emitter_MV = ItemList.Emitter_MV.get(1); + CI.emitter_HV = ItemList.Emitter_HV.get(1); + CI.emitter_EV = ItemList.Emitter_EV.get(1); + CI.emitter_IV = ItemList.Emitter_IV.get(1); + CI.fieldGenerator_LV = ItemList.Field_Generator_LV.get(1); + CI.fieldGenerator_MV = ItemList.Field_Generator_MV.get(1); + CI.fieldGenerator_HV = ItemList.Field_Generator_HV.get(1); + CI.fieldGenerator_EV = ItemList.Field_Generator_EV.get(1); + CI.fieldGenerator_IV = ItemList.Field_Generator_IV.get(1); + CI.sensor_LV = ItemList.Sensor_LV.get(1); + CI.sensor_MV = ItemList.Sensor_MV.get(1); + CI.sensor_HV = ItemList.Sensor_HV.get(1); + CI.sensor_EV = ItemList.Sensor_EV.get(1); + CI.sensor_IV = ItemList.Sensor_IV.get(1); + } + + private static void registerGTExperimentalComponents(){ + //GT++ Machine Components + CI.electricMotor_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32606, 1); + CI.electricMotor_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32607, 1); + CI.electricMotor_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32608, 1); + CI.electricPump_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32620, 1); + CI.electricPump_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32621, 1); + CI.electricPump_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32622, 1); + CI.electricPiston_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32645, 1); + CI.electricPiston_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32646, 1); + CI.electricPiston_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32647, 1); + CI.robotArm_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32655, 1); + CI.robotArm_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32656, 1); + CI.robotArm_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32657, 1); + CI.conveyorModule_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32636, 1); + CI.conveyorModule_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32637, 1); + CI.conveyorModule_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32638, 1); + CI.emitter_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32685, 1); + CI.emitter_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32686, 1); + CI.emitter_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32687, 1); + CI.fieldGenerator_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32675, 1); + CI.fieldGenerator_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32676, 1); + CI.fieldGenerator_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32677, 1); + CI.sensor_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32695, 1); + CI.sensor_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32696, 1); + CI.sensor_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32697, 1); + + registerComponentsULV(); + registerComponentsMAX(); + } + + private static void registerGTStandardComponents(){ + CI.electricMotor_LuV = GregtechItemList.Electric_Motor_LuV.get(1); + CI.electricMotor_ZPM = GregtechItemList.Electric_Motor_ZPM.get(1); + CI.electricMotor_UV = GregtechItemList.Electric_Motor_UV.get(1); + CI.electricMotor_MAX = GregtechItemList.Electric_Motor_MAX.get(1); + CI.electricPump_LuV = GregtechItemList.Electric_Pump_LuV.get(1); + CI.electricPump_ZPM = GregtechItemList.Electric_Pump_ZPM.get(1); + CI.electricPump_UV = GregtechItemList.Electric_Pump_UV.get(1); + CI.electricPump_MAX = GregtechItemList.Electric_Pump_MAX.get(1); + CI.electricPiston_LuV = GregtechItemList.Electric_Piston_LuV.get(1); + CI.electricPiston_ZPM = GregtechItemList.Electric_Piston_ZPM.get(1); + CI.electricPiston_UV = GregtechItemList.Electric_Piston_UV.get(1); + CI.electricPiston_MAX = GregtechItemList.Electric_Piston_MAX.get(1); + CI.robotArm_LuV = GregtechItemList.Robot_Arm_LuV.get(1); + CI.robotArm_ZPM = GregtechItemList.Robot_Arm_ZPM.get(1); + CI.robotArm_UV = GregtechItemList.Robot_Arm_UV.get(1); + CI.robotArm_MAX = GregtechItemList.Robot_Arm_MAX.get(1); + CI.conveyorModule_LuV = GregtechItemList.Conveyor_Module_LuV.get(1); + CI.conveyorModule_ZPM = GregtechItemList.Conveyor_Module_ZPM.get(1); + CI.conveyorModule_UV = GregtechItemList.Conveyor_Module_UV.get(1); + CI.conveyorModule_MAX = GregtechItemList.Conveyor_Module_MAX.get(1); + CI.emitter_LuV = GregtechItemList.Emitter_LuV.get(1); + CI.emitter_ZPM = GregtechItemList.Emitter_ZPM.get(1); + CI.emitter_UV = GregtechItemList.Emitter_UV.get(1); + CI.emitter_MAX = GregtechItemList.Emitter_MAX.get(1); + CI.fieldGenerator_LuV = GregtechItemList.Field_Generator_LuV.get(1); + CI.fieldGenerator_ZPM = GregtechItemList.Field_Generator_ZPM.get(1); + CI.fieldGenerator_UV = GregtechItemList.Field_Generator_UV.get(1); + CI.fieldGenerator_MAX = GregtechItemList.Field_Generator_MAX.get(1); + CI.sensor_LuV = GregtechItemList.Sensor_LuV.get(1); + CI.sensor_ZPM = GregtechItemList.Sensor_ZPM.get(1); + CI.sensor_UV = GregtechItemList.Sensor_UV.get(1); + CI.sensor_MAX = GregtechItemList.Sensor_MAX.get(1); + + registerComponentsULV(); + } + + private static void registerGTNHComponents(){ + //Machine Components + CI.electricMotor_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32606, 1); + CI.electricMotor_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32607, 1); + CI.electricMotor_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32608, 1); + + CI.electricPump_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32615, 1); + CI.electricPump_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32616, 1); + CI.electricPump_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32617, 1); + + CI.electricPiston_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32645, 1); + CI.electricPiston_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32646, 1); + CI.electricPiston_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32647, 1); + + CI.robotArm_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32655, 1); + CI.robotArm_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32656, 1); + CI.robotArm_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32657, 1); + + CI.conveyorModule_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32635, 1); + CI.conveyorModule_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32636, 1); + CI.conveyorModule_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32637, 1); + + CI.emitter_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32685, 1); + CI.emitter_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32686, 1); + CI.emitter_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32687, 1); + + CI.fieldGenerator_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32675, 1); + CI.fieldGenerator_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32676, 1); + CI.fieldGenerator_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32677, 1); + + CI.sensor_LuV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32695, 1); + CI.sensor_ZPM = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32696, 1); + CI.sensor_UV = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32697, 1); + + // Thanks 0lafe + CI.electricMotor_MAX = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32596, 1); + CI.electricPump_MAX = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32618, 1); + CI.electricPiston_MAX = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32648, 1); + CI.robotArm_MAX = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32658, 1); + CI.conveyorModule_MAX = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32638, 1); + CI.emitter_MAX = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32688, 1); + CI.fieldGenerator_MAX = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32678, 1); + CI.sensor_MAX = ItemUtils.simpleMetaStack("gregtech:gt.metaitem.01", 32698, 1); + + registerComponentsULV(); + } + + private static boolean registerComponentsULV(){ + + CI.electricMotor_ULV = GregtechItemList.Electric_Motor_ULV.get(1); + CI.electricPump_ULV = GregtechItemList.Electric_Pump_ULV.get(1); + CI.electricPiston_ULV = GregtechItemList.Electric_Piston_ULV.get(1); + CI.robotArm_ULV = GregtechItemList.Robot_Arm_ULV.get(1); + CI.conveyorModule_ULV = GregtechItemList.Conveyor_Module_ULV.get(1); + CI.emitter_ULV = GregtechItemList.Emitter_ULV.get(1); + CI.fieldGenerator_ULV = GregtechItemList.Field_Generator_ULV.get(1); + CI.sensor_ULV = GregtechItemList.Sensor_ULV.get(1); + return true; + } + + private static boolean registerComponentsMAX() { + + // Max Tier Components Blood Never added... Useless, lol. + CI.electricMotor_MAX = GregtechItemList.Electric_Motor_MAX.get(1); + CI.electricPump_MAX = GregtechItemList.Electric_Pump_MAX.get(1); + CI.electricPiston_MAX = GregtechItemList.Electric_Piston_MAX.get(1); + CI.robotArm_MAX = GregtechItemList.Robot_Arm_MAX.get(1); + CI.conveyorModule_MAX = GregtechItemList.Conveyor_Module_MAX.get(1); + CI.emitter_MAX = GregtechItemList.Emitter_MAX.get(1); + CI.fieldGenerator_MAX = GregtechItemList.Field_Generator_MAX.get(1); + CI.sensor_MAX = GregtechItemList.Sensor_MAX.get(1); + + return true; + } + +} diff --git a/src/main/java/gtPlusPlus/core/recipe/RECIPES_Extruder.java b/src/main/java/gtPlusPlus/core/recipe/RECIPES_Extruder.java new file mode 100644 index 0000000000..455beb2fd0 --- /dev/null +++ b/src/main/java/gtPlusPlus/core/recipe/RECIPES_Extruder.java @@ -0,0 +1,47 @@ +package gtPlusPlus.core.recipe; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.*; +import gregtech.api.interfaces.IOreRecipeRegistrator; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; + +public class RECIPES_Extruder implements IOreRecipeRegistrator { + + public RECIPES_Extruder() { + OrePrefixes.ingot.add((IOreRecipeRegistrator) this); + OrePrefixes.dust.add((IOreRecipeRegistrator) this); + } + + public void registerOre(final OrePrefixes aPrefix, final Materials aMaterial, final String aOreDictName, + final String aModName, final ItemStack aStack) { + if (!CORE.GTNH && ((aMaterial == Materials.Glass || aMaterial == Materials.WroughtIron + || GT_OreDictUnificator.get(OrePrefixes.ingot, (Object) aMaterial, 1L) != null) + && !aMaterial.contains(SubTag.NO_SMELTING))) { + final long aMaterialMass = aMaterial.getMass(); + final int tAmount = (int) (aPrefix.mMaterialAmount / 3628800L); + if (tAmount > 0 && tAmount <= 64 && aPrefix.mMaterialAmount % 3628800L == 0L) { + int tVoltageMultiplier = (aMaterial.mBlastFurnaceTemp >= 2800) ? 64 : 16; + if (aMaterial.contains(SubTag.NO_SMASHING)) { + tVoltageMultiplier /= 4; + } else if (aPrefix.name().startsWith(OrePrefixes.dust.name())) { + return; + } + + GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), + GregtechItemList.Shape_Extruder_SmallGear.get(0L, new Object[0]), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, (Object) aMaterial.mSmeltInto, (long) tAmount), + ((int) Math.max(aMaterialMass * 5L * tAmount, tAmount)/4), 8 * tVoltageMultiplier); + GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(2L, new Object[]{aStack}), + ItemList.Shape_Mold_Gear_Small.get(0L, new Object[0]), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, (Object) aMaterial.mSmeltInto, (long) tAmount), + ((int) Math.max(aMaterialMass * 10L * tAmount, tAmount)/4), 2 * tVoltageMultiplier); + + } + } + } +} \ No newline at end of file diff --git a/src/main/java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java b/src/main/java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java new file mode 100644 index 0000000000..5156b938db --- /dev/null +++ b/src/main/java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java @@ -0,0 +1,2270 @@ +package gtPlusPlus.core.recipe; + +import static gtPlusPlus.core.lib.CORE.GTNH; + +import java.util.ArrayList; + +import cpw.mods.fml.common.Loader; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.HotFuel; +import gregtech.api.util.ThermalFuel; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.block.ModBlocks; +import gtPlusPlus.core.item.ModItems; +import gtPlusPlus.core.item.chemistry.AgriculturalChem; +import gtPlusPlus.core.item.chemistry.GenericChem; +import gtPlusPlus.core.item.chemistry.IonParticles; +import gtPlusPlus.core.item.chemistry.RocketFuels; +import gtPlusPlus.core.item.crafting.ItemDummyResearch; +import gtPlusPlus.core.item.crafting.ItemDummyResearch.ASSEMBLY_LINE_RESEARCH; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.lib.LoadedMods; +import gtPlusPlus.core.material.ALLOY; +import gtPlusPlus.core.material.ELEMENT; +import gtPlusPlus.core.material.MISC_MATERIALS; +import gtPlusPlus.core.material.ORES; +import gtPlusPlus.core.material.Particle; +import gtPlusPlus.core.material.nuclear.FLUORIDES; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.minecraft.EnchantingUtils; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; +import gtPlusPlus.core.util.reflect.AddGregtechRecipe; +import gtPlusPlus.everglades.dimension.Dimension_Everglades; +import gtPlusPlus.xmod.bop.blocks.BOP_Block_Registrator; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +public class RECIPES_GREGTECH { + + public static void run() { + Logger.INFO("Loading Recipes through GregAPI for Industrial Multiblocks."); + execute(); + } + + private static void execute() { + cokeOvenRecipes(); + electrolyzerRecipes(); + assemblerRecipes(); + fluidcannerRecipes(); + distilleryRecipes(); + extractorRecipes(); + fluidExtractorRecipes(); + chemicalBathRecipes(); + chemicalReactorRecipes(); + dehydratorRecipes(); + blastFurnaceRecipes(); + + if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) { + largeChemReactorRecipes(); + fusionRecipes(); + } + + fissionFuelRecipes(); + autoclaveRecipes(); + compressorRecipes(); + mixerRecipes(); + macerationRecipes(); + centrifugeRecipes(); + benderRecipes(); + cyclotronRecipes(); + blastSmelterRecipes(); + //advancedMixerRecipes(); + sifterRecipes(); + electroMagneticSeperatorRecipes(); + extruderRecipes(); + cuttingSawRecipes(); + breweryRecipes(); + laserEngraverRecipes(); + assemblyLineRecipes(); + latheRecipes(); + vacuumFreezerRecipes(); + fluidheaterRecipes(); + chemplantRecipes(); + packagerRecipes(); + + + /** + * Special Recipe handlers + */ + RECIPES_SeleniumProcessing.init(); + RECIPES_RareEarthProcessing.init(); + + + + + + + addFuels(); + } + + + + private static void packagerRecipes() { + + + } + + private static void chemplantRecipes() { + + //This is subsequently absorbed in water to form nitric acid and nitric oxide. + //3 NO2 (g) + H2O (l) → 2 HNO3 (aq) + NO (g) (ΔH = −117 kJ/mol) + //The nitric oxide is cycled back for reoxidation. Alternatively, if the last step is carried out in air: + //4 NO2 (g) + O2 (g) + 2 H2O (l) → 4 HNO3 (aq) + + // Advanced method for Nitric Acid Production + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(17), + CI.getPinkCatalyst(0), + }, + new FluidStack[] { + FluidUtils.getFluidStack(GenericChem.Nitrogen_Dioxide, 4000), + FluidUtils.getAir(4000), + FluidUtils.getWater(2000), + }, + new ItemStack[] { + + }, + new FluidStack[] { + FluidUtils.getFluidStack("nitricacid", 4000), + }, + 10 * 20, + 480, + 3); + + // Advanced recipe for Fluorine Production + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(17), + CI.getPurpleCatalyst(0), + ItemUtils.getSimpleStack(Blocks.sandstone, 64), + ItemUtils.getSimpleStack(Blocks.sandstone, 64) + }, + new FluidStack[] { + FluidUtils.getFluidStack("nitricacid", 4000), + FluidUtils.getAir(8000) + }, + new ItemStack[] { + FLUORIDES.FLUORITE.getOre(8), + FLUORIDES.FLUORITE.getOre(4), + FLUORIDES.FLUORITE.getOre(4), + FLUORIDES.FLUORITE.getOre(4), + }, + new FluidStack[] { + + }, + new int[] { + 0, 2500, 2000, 1500 + }, + 10 * 20, + 1024, + 5); + + // Advanced recipe for Fluorine Production + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(17), + CI.getPurpleCatalyst(0), + ItemUtils.getSimpleStack(Blocks.sand, 64), + ItemUtils.getSimpleStack(Blocks.sand, 64) + }, + new FluidStack[] { + FluidUtils.getFluidStack("nitricacid", 5000), + FluidUtils.getAir(12000) + }, + new ItemStack[] { + FLUORIDES.FLUORITE.getOre(4), + FLUORIDES.FLUORITE.getOre(2), + FLUORIDES.FLUORITE.getOre(2), + FLUORIDES.FLUORITE.getOre(2), + }, + new FluidStack[] { + + }, + new int[] { + 7500, 1500, 1000, 500 + }, + 10 * 20, + 1024, + 5); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(16), + CI.getPinkCatalyst(0), + }, + new FluidStack[] { + FluidUtils.getFluidStack(GenericChem.Nitrogen_Dioxide, 3000), + FluidUtils.getDistilledWater(5000) + }, + new ItemStack[] { + + }, + new FluidStack[] { + FluidUtils.getFluidStack("nitricacid", 2000), + FluidUtils.getFluidStack(GenericChem.Nitric_Oxide, 1500), + }, + 10 * 20, + 480, + 2); + + // Produce Boric Acid + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(21), + ItemUtils.getItemStackOfAmountFromOreDict("dustBorax", 4), + }, + new FluidStack[] { + FluidUtils.getFluidStack(GenericChem.HydrochloricAcid, 2000) + }, + new ItemStack[] { + ItemUtils.getItemStackOfAmountFromOreDict("dustSalt", 5), + }, + new FluidStack[] { + FluidUtils.getFluidStack("boricacid", 2000), + FluidUtils.getWater(5000) + + }, + 20 * 30, + MaterialUtils.getVoltageForTier(3), + 3); + + // Produce Th232 + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(22), + ELEMENT.getInstance().THORIUM.getDust(16) + }, + new FluidStack[] { + FluidUtils.getDistilledWater(2000), + FluidUtils.getFluidStack("boricacid", 1500) + }, + new ItemStack[] { + ELEMENT.getInstance().THORIUM.getSmallDust(32), + ELEMENT.getInstance().THORIUM232.getDust(2), + ELEMENT.getInstance().THORIUM232.getSmallDust(2), + ELEMENT.getInstance().URANIUM232.getDust(1), + }, + new FluidStack[] { + + }, + new int[] { + 0, 0, 1000, 250 + }, + 20 * 300, + MaterialUtils.getVoltageForTier(4), + 4); + + // Modify Sapling into Pine Sapling + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedBioCircuit(6), + ItemUtils.getSimpleStack(Blocks.sapling, 32) + }, + new FluidStack[] { + FluidUtils.getFluidStack("fluid.geneticmutagen", 2000), + FluidUtils.getDistilledWater(8000) + }, + new ItemStack[] { + ItemUtils.getSimpleStack(BOP_Block_Registrator.sapling_Pine, 16) + }, + new FluidStack[] { + + }, + 120 * 20, + 64, + 2); + + + // Convert GT++ Plutonium239 into normal Plutonium + if (Materials.Plutonium.mDefaultLocalName.equals("Plutonium 239")) { + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(16), + ELEMENT.getInstance().PLUTONIUM239.getDust(1) + }, + new FluidStack[] { + + }, + new ItemStack[] { + ItemUtils.getItemStackOfAmountFromOreDict("dustPlutonium", 1) + }, + new FluidStack[] { + + }, + 5 * 20, + 1, + 2); + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(16), + ELEMENT.getInstance().PLUTONIUM239.getSmallDust(1) + }, + new FluidStack[] { + + }, + new ItemStack[] { + ItemUtils.getItemStackOfAmountFromOreDict("dustSmallPlutonium", 1) + }, + new FluidStack[] { + + }, + 5 * 20, + 1, + 2); + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(16), + ELEMENT.getInstance().PLUTONIUM239.getTinyDust(1) + }, + new FluidStack[] { + + }, + new ItemStack[] { + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyPlutonium", 1) + }, + new FluidStack[] { + + }, + 5 * 20, + 1, + 2); + } + + int aLaureniumTier = ALLOY.LAURENIUM.vTier; + // Adding Recipes for Casings + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(12), + CI.getTieredMachineCasing(aLaureniumTier-1), + ALLOY.LAURENIUM.getPlate(8), + CI.getGear(aLaureniumTier, 2) + }, + new FluidStack[] { + CI.getTieredFluid(aLaureniumTier, 2 * 144), + CI.getAlternativeTieredFluid(aLaureniumTier-1, 4 * 144), + CI.getTertiaryTieredFluid(aLaureniumTier-2, 6 * 144) + }, + new ItemStack[] { + GregtechItemList.Casing_Machine_Custom_3.get(1) + }, + new FluidStack[] { + + }, + 20 * 20, + MaterialUtils.getVoltageForTier(aLaureniumTier-2), + 5); + + int aBotmiumTier = ALLOY.BOTMIUM.vTier; + // Adding Recipes for Casings + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(12), + CI.getTieredMachineCasing(aBotmiumTier-1), + ALLOY.BOTMIUM.getPlate(8), + CI.getGear(aBotmiumTier, 2) + }, + new FluidStack[] { + CI.getTieredFluid(aBotmiumTier, 2 * 144), + CI.getAlternativeTieredFluid(aBotmiumTier-1, 4 * 144), + CI.getTertiaryTieredFluid(aBotmiumTier-2, 6 * 144) + }, + new ItemStack[] { + GregtechItemList.Casing_Machine_Custom_4.get(1) + }, + new FluidStack[] { + + }, + 20 * 20, + MaterialUtils.getVoltageForTier(aBotmiumTier-2), + 6); + + } + + private static void fluidheaterRecipes() { + GT_Values.RA.addFluidHeaterRecipe(CI.getNumberedCircuit(20), FluidUtils.getWater(1000), FluidUtils.getHotWater(1000), 30, 30); + + } + + private static void vacuumFreezerRecipes() { + GT_Values.RA.addVacuumFreezerRecipe(GregtechItemList.Bomb_Cast_Molten.get(1), GregtechItemList.Bomb_Cast_Set.get(1), 20 * 30); + } + + private static void latheRecipes() { + + GT_Values.RA.addLatheRecipe( + ALLOY.EGLIN_STEEL.getBlock(1), + GregtechItemList.Bomb_Cast_Mold.get(1), + null, + 20 * 60 * 15, + 120); + + GT_Values.RA.addLatheRecipe( + GregtechItemList.Bomb_Cast_Set.get(1), + GregtechItemList.Bomb_Cast_Broken.get(2), + ItemUtils.getSimpleStack(ModItems.itemBombCasing, 2), + 20 * 60 * 5, + 30); + + } + + private static void fusionRecipes() { + + /** + * Adds a Fusion reactor Recipe + * + * @param aInput1 = first Input (not null, and respects StackSize) + * @param aInput2 = second Input (not null, and respects StackSize) + * @param aOutput = Output of the Fusion (can be null, and respects StackSize) + * @param aFusionDurationInTicks = How many ticks the Fusion lasts (must be > 0) + * @param aFusionEnergyPerTick = The EU generated per Tick (can even be negative!) + * @param aEnergyNeededForStartingFusion = EU needed for heating the Reactor up (must be >= 0) + */ + + //Hydrogen Plasma + /*CORE.RA.addFusionReactorRecipe( + Particle.getIon("Hydrogen", 0), + Particle.getIon("Hydrogen", 0), + Materials.Hydrogen.getPlasma(1), + 5000, + 16, + 4096, + 40000000);*/ + + + //Hypogen Creation + GT_Values.RA.addFusionReactorRecipe( + Materials.Neutronium.getMolten(128), + ALLOY.QUANTUM.getFluidStack(256), + ELEMENT.STANDALONE.HYPOGEN.getFluidStack(4), + 2048 * 4, + (int) MaterialUtils.getVoltageForTier(9), + 600000000 * 2); + + //Rhugnor + GT_Values.RA.addFusionReactorRecipe( + GenericChem.TEFLON.getFluidStack(64), + ALLOY.PIKYONIUM.getFluidStack(128), + ELEMENT.STANDALONE.RHUGNOR.getFluidStack(8), + 2048 * 4, + (int) MaterialUtils.getVoltageForTier(7), + 150000000 * 2); + + } + + private static void assemblyLineRecipes() { + + + + ItemStack[] aCoilWire = new ItemStack[] { + ItemUtils.simpleMetaStack("miscutils:itemDehydratorCoilWire", 0, GTNH ? 64 : 32), + ItemUtils.simpleMetaStack("miscutils:itemDehydratorCoilWire", 1, GTNH ? 64 : 32), + ItemUtils.simpleMetaStack("miscutils:itemDehydratorCoilWire", 2, GTNH ? 64 : 32), + ItemUtils.simpleMetaStack("miscutils:itemDehydratorCoilWire", 3, GTNH ? 64 : 32), + }; + + + + + //Containment Casings + CORE.RA.addAssemblylineRecipe( + ItemDummyResearch.getResearchStack(ASSEMBLY_LINE_RESEARCH.RESEARCH_1_CONTAINMENT, 1), + 20 * 60 * 30, + new Object[] { + ItemList.Field_Generator_IV.get(GTNH ? 32 : 16), + ItemList.Electric_Motor_EV.get(GTNH ? 64 : 32), + ItemList.Energy_LapotronicOrb.get(GTNH ? 32 : 16), + CI.getTieredComponent(OrePrefixes.cableGt12, 7, GTNH ? 32 : 16), + CI.getTieredComponent(OrePrefixes.wireGt16, 6, GTNH ? 64 : 32), + ItemUtils.getOrePrefixStack(OrePrefixes.plate, Materials.Naquadria, GTNH ? 64 : 16), + ELEMENT.getInstance().GADOLINIUM.getDust(GTNH ? 32 : 8), + ELEMENT.getInstance().SAMARIUM.getDust(GTNH ? 16 : 4), + ALLOY.ARCANITE.getGear(GTNH ? 8 : 2), + new Object[] {CI.getTieredCircuitOreDictName(5), 64}, + new Object[] {CI.getTieredCircuitOreDictName(6), 32}, + new Object[] {CI.getTieredCircuitOreDictName(7), 16}, + GregtechItemList.Laser_Lens_Special.get(1), + aCoilWire[3] + }, + new FluidStack[] { + ALLOY.NITINOL_60.getFluidStack(144 * 9 * (GTNH ? 4 : 2)), + ALLOY.ENERGYCRYSTAL.getFluidStack(144 * 9 * (GTNH ? 8 : 4)), + ALLOY.TUMBAGA.getFluidStack(144 * 9 * (GTNH ? 32 : 8)), + ALLOY.NICHROME.getFluidStack(144 * 1 * (GTNH ? 16 : 4)), + }, + ItemUtils.getSimpleStack(ModBlocks.blockCasings3Misc, 15, 32), + 20 * 60 * 10 * (GTNH ? 2 : 1), + (int) MaterialUtils.getVoltageForTier(6)); + + //Slow Fusion Controller + /*CORE.RA.addAssemblylineRecipe( + GregtechItemList.COMET_Cyclotron.get(1), + 20 * 60 * 30, + new ItemStack[] { + CI.getFieldGenerator(6, GTNH ? 32 : 8), + ItemList.Electric_Motor_EV.get(GTNH ? 32 : 8), + ItemList.Tool_Scanner.get(GTNH ? 4 : 2), + CI.getTieredComponent(OrePrefixes.cableGt12, 6, GTNH ? 32 : 16), + CI.getTieredComponent(OrePrefixes.wireGt16, 5, GTNH ? 64 : 32), + CI.getTieredComponent(OrePrefixes.plate, 6, GTNH ? 64 : 32), + ELEMENT.getInstance().GADOLINIUM.getDust(GTNH ? 32 : 8), + ELEMENT.getInstance().SAMARIUM.getDust(GTNH ? 16 : 4), + ALLOY.INCOLOY_MA956.getGear(GTNH ? 8 : 2), + CI.getTieredComponent(OrePrefixes.circuit, 5, GTNH ? 64 : 32), + CI.getTieredComponent(OrePrefixes.circuit, 6, GTNH ? 32 : 16), + CI.getTieredComponent(OrePrefixes.circuit, 7, GTNH ? 16 : 8) + }, + new FluidStack[] { + CI.getTieredFluid(6, 144 * 9 * (GTNH ? 8 : 4)), + CI.getTertiaryTieredFluid(6, 144 * 9 * (GTNH ? 8 : 4)), + CI.getAlternativeTieredFluid(6, 144 * 9 * (GTNH ? 8 : 4)), + CI.getTieredFluid(5, 144 * 9 * (GTNH ? 16 : 8)), + }, + GregtechItemList.Miniature_Fusion.get(1), + 20 * 60 * 5 * (GTNH ? 2 : 1), + (int) MaterialUtils.getVoltageForTier(7));*/ + + + //Plasma Tank + /*CORE.RA.addAssemblylineRecipe( + ItemUtils.getOrePrefixStack(OrePrefixes.pipeMedium, Materials.Superconductor, 1), + 20 * 60 * 5, + new ItemStack[] { + CI.getTieredComponent(OrePrefixes.plate, 5, GTNH ? 32 : 16), + CI.getTieredComponent(OrePrefixes.circuit, 5, GTNH ? 16 : 4), + CI.getTieredComponent(OrePrefixes.pipeHuge, 5, GTNH ? 16 : 4), + CI.getTieredComponent(OrePrefixes.cableGt08, 7, GTNH ? 32 : 16), + CI.getTieredComponent(OrePrefixes.gearGt, 6, GTNH ? 8 : 4), + aCoilWire[2] + }, + new FluidStack[] { + CI.getTieredFluid(4, 144 * 9 * (GTNH ? 16 : 8)), + CI.getTertiaryTieredFluid(4, 144 * 9 * (GTNH ? 16 : 8)), + CI.getAlternativeTieredFluid(4, 144 * 9 * (GTNH ? 16 : 8)), + + }, + GregtechItemList.Plasma_Tank.get(1), + 20 * 60 * 1 * (GTNH ? 2 : 1), + (int) MaterialUtils.getVoltageForTier(5));*/ + + // Turbine Automation Port + CORE.RA.addAssemblylineRecipe( + ItemDummyResearch.getResearchStack(ASSEMBLY_LINE_RESEARCH.RESEARCH_8_TURBINE_AUTOMATION, 1), + 20 * 60 * 60 * 24, + new Object[] { + CI.getTieredMachineHull(8, 4), + CI.getConveyor(8, GTNH ? 24 : 12), + CI.getElectricMotor(7, GTNH ? 32 : 16), + CI.getElectricPiston(7, GTNH ? 16 : 4), + CI.getEnergyCore(6, GTNH ? 8 : 2), + CI.getPlate(8, GTNH ? 24 : 12), + CI.getTieredComponent(OrePrefixes.screw, 8, GTNH ? 48 : 24), + CI.getTieredComponent(OrePrefixes.bolt, 7, GTNH ? 32 : 16), + CI.getTieredComponent(OrePrefixes.rod, 6, GTNH ? 12 : 6), + new Object[] {CI.getTieredCircuitOreDictName(7), 20}, + CI.getTieredComponent(OrePrefixes.rotor, 6, GTNH ? 16 : 8), + }, + new FluidStack[] { + CI.getTieredFluid(8, 144 * 32), + CI.getAlternativeTieredFluid(7, 144 * 16), + CI.getTertiaryTieredFluid(7, 144 * 16), + ALLOY.BABBIT_ALLOY.getFluidStack(128 * 144), + ALLOY.ZERON_100.getFluidStack(144 * 64) + + }, + GregtechItemList.Hatch_Input_TurbineHousing.get(4), + 20 * 60 * 60 * (GTNH ? 2 : 1), + (int) MaterialUtils.getVoltageForTier(8)); + + + /* + * Contianment casings + */ + + ItemStack[] aGemCasings = new ItemStack[] { + GregtechItemList.Battery_Casing_Gem_1.get(1), + GregtechItemList.Battery_Casing_Gem_2.get(1), + GregtechItemList.Battery_Casing_Gem_3.get(1), + GregtechItemList.Battery_Casing_Gem_4.get(1), + }; + ItemStack[] aResearch = new ItemStack[] { + Particle.getBaseParticle(Particle.UNKNOWN), + GregtechItemList.Battery_Casing_Gem_1.get(1), + GregtechItemList.Battery_Casing_Gem_2.get(1), + GregtechItemList.Battery_Casing_Gem_3.get(1), + }; + + int aCasingSlot = 0; + for (int j = 6; j < 10; j++) { + CORE.RA.addAssemblylineRecipe( + aResearch[aCasingSlot], + 20 * 60 * 60, + new ItemStack[] { + CI.getTieredComponent(OrePrefixes.plate, j-1,16), + CI.getTieredComponent(OrePrefixes.cableGt08, j+1,(GTNH ? 32 : 16)), + CI.getTieredComponent(OrePrefixes.gearGt, j-1, 4), + aCoilWire[aCasingSlot] + }, + new FluidStack[] { + CI.getTieredFluid(j, 144 *(GTNH ? 8 : 4)), + CI.getTertiaryTieredFluid(j-2, 144 * (GTNH ? 16 : 8)), + CI.getAlternativeTieredFluid(j, 144 * (GTNH ? 16 : 12)), + + }, + aGemCasings[aCasingSlot++], + 20 * 60 * 1 * (GTNH ? 2 : 1), + (int) MaterialUtils.getVoltageForTier(j)); + } + + /* + * Gem Battery Recipes + */ + + ItemStack[] aGemBatteries = new ItemStack[] { + GregtechItemList.Battery_Gem_1.get(1), + GregtechItemList.Battery_Gem_2.get(1), + GregtechItemList.Battery_Gem_3.get(1), + GregtechItemList.Battery_Gem_4.get(1), + }; + + ItemStack[] aExoticInputs = new ItemStack[] { + Particle.getBaseParticle(Particle.PROTON), + Particle.getBaseParticle(Particle.ELECTRON), + Particle.getBaseParticle(Particle.CHARM), + Particle.getBaseParticle(Particle.GRAVITON) + }; + aCasingSlot = 0; + for (int j = 6; j < 10; j++) { + CORE.RA.addAssemblylineRecipe( + aExoticInputs[aCasingSlot], + 20 * 60 * 60 * 5, + new Object[] { + aGemCasings[aCasingSlot], + ItemUtils.getSimpleStack(aExoticInputs[aCasingSlot], 16), + CI.getTieredComponent(OrePrefixes.plate, j, 16), + new Object[] {CI.getTieredCircuitOreDictName(j), 8}, + CI.getTieredComponent(OrePrefixes.wireGt16, j+1, GTNH ? 32 : 16), + CI.getTieredComponent(OrePrefixes.bolt, j, GTNH ? 8 : 4), + CI.getTieredComponent(OrePrefixes.screw, j-1, GTNH ? 8 : 4), + }, + new FluidStack[] { + CI.getTieredFluid(j, 144 * 1 * (GTNH ? 16 : 8)), + CI.getTertiaryTieredFluid(j-2, 144 * 2 * (GTNH ? 16 : 8)), + CI.getAlternativeTieredFluid(j, 144 * (GTNH ? 16 : 8)), + CI.getTertiaryTieredFluid(j-1, 144 * (GTNH ? 16 : 8)), + }, + aGemBatteries[aCasingSlot++], + 20 * 60 * 1 * (GTNH ? 2 : 1), + (int) MaterialUtils.getVoltageForTier(j)); + } + + + if (LoadedMods.Baubles) { + //Nano Healer + CORE.RA.addAssemblylineRecipe( + ItemUtils.simpleMetaStack(Items.golden_apple, 1, 1), + 20 * 60 * 10, + new Object[] { + ItemUtils.getSimpleStack(aGemCasings[2], GTNH ? 4 : 2), + CI.getTieredComponent(OrePrefixes.plate, 8, GTNH ? 32 : 16), + new Object[] {CI.getTieredCircuitOreDictName(7), 16}, + CI.getTieredComponent(OrePrefixes.cableGt02, 7, GTNH ? 16 : 8), + CI.getTieredComponent(OrePrefixes.gearGt, 6, GTNH ? 6 : 3), + CI.getTieredComponent(OrePrefixes.screw, 7, GTNH ? 16 : 8), + CI.getTieredComponent(OrePrefixes.bolt, 5, GTNH ? 24 : 12), + CI.getTieredComponent(OrePrefixes.frameGt, 4, GTNH ? 12 : 6), + aCoilWire[3] + }, + new FluidStack[] { + CI.getTieredFluid(7, 144 * 18 * (GTNH ? 16 : 8)), + CI.getTertiaryTieredFluid(7, 144 * 18 * (GTNH ? 16 : 8)), + CI.getAlternativeTieredFluid(6, 144 * 18 * (GTNH ? 16 : 8)), + CI.getAlternativeTieredFluid(7, 144 * 18 * (GTNH ? 16 : 8)), + + }, + ItemUtils.getItemStackFromFQRN("miscutils:personalHealingDevice", 1), + 20 * 60 * 30 * (GTNH ? 2 : 1), + (int) MaterialUtils.getVoltageForTier(7)); + + + + //Charge Pack LuV-UV + + ItemStack[] aChargeResearch = new ItemStack[] { + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore7", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore8", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore9", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore10", 1), + }; + + ItemStack[] aChargeOutputs = new ItemStack[] { + ItemUtils.getSimpleStack(ModItems.itemChargePack_High_1, 1), + ItemUtils.getSimpleStack(ModItems.itemChargePack_High_2, 1), + ItemUtils.getSimpleStack(ModItems.itemChargePack_High_3, 1), + ItemUtils.getSimpleStack(ModItems.itemChargePack_High_4, 1), + }; + + int aCurrSlot = 0; + for (int h = 6; h < 10; h++) { + CORE.RA.addAssemblylineRecipe( + aChargeResearch[aCurrSlot], + 20 * 60 * 10 * (aCurrSlot + 1), + new Object[] { + ItemUtils.getSimpleStack(aGemBatteries[aCurrSlot],2), + aCoilWire[aCurrSlot], + CI.getTieredComponent(OrePrefixes.plate, h, 8), + new Object[] {CI.getTieredCircuitOreDictName(h), 4}, + new Object[] {CI.getTieredCircuitOreDictName(h-1), 8}, + CI.getTieredComponent(OrePrefixes.cableGt12, h-1, 16), + CI.getTieredComponent(OrePrefixes.screw, h, GTNH ? 16 : 8), + CI.getTieredComponent(OrePrefixes.bolt, h-2, GTNH ? 32 : 16), + CI.getFieldGenerator(h, 1), + }, + new FluidStack[] { + CI.getTieredFluid(h, 144 * 4 * (GTNH ? 8 : 4)), + CI.getTertiaryTieredFluid(h-1, 144 * 4 * (GTNH ? 8 : 4)), + CI.getAlternativeTieredFluid(h-1, 144 * 4 * (GTNH ? 8 : 4)), + CI.getAlternativeTieredFluid(h-2, 144 * 4 * (GTNH ? 8 : 4)), + }, + aChargeOutputs[aCurrSlot], + 20 * 60 * 30 * (GTNH ? 2 : 1) * (aCurrSlot+1), + (int) MaterialUtils.getVoltageForTier(h)); + aCurrSlot++; + } + + //Cloaking device + CORE.RA.addAssemblylineRecipe( + ItemDummyResearch.getResearchStack(ASSEMBLY_LINE_RESEARCH.RESEARCH_9_CLOAKING, 1), + 20 * 60 * 10, + new Object[] { + ItemUtils.getSimpleStack(aGemCasings[3], GTNH ? 4 : 2), + CI.getTieredComponent(OrePrefixes.plate, 8, GTNH ? 32 : 16), + new Object[] {CI.getTieredCircuitOreDictName(7), 16}, + CI.getTieredComponent(OrePrefixes.cableGt04, 8, GTNH ? 16 : 8), + CI.getTieredComponent(OrePrefixes.gearGt, 7, GTNH ? 6 : 3), + CI.getTieredComponent(OrePrefixes.screw, 8, GTNH ? 16 : 8), + CI.getTieredComponent(OrePrefixes.bolt, 7, GTNH ? 24 : 12), + CI.getTieredComponent(OrePrefixes.frameGt, 5, GTNH ? 12 : 6), + aCoilWire[3] + }, + new FluidStack[] { + CI.getTieredFluid(8, 144 * 18 * (GTNH ? 16 : 8)), + CI.getTertiaryTieredFluid(8, 144 * 18 * (GTNH ? 16 : 8)), + CI.getAlternativeTieredFluid(7, 144 * 18 * (GTNH ? 16 : 8)), + CI.getAlternativeTieredFluid(8, 144 * 18 * (GTNH ? 16 : 8)), + + }, + ItemUtils.getItemStackFromFQRN("miscutils:personalCloakingDevice", 1), + 20 * 60 * 30 * (GTNH ? 2 : 1), + (int) MaterialUtils.getVoltageForTier(8)); + } + + + + + + + + + + } + + private static void laserEngraverRecipes() { + + // Laser Sensors and Emitters together + GregtechItemList[] aTransParts = new GregtechItemList[] { + GregtechItemList.TransmissionComponent_ULV, + GregtechItemList.TransmissionComponent_LV, + GregtechItemList.TransmissionComponent_MV, + GregtechItemList.TransmissionComponent_HV, + GregtechItemList.TransmissionComponent_EV, + GregtechItemList.TransmissionComponent_IV, + GregtechItemList.TransmissionComponent_LuV, + GregtechItemList.TransmissionComponent_ZPM, + GregtechItemList.TransmissionComponent_UV, + GregtechItemList.TransmissionComponent_MAX, + }; + for (int i=0;i<10;i++) { + GT_Values.RA.addLaserEngraverRecipe( + CI.getEmitter(i, 2), + CI.getSensor(i, 2), + aTransParts[i].get(1), + 20 * 5, + MaterialUtils.getVoltageForTier(i)); + } + + + + GT_Values.RA.addLaserEngraverRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tungsten, 6L), + GregtechItemList.Laser_Lens_Special.get(0), + ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN.getDust(1), + 20 * 60 * 3, + MaterialUtils.getVoltageForTier(ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN.vTier)); + + GT_Values.RA.addLaserEngraverRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Titanium, 8L), + GregtechItemList.Laser_Lens_Special.get(0), + ELEMENT.STANDALONE.ASTRAL_TITANIUM.getDust(1), + 20 * 60 * 2, + MaterialUtils.getVoltageForTier(ELEMENT.STANDALONE.ASTRAL_TITANIUM.vTier)); + + GT_Values.RA.addLaserEngraverRecipe( + ALLOY.NITINOL_60.getBlock(2), + GregtechItemList.Laser_Lens_Special.get(0), + ELEMENT.STANDALONE.ADVANCED_NITINOL.getBlock(1), + 20 * 60 * 1, + MaterialUtils.getVoltageForTier(ELEMENT.STANDALONE.ADVANCED_NITINOL.vTier)); + + GT_Values.RA.addLaserEngraverRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Glass, 64L), + GregtechItemList.Laser_Lens_Special.get(0), + ELEMENT.STANDALONE.CHRONOMATIC_GLASS.getDust(1), + 20 * 60 * 5, + MaterialUtils.getVoltageForTier(ELEMENT.STANDALONE.CHRONOMATIC_GLASS.vTier)); + + + GT_Values.RA.addLaserEngraverRecipe( + CI.getFieldGenerator(6, 1), + CI.getEmitter(7, 2), + ItemDummyResearch.getResearchStack(ASSEMBLY_LINE_RESEARCH.RESEARCH_1_CONTAINMENT, 1), + 20 * 60 * 5, + MaterialUtils.getVoltageForTier(5)); + + // Distillus Upgrade Chip + GT_Values.RA.addLaserEngraverRecipe( + GregtechItemList.Laser_Lens_WoodsGlass.get(0), + ItemUtils.simpleMetaStack(AgriculturalChem.mBioCircuit, 20, 1), + GregtechItemList.Distillus_Upgrade_Chip.get(1), + 20 * 60 * 5, + MaterialUtils.getVoltageForTier(5)); + + + + + } + + private static void breweryRecipes() { + CORE.RA.addBrewingRecipe(14, EnchantingUtils.getMobEssence(100), EnchantingUtils.getLiquidXP(1332), 100, 120, false); + CORE.RA.addBrewingRecipe(14, EnchantingUtils.getLiquidXP(1332), EnchantingUtils.getMobEssence(100), 100, 120, false); + CORE.RA.addBrewingRecipe(ItemUtils.getSimpleStack(BOP_Block_Registrator.sapling_Rainforest), FluidUtils.getFluidStack("water", 100), FluidUtils.getFluidStack("biomass", 100), 1200, 3, false); + CORE.RA.addBrewingRecipe(ItemUtils.getSimpleStack(BOP_Block_Registrator.sapling_Rainforest), FluidUtils.getFluidStack("honey", 100), FluidUtils.getFluidStack("biomass", 150), 1200, 3, false); + CORE.RA.addBrewingRecipe(ItemUtils.getSimpleStack(BOP_Block_Registrator.sapling_Rainforest), FluidUtils.getFluidStack("juice", 100), FluidUtils.getFluidStack("biomass", 150), 1200, 3, false); + } + + private static void cuttingSawRecipes() { + GT_Values.RA.addCutterRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("blockMeatRaw", 1), //Input + ItemUtils.getItemStackOfAmountFromOreDict("plateMeatRaw", 9), //Output + null, + 16, //Time + 8); //EU + } + + private static void electrolyzerRecipes() { + GT_Values.RA.addElectrolyzerRecipe( + ItemUtils.getSimpleStack(ModItems.dustDecayedRadium226, 1), + null, + null, + FluidUtils.getFluidStack("radon", !GTNH ? 500 : 144), + null, + null, + null, + null, + null, + null, + new int[]{}, + 20*90, + 240); + } + + private static void extruderRecipes() { + // Osmium Credits + if (GT_Values.RA.addExtruderRecipe(ItemUtils.getItemStackOfAmountFromOreDict("blockOsmium", 1), + ItemList.Shape_Mold_Credit.get(0), ItemList.Credit_Greg_Osmium.get(1), + (int) Math.max(Materials.Osmium.getMass() * 2L * 20, 1), 1024)) { + Logger.WARNING("Extruder Recipe: Osmium Credit - Success"); + } + else { + Logger.WARNING("Extruder Recipe: Osmium Credit - Failed"); + } + } + + private static void blastSmelterRecipes() { + + if (!GTNH) { + // Trinium + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(8), + ELEMENT.getInstance().BISMUTH.getDust(8), + ELEMENT.getInstance().IRON.getDust(64), + ELEMENT.getInstance().CARBON.getDust(16), + ELEMENT.getInstance().GOLD.getDust(16), + ELEMENT.getInstance().SILVER.getDust(16), + ELEMENT.getInstance().OSMIUM.getDust(4), + ELEMENT.getInstance().IRIDIUM.getDust(4), + ELEMENT.getInstance().CERIUM.getDust(8) + }, + FluidUtils.getFluidStack("molten.trinium", 136 * 144), 0, 20 * 3000, + 2040*4); + } + + //Eglin Steel + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(6), + ELEMENT.getInstance().IRON.getDust(4), + ALLOY.KANTHAL.getDust(1), + ALLOY.INVAR.getDust(5), + ELEMENT.getInstance().SULFUR.getDust(1), + ELEMENT.getInstance().CARBON.getDust(1), + ELEMENT.getInstance().SILICON.getDust(4) + }, + ALLOY.EGLIN_STEEL.getFluidStack(16 * 144), + 0, + 20 * 45, + 120); + + //HG1223 + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(5), + ELEMENT.getInstance().MERCURY.getCell(1), + ELEMENT.getInstance().BARIUM.getDust(2), + ELEMENT.getInstance().CALCIUM.getDust(2), + ELEMENT.getInstance().COPPER.getDust(3), + }, + ELEMENT.getInstance().OXYGEN.getFluidStack(8000), + ALLOY.HG1223.getFluidStack(16 * 144), + new ItemStack[] { + CI.emptyCells(1) + }, + new int[] {10000}, //Output Chance + 20 * 120, + 30720); + + //NITINOL_60 + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(2), + ELEMENT.getInstance().TITANIUM.getDust(3), + ELEMENT.getInstance().NICKEL.getDust(2) + }, + ALLOY.NITINOL_60.getFluidStack(5 * 144), + 0, + 20 * 75, + 7680); + + + + + + // Germanium Roasting + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(15), + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedSphalerite", 8), + ELEMENT.getInstance().CARBON.getDust(32), + }, + Materials.SulfuricAcid.getFluid(2000), + ELEMENT.getInstance().GERMANIUM.getFluidStack(288), + 0, + 20 * 300, + 4000); + + + // Ruthenium Roasting + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(19), + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedIridium", 8), + ELEMENT.getInstance().CARBON.getDust(32), + }, + Materials.SulfuricAcid.getFluid(2000), + ELEMENT.getInstance().RUTHENIUM.getFluidStack(288), + 0, + 20 * 300, + 8000); + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(19), + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedOsmium", 8), + ELEMENT.getInstance().CARBON.getDust(32), + }, + Materials.SulfuricAcid.getFluid(2000), + ELEMENT.getInstance().RUTHENIUM.getFluidStack(288), + 0, + 20 * 300, + 8000); + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(19), + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedPlatinum", 8), + ELEMENT.getInstance().CARBON.getDust(32), + }, + Materials.SulfuricAcid.getFluid(2000), + ELEMENT.getInstance().RUTHENIUM.getFluidStack(288), + 0, + 20 * 300, + 8000); + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(19), + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedCooperite", 8), + ELEMENT.getInstance().CARBON.getDust(32), + }, + Materials.SulfuricAcid.getFluid(8000), + ELEMENT.getInstance().RUTHENIUM.getFluidStack(144), + 0, + 20 * 300, + 8000); + + // Rhenium Roasting + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(20), + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedScheelite", 8), + ELEMENT.getInstance().CARBON.getDust(32), + }, + Materials.SulfuricAcid.getFluid(10000), + ELEMENT.getInstance().RHENIUM.getFluidStack(144), + 0, + 20 * 300, + 4000); + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(20), + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedMolybdenite", 8), + ELEMENT.getInstance().CARBON.getDust(32), + }, + Materials.SulfuricAcid.getFluid(7500), + ELEMENT.getInstance().RHENIUM.getFluidStack(144), + 0, + 20 * 300, + 4000); + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(20), + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedMolybdenum", 8), + ELEMENT.getInstance().CARBON.getDust(32), + }, + Materials.SulfuricAcid.getFluid(5000), + ELEMENT.getInstance().RHENIUM.getFluidStack(288), + 0, + 20 * 300, + 4000); + + //Thallium Roasting + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(21), + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedIron", 12), + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedPyrite", 16), + ELEMENT.getInstance().CARBON.getDust(64), + }, + Materials.SulfuricAcid.getFluid(5000), + ELEMENT.getInstance().THALLIUM.getFluidStack(288+144), + 0, + 20 * 300, + 8000); + + + + //Strontium processing + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(21), + MISC_MATERIALS.STRONTIUM_OXIDE.getDust(8), + ELEMENT.getInstance().ALUMINIUM.getDust(8), + }, + null, + ELEMENT.getInstance().OXYGEN.getFluidStack(8000), + new ItemStack[] { + ELEMENT.getInstance().ALUMINIUM.getIngot(8), + ELEMENT.getInstance().STRONTIUM.getIngot(8) + }, + new int[] {10000, 10000}, //Output Chance + 20 * 120, + 480*4); + + + //Wood's Glass Laser Lens + CORE.RA.addBlastSmelterRecipe( + new ItemStack[] { + ItemUtils.getGregtechCircuit(5), + ItemList.Shape_Mold_Ball.get(0), + ELEMENT.getInstance().BARIUM.getDust(1), + ELEMENT.getInstance().SODIUM.getDust(1), + ELEMENT.getInstance().SILICON.getDust(2), + ELEMENT.getInstance().NICKEL.getDust(1), + ItemUtils.getItemStackOfAmountFromOreDict("dustGlass", 5) + }, + FluidUtils.getUUM(1000), + null, + new ItemStack[] { + GregtechItemList.Laser_Lens_WoodsGlass.get(1) + }, + new int[] {10000}, + 20 * 300, + (int) GT_Values.V[3]); + + + + } + + private static void fluidcannerRecipes() { + // Sulfuric Acid + CORE.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(Items.glass_bottle), + ItemUtils.getSimpleStack(ModItems.itemSulfuricPotion), FluidUtils.getFluidStack("sulfuricacid", 250), + null); + CORE.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(ModItems.itemSulfuricPotion), + ItemUtils.getSimpleStack(Items.glass_bottle), null, FluidUtils.getFluidStack("sulfuricacid", 250)); + + + + // Hydrofluoric Acid + boolean addedGtExtraction = false; + // Try use Internal GT Fluid first + if (Utils.getGregtechVersionAsInt() >= 50929) { + // Hydrofluoric Acid + CORE.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(Items.glass_bottle), + ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), + FluidUtils.getFluidStack("hydrofluoricacid_gt5u", 250), null); + addedGtExtraction = CORE.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), + ItemUtils.getSimpleStack(Items.glass_bottle), null, FluidUtils.getFluidStack("hydrofluoricacid_gt5u", 250)); + } + //Add a Fill recipe for GT++ Acid + CORE.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(Items.glass_bottle), + ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), + FluidUtils.getFluidStack("hydrofluoricacid", 125), null); + //Add an empty recipe, but only if we didn't for the standard GT HF. Prevents Fluid transformation exploits. + if (!addedGtExtraction) { + CORE.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), ItemUtils.getSimpleStack(Items.glass_bottle), null, FluidUtils.getFluidStack("hydrofluoricacid", 125)); + } + + //Gelid Cryotheum + CORE.RA.addFluidExtractionRecipe(ItemUtils.getItemStackOfAmountFromOreDict("dustCryotheum", 1), FluidUtils.getFluidStack("cryotheum", 250), 200, 240); + + //Ender Fluid + CORE.RA.addFluidExtractionRecipe(ItemUtils.getSimpleStack(Items.ender_pearl), FluidUtils.getFluidStack("ender", 250), 100, 30); + + //Blazing Pyrotheum + CORE.RA.addFluidExtractionRecipe(ItemUtils.getItemStackOfAmountFromOreDict("dustPyrotheum", 1), FluidUtils.getFluidStack("pyrotheum", 250), 200, 240); + + + } + + private static void cokeOvenRecipes() { + Logger.INFO("Loading Recipes for Industrial Coking Oven."); + // Wood to Charcoal + //Try use all woods found + ArrayList aLogData = OreDictionary.getOres("logWood"); + if (aLogData.isEmpty()) { + AddGregtechRecipe.addCokeAndPyrolyseRecipes(GT_OreDictUnificator.get(OrePrefixes.log, Materials.Wood, 20L), 20, + GT_ModHandler.getSteam(1000), GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Charcoal, 24L), + FluidUtils.getFluidStack("fluid.coalgas", 1440), 60, 30); } + else { + for (ItemStack stack : aLogData) { + AddGregtechRecipe.addCokeAndPyrolyseRecipes(ItemUtils.getSimpleStack(stack, 20), 20, + GT_ModHandler.getSteam(1000), GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Charcoal, 24L), + FluidUtils.getFluidStack("fluid.coalgas", 1440), 60, 30); + } + } + + // Coal to Coke + AddGregtechRecipe.addCokeAndPyrolyseRecipes(GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 16L), 22, + GT_ModHandler.getSteam(1000), ItemUtils.getItemStackOfAmountFromOreDict("fuelCoke", 10), + FluidUtils.getFluidStack("fluid.coalgas", 2880), 30, 120); + + // Coke & Coal + CORE.RA.addCokeOvenRecipe(GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 12L), + ItemUtils.getItemStackOfAmountFromOreDict("fuelCoke", 6), GT_ModHandler.getSteam(2000), + FluidUtils.getFluidStack("fluid.coalgas", 5040), + ItemUtils.getItemStackOfAmountFromOreDict("fuelCoke", 14), 60 * 20, 240); + + } + + private static void matterFabRecipes() { + Logger.INFO("Loading Recipes for Matter Fabricator."); + + try { + + CORE.RA.addMatterFabricatorRecipe(Materials.UUAmplifier.getFluid(1L), // Fluid + // Input + Materials.UUMatter.getFluid(1L), // Fluid Output + 800, // Time in ticks + 32); // EU + } + catch (final NullPointerException e) { + Logger.INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE"); + } + try { + + CORE.RA.addMatterFabricatorRecipe(null, // Fluid Input + Materials.UUMatter.getFluid(1L), // Fluid Output + 3200, // Time in ticks + 32); // EU + } + catch (final NullPointerException e) { + Logger.INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE"); + } + + } + + private static void dehydratorRecipes() { + Logger.INFO("Loading Recipes for Chemical Dehydrator."); + + + ItemStack cropGrape = ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cropGrape", 1); + ItemStack foodRaisins = ItemUtils.getItemStackOfAmountFromOreDictNoBroken("foodRaisins", 1); + + if (cropGrape != null && foodRaisins != null) + CORE.RA.addDehydratorRecipe(new ItemStack[] { + CI.getNumberedBioCircuit(20), + cropGrape + }, // Item + null, // Fluid input (slot 1) + null, // Fluid output (slot 2) + new ItemStack[] { + foodRaisins + }, // Output + new int[] { 10000 }, + 10, // Time in ticks + 2); // EU + + + + // Process Waste Water + CORE.RA.addDehydratorRecipe( + new ItemStack[] { + CI.getNumberedBioCircuit(21) + }, + FluidUtils.getFluidStack("fluid.sludge", 1000), + FluidUtils.getFluidStack("nitricacid", 10), + new ItemStack[] { + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyIron", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyCopper", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyTin", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyNickel", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyCobalt", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyAluminium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinySilver", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyGold", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyIridium", 1) }, + new int[] { 10, 5, 5, 4, 4, 3, 2, 2, 1 }, + 2 * 20, + 500); // EU + + // CaF2 + H2SO4 → CaSO4(solid) + 2 HF + FluidStack aGregtechHydro = FluidUtils.getFluidStack("hydrofluoricacid_gt5u", 16000); + if (aGregtechHydro == null) { + aGregtechHydro = FluidUtils.getFluidStack("hydrofluoricacid", 16000); + } + + CORE.RA.addDehydratorRecipe( + new ItemStack[] { + CI.getNumberedAdvancedCircuit(5), + ItemUtils.getItemStackOfAmountFromOreDict("dustFluorite", 37), + }, + FluidUtils.getFluidStack("sulfuricacid", 56 * 144), + aGregtechHydro, // Fluid output (slot 2) + new ItemStack[] { + ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumSulfate", 30), + ItemUtils.getItemStackOfAmountFromOreDict("dustSilver", 1)