diff options
Diffstat (limited to 'src/Java/gtPlusPlus/core/recipe')
11 files changed, 1808 insertions, 0 deletions
diff --git a/src/Java/gtPlusPlus/core/recipe/Gregtech_Recipe_Adder.java b/src/Java/gtPlusPlus/core/recipe/Gregtech_Recipe_Adder.java new file mode 100644 index 0000000000..0f31c4c61d --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/Gregtech_Recipe_Adder.java @@ -0,0 +1,98 @@ +package gtPlusPlus.core.recipe; + +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_ModHandler; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.item.UtilsItems; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +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( + Item maceratorInput, int maceratorInputAmount1, + Item maceratorOutput, int maceratorOutputAmount1, + Item compressorInput, int compressorInputAmount1, + Item compressorOutput, int compressorOutputAmount1, + Item blastFurnaceInput, int blastFurnaceInputAmount1, + Item blastFurnaceOutput, int blastFurnaceOutputAmount1, + Item blastFurnaceInput2, int blastFurnaceInputAmount2, + Item blastFurnaceOutput2, int blastFurnaceOutputAmount2, + Item smeltingInput, int smeltingInputAmount1, + Item smeltingOutput, int smeltingOutputAmount1, + + int euPerTick, int timeInTicks, + boolean addMaceratorRecipe, boolean addCompressorRecipe, boolean addBlastFurnaceRecipe, int blastFurnaceTemp, boolean addSmeltingRecipe, boolean addMixerRecipe){ + euT = euPerTick; + ticks = timeInTicks; + + resetVars(); + if (addMaceratorRecipe){ + inputStack1 = UtilsItems.getSimpleStack(maceratorInput, maceratorInputAmount1); + outputStack1 = UtilsItems.getSimpleStack(maceratorOutput, maceratorOutputAmount1); + addMaceratorRecipe(inputStack1, outputStack1); + } + resetVars(); + if (addCompressorRecipe){ + inputStack1 = UtilsItems.getSimpleStack(compressorInput, compressorInputAmount1); + outputStack1 = UtilsItems.getSimpleStack(compressorOutput, compressorOutputAmount1); + addCompressorRecipe(inputStack1, outputStack1); + } + resetVars(); + if (addBlastFurnaceRecipe){ + inputStack1 = UtilsItems.getSimpleStack(blastFurnaceInput, blastFurnaceInputAmount1); + inputStack2 = UtilsItems.getSimpleStack(blastFurnaceInput2, blastFurnaceInputAmount2); + outputStack1 = UtilsItems.getSimpleStack(blastFurnaceOutput, blastFurnaceOutputAmount1); + outputStack2 = UtilsItems.getSimpleStack(blastFurnaceOutput2, blastFurnaceOutputAmount2); + addBlastFurnaceRecipe(inputStack1, inputStack2, outputStack1, outputStack2, blastFurnaceTemp); + } + resetVars(); + if (addSmeltingRecipe){ + inputStack1 = UtilsItems.getSimpleStack(smeltingInput, smeltingInputAmount1); + outputStack1 = UtilsItems.getSimpleStack(smeltingOutput, smeltingOutputAmount1); + addSmeltingRecipe(inputStack1, outputStack1); + } + resetVars(); + + } + + private static void resetVars(){ + inputStack1 = null; + inputStack2 = null; + outputStack1 = null; + outputStack2 = null; + } + + private static void addMaceratorRecipe(ItemStack input1, ItemStack output1){ + GT_ModHandler.addPulverisationRecipe(input1, output1); + } + + private static void addCompressorRecipe(ItemStack input1, ItemStack output1){ + GT_ModHandler.addCompressionRecipe(input1, output1); + } + + private static void addBlastFurnaceRecipe(ItemStack input1, ItemStack input2, ItemStack output1, ItemStack output2, int tempRequired){ + Utils.LOG_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(ItemStack input1, ItemStack output1){ + GT_ModHandler.addSmeltingRecipe(input1, output1); + } + +} diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java new file mode 100644 index 0000000000..addeb8b74a --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java @@ -0,0 +1,233 @@ +package gtPlusPlus.core.recipe; + +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 gtPlusPlus.core.item.ModItems; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.fluid.FluidUtils; +import gtPlusPlus.core.util.item.UtilsItems; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import net.minecraft.item.ItemStack; + +public class RECIPES_GREGTECH { + + public static void run(){ + Utils.LOG_INFO("Loading Recipes through GregAPI for Industrial Multiblocks."); + execute(); + } + + private static void execute(){ + cokeOvenRecipes(); + matterFabRecipes(); + assemblerRecipes(); + distilleryRecipes(); + extractorRecipes(); + chemicalBathRecipes(); + dehydratorRecipes(); + addFuels(); + } + + private static void cokeOvenRecipes(){ + Utils.LOG_INFO("Loading Recipes for Industrial Coking Oven."); + + try { + + //GT Logs to Charcoal Recipe + //With Sulfuric Acid + CORE.RA.addCokeOvenRecipe( + GT_OreDictUnificator.get(OrePrefixes.log, Materials.Wood, 1L), //Input 1 + GT_OreDictUnificator.get(OrePrefixes.log, Materials.Wood, 1L), //Input 2 + Materials.SulfuricAcid.getFluid(20L), //Fluid Input + Materials.Creosote.getFluid(175L), //Fluid Output + GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Charcoal, 2L), //Item Output + 800, //Time in ticks + 30); //EU + }catch (NullPointerException e){Utils.LOG_INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");} + try { + + //Coal -> Coke Recipe + //With Sulfuric Acid + CORE.RA.addCokeOvenRecipe( + GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 1L), //Input 1 + GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 1L), //Input 2 + Materials.SulfuricAcid.getFluid(60L), //Fluid Input + Materials.Creosote.getFluid(250L), //Fluid Output + UtilsItems.getItemStack("Railcraft:fuel.coke", 2), //Item Output + 600, //Time in ticks + 120); //EU + }catch (NullPointerException e){Utils.LOG_INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");} + + try { + //GT Logs to Charcoal Recipe + //Without Sulfuric Acid + CORE.RA.addCokeOvenRecipe( + GT_OreDictUnificator.get(OrePrefixes.log, Materials.Wood, 1L), //Input 1 + GT_OreDictUnificator.get(OrePrefixes.log, Materials.Wood, 1L), //Input 2 + FluidUtils.getFluidStack("oxygen", 80), //Fluid Input + Materials.Creosote.getFluid(145L), //Fluid Output + GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Charcoal, 2L), //Item Output + 1200, //Time in ticks + 30); //EU + }catch (NullPointerException e){Utils.LOG_INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");} + + try { + //Coal -> Coke Recipe + //Without Sulfuric Acid + CORE.RA.addCokeOvenRecipe( + GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 1L), //Input 1 + GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 1L), //Input 2 + FluidUtils.getFluidStack("oxygen", 185), //Fluid Input + Materials.Creosote.getFluid(200L), //Fluid Output + UtilsItems.getItemStack("Railcraft:fuel.coke", 2), //Item Output + 900, //Time in ticks + 120); //EU + }catch (NullPointerException e){Utils.LOG_INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");} + } + + private static void matterFabRecipes(){ + Utils.LOG_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 (NullPointerException e){Utils.LOG_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 (NullPointerException e){Utils.LOG_INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");} + + } + + private static void dehydratorRecipes(){ + Utils.LOG_INFO("Loading Recipes for Chemical Dehydrator."); + + try { + + //Makes Lithium Carbonate + CORE.RA.addDehydratorRecipe( + FluidUtils.getFluidStack("sulfuriclithium", 1000), //Item input (slot 1) + null, //Fluid Input + new ItemStack[]{ + UtilsItems.getItemStackOfAmountFromOreDict("dustSodium", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustCarbon", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustLithium", 1) + }, //Output Array of Items - Upto 9 + 10*20, //Time in ticks + 30); //EU + }catch (NullPointerException e){Utils.LOG_INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");} + try { + + CORE.RA.addDehydratorRecipe( + UtilsItems.getItemStackOfAmountFromOreDict("cellEmpty", 1), //Item input (slot 1) + FluidUtils.getFluidStack("sulfuriclithium", 1000), //Fluid Input + new ItemStack[]{ + UtilsItems.getItemStackOfAmountFromOreDict("dustSodium", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustCarbon", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustLithium", 1) + }, //Output Array of Items - Upto 9 + 10*20, //Time in ticks + 30); //EU + }catch (NullPointerException e){Utils.LOG_INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");} + try { + CORE.RA.addDehydratorRecipe( + UtilsItems.getItemStackOfAmountFromOreDict("cellEmpty", 1), //Item input (slot 1) + UtilsItems.getItemStackOfAmountFromOreDict("cellWater", 1), //Item input (slot 2) + new ItemStack[]{ + UtilsItems.getItemStackOfAmountFromOreDict("dustSodium", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustCarbon", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustLithium", 1) + }, //Output Array of Items - Upto 9 + 10*20, //Time in ticks + 30); //EU + }catch (NullPointerException e){Utils.LOG_INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");} + try { + CORE.RA.addDehydratorRecipe( + UtilsItems.getItemStackOfAmountFromOreDict("cellEmpty", 1), + null, + FluidUtils.getFluidStack("sulfuriclithium", 1000), + new ItemStack[]{ + UtilsItems.getItemStackOfAmountFromOreDict("dustSodium", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustCarbon", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustLithium", 1) + }, //Output Array of Items - Upto 9 + FluidUtils.getFluidStack("water", 1000), + 10*20, //Time in ticks + 30); //EU + + }catch (NullPointerException e){Utils.LOG_INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");} + + try { + CORE.RA.addDehydratorRecipe( + null, //Item input (slot 1) + null, //Item input (slot 2) + FluidUtils.getFluidStack("sulfuriclithium", 1000), //Fluid input (slot 1) + null, //Fluid output (slot 1) + new ItemStack[]{ + UtilsItems.getItemStackOfAmountFromOreDict("dustSodium", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustCarbon", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustLithium", 1) + }, //Output Array of Items - Upto 9, + new int[]{0}, + 10*20, //Time in ticks + 30); //EU + + }catch (NullPointerException e){Utils.LOG_INFO("FAILED TO LOAD RECIPES - NULL POINTER SOMEWHERE");} + } + + private static void assemblerRecipes(){ + //GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Titanium, 6L), ItemList.Casing_Turbine.get(1L, new Object[0]), ItemList.Casing_Turbine2.get(1L, new Object[0]), 50, 16); + //GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.TungstenSteel, 6L), ItemList.Casing_Turbine.get(1L, new Object[0]), ItemList.Casing_Turbine3.get(1L, new Object[0]), 50, 16); + + } + + private static void distilleryRecipes(){ + Utils.LOG_INFO("Registering Distillery/Distillation Tower Recipes."); + GT_Values.RA.addDistilleryRecipe(ItemList.Circuit_Integrated.getWithDamage(0L, 4L, new Object[0]), FluidUtils.getFluidStack("air", 1000), FluidUtils.getFluidStack("helium", 1), 400, 30, false); + GT_Values.RA.addDistillationTowerRecipe(FluidUtils.getFluidStack("air", 20000), FluidUtils.getFluidStackArray("helium", 25), UtilsItems.getSimpleStack(ModItems.itemHeliumBlob, 1), 200, 60); + } + + private static void addFuels(){ + Utils.LOG_INFO("Registering New Fuels."); + GT_Values.RA.addFuel(UtilsItems.simpleMetaStack("EnderIO:bucketFire_water", 0, 1), null, 120, 0); + GT_Values.RA.addFuel(UtilsItems.simpleMetaStack("EnderIO:bucketRocket_fuel", 0, 1), null, 112, 0); + GT_Values.RA.addFuel(UtilsItems.simpleMetaStack("EnderIO:bucketHootch", 0, 1), null, 36, 0); + //System.exit(1); + } + + private static void extractorRecipes(){ + Utils.LOG_INFO("Registering Extractor Recipes."); + GT_ModHandler.addExtractionRecipe(GregtechItemList.Battery_RE_EV_Sodium.get(1L, new Object[0]), ItemList.Battery_Hull_HV.get(4L, new Object[0])); + GT_ModHandler.addExtractionRecipe(GregtechItemList.Battery_RE_EV_Cadmium.get(1L, new Object[0]), ItemList.Battery_Hull_HV.get(4L, new Object[0])); + GT_ModHandler.addExtractionRecipe(GregtechItemList.Battery_RE_EV_Lithium.get(1L, new Object[0]), ItemList.Battery_Hull_HV.get(4L, new Object[0])); + } + + private static void chemicalBathRecipes(){ + int[] chances = {10000, 5000, 2500}; + GT_Values.RA.addChemicalBathRecipe(UtilsItems.getItemStackOfAmountFromOreDict("dustTin", 12), FluidUtils.getFluidStack("chlorine", 2400), + UtilsItems.getItemStackOfAmountFromOreDict("dustZirconium", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustZirconium", 1), + UtilsItems.getItemStackOfAmountFromOreDict("dustZirconium", 1), + chances, + 30*20, + 240); + } + + private static void registerSkookumChoocher(){ + //GT_ModHandler.addCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.toolHeadUniversalSpade, aMaterial, 1L), tBits, new Object[]{"fX", Character.valueOf('X'), OrePrefixes.toolHeadShovel.get(aMaterial)}); + } + + +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_LaserEngraver.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_LaserEngraver.java new file mode 100644 index 0000000000..94a1d85ae3 --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_LaserEngraver.java @@ -0,0 +1,32 @@ +package gtPlusPlus.core.recipe; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OreDictNames; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.IOreRecipeRegistrator; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import net.minecraft.item.ItemStack; + +public class RECIPES_LaserEngraver implements IOreRecipeRegistrator { + public RECIPES_LaserEngraver() { + OrePrefixes.crafting.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) { + if (aOreDictName.equals(OreDictNames.craftingLensBlue.toString())) { + GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.YttriumBariumCuprate, 2L), GT_Utility.copyAmount(0L, new Object[]{aStack}), GregtechItemList.Circuit_Parts_Wiring_IV.get(1L, new Object[0]), 64, 480); + } else if (aOreDictName.equals(OreDictNames.craftingLensYellow.toString())) { + GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Osmium, 2L), GT_Utility.copyAmount(0L, new Object[]{aStack}), GregtechItemList.Circuit_Parts_Wiring_LuV.get(1L, new Object[0]), 64, 1024); + } else if (aOreDictName.equals(OreDictNames.craftingLensCyan.toString())) { + } else if (aOreDictName.equals(OreDictNames.craftingLensRed.toString())) { + } else if (aOreDictName.equals(OreDictNames.craftingLensGreen.toString())) { + GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Naquadah, 2L), GT_Utility.copyAmount(0L, new Object[]{aStack}), GregtechItemList.Circuit_Parts_Wiring_ZPM.get(1L, new Object[0]), 64, 2000); + } else if (aOreDictName.equals(OreDictNames.craftingLensWhite.toString())) { + + } + } +} diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_MTWRAPPER.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_MTWRAPPER.java new file mode 100644 index 0000000000..6d81ba42ad --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_MTWRAPPER.java @@ -0,0 +1,115 @@ +package gtPlusPlus.core.recipe; + +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.item.UtilsItems; +import gtPlusPlus.core.util.recipe.UtilsRecipe; +import gtPlusPlus.core.util.wrapper.var; + +import java.util.ArrayList; + +import net.minecraft.item.ItemStack; + +public class RECIPES_MTWRAPPER { + + public static int MT_RECIPES_LOADED = 0; + public static int MT_RECIPES_FAILED = 0; + + static var chestWood = new var("minecraft:chest>"); + static var slabWood = new var("ore:slabWood>"); + static var gemNetherQuartz = new var("ore:gemNetherQuartz>"); + static var glass = new var("ore:blockGlass>"); + static var sensorDaylight = new var("minecraft:daylight_detector>"); + static var blazeRod = new var("minecraft:blaze_rod>"); + static var saw = new var("ore:craftingToolSaw>"); + static var logWood = new var("ore:logWood>"); + static var button = new var("minecraft:stone_button>"); + static var stoneBlock = new var("minecraft:stone>"); + + public static void run(){ + /*addShaped(button.getStack(2), + null, stoneBlock, null, + null, stoneBlock, null, + null, null, null);*/ + /*addShaped(stoneStick.getStack(1), + stoneBlock, null, null, + stoneBlock, null, null, + null, null, null);*/ + addShaped(chestWood.getStack(2), + logWood, logWood, logWood, + logWood, null, logWood, + logWood, logWood, logWood); + addShaped(chestWood.getStack(4), + logWood, logWood, logWood, + logWood, saw, logWood, + logWood, logWood, logWood); + //Recipe Fixes + //remove(sensorDaylight); + addShaped(sensorDaylight.getStack(1), + glass, glass, glass, + gemNetherQuartz, gemNetherQuartz, gemNetherQuartz, + slabWood, slabWood, slabWood); + /*addShaped(ironBars .getStack( 8), + null, "<ore:craftingToolWrench>", null, + "<ore:stickAnyIron>", "<ore:stickAnyIron>", "<ore:stickAnyIron>", + "<ore:stickAnyIron>", "<ore:stickAnyIron>", "<ore:stickAnyIron>");*/ + } + + + public static void addShaped(Object item_Output, + Object item_1, Object item_2, Object item_3, + Object item_4, Object item_5, Object item_6, + Object item_7, Object item_8, Object item_9){ + + + /* + * + * var item_1, var item_2, var item_3, + var item_4, var item_5, var item_6, + var item_7, var item_8, var item_9 + * + * + */ + + ItemStack outputItem = UtilsItems.getCorrectStacktype(item_Output, 1); + + ArrayList<Object> validSlots = new ArrayList<Object>(); + String a,b,c,d,e,f,g,h,i; + if (item_1 == null){ a = " ";} else { a = "1";validSlots.add('1');validSlots.add(item_1);} + if (item_2 == null){ b = " ";} else { b = "2";validSlots.add('2');validSlots.add(item_2);} + if (item_3 == null){ c = " ";} else { c = "3";validSlots.add('3');validSlots.add(item_3);} + if (item_4 == null){ d = " ";} else { d = "4";validSlots.add('4');validSlots.add(item_4);} + if (item_5 == null){ e = " ";} else { e = "5";validSlots.add('5');validSlots.add(item_5);} + if (item_6 == null){ f = " ";} else { f = "6";validSlots.add('6');validSlots.add(item_6);} + if (item_7 == null){ g = " ";} else { g = "7";validSlots.add('7');validSlots.add(item_7);} + if (item_8 == null){ h = " ";} else { h = "8";validSlots.add('8');validSlots.add(item_8);} + if (item_9 == null){ i = " ";} else { i = "9";validSlots.add('9');validSlots.add(item_9);} + + String lineOne = a+b+c; + String lineTwo = d+e+f; + String lineThree = g+h+i; + validSlots.add(0, lineOne); + validSlots.add(1, lineTwo); + validSlots.add(2, lineThree); + + try { + UtilsRecipe.recipeBuilder((Object[]) validSlots.toArray(), outputItem.copy()); + MT_RECIPES_LOADED++; + } + catch(NullPointerException | ClassCastException k){ + k.getMessage(); + k.getClass(); + k.printStackTrace(); + k.getLocalizedMessage(); + Utils.LOG_WARNING("@@@: Invalid Recipe detected for: "+((var) item_Output).getsanitizedName()); + MT_RECIPES_FAILED++; + } + } + + public static void addShapeless(){ + + } + + + +} + diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_MachineComponents.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_MachineComponents.java new file mode 100644 index 0000000000..f5e3fd1ad5 --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_MachineComponents.java @@ -0,0 +1,299 @@ +package gtPlusPlus.core.recipe; + +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.SubTag; +import gregtech.api.util.GT_OreDictUnificator; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.recipe.UtilsRecipe; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; + +public class RECIPES_MachineComponents { + + //Wire + static String wireTier6 = "wireGt08NiobiumTitanium"; + static String wireTier7 = "wireGt08Osmium"; + static String wireTier8 = "wireGt08Naquadah"; + static String wireTier9 = "wireGt08Superconductor"; + static String wireTier10 = "wireGt16Superconductor"; + + //Wire + static String cableTier6 = "cableGt04Tungsten"; + static String cableTier7 = "cableGt04NiobiumTitanium"; + static String cableTier8 = "cableGt04Osmium"; + static String cableTier9 = "cableGt04Naquadah"; + static String cableTier10 = "wireGt08Superconductor"; + + //Plates + static String plateTier7 = "plateChrome"; + static String plateTier8 = "plateIridium"; + static String plateTier9 = "plateOsmium"; + static String plateTier10 = "plateNeutronium"; + + //rods + static String rodTier7a = "stickChrome"; + static String rodTier8a = "stickIridium"; + static String rodTier9a = "stickOsmium"; + static String rodTier10a = "stickNeutronium"; + static String rodTier7b = "stickPlatinum"; + static String rodTier8b = "stickChrome"; + static String rodTier9b = "stickIridium"; + static String rodTier10b = "stickOsmium"; + static String rodTier7c = "stickTitanium"; + static String rodTier8c = "stickTungstenSteel"; + static String rodTier9c = "stickNaquadah"; + static String rodTier10c = "stickOsmium"; + + //Screws + static String screwTier7 = "screwChrome"; + static String screwTier8 = "screwIridium"; + static String screwTier9 = "screwOsmium"; + static String screwTier10 = "screwNeutronium"; + + //Rotors + static String rotorTier7 = "rotorChrome"; + static String rotorTier8 = "rotorIridium"; + static String rotorTier9 = "rotorOsmium"; + static String rotorTier10 = "rotorNeutronium"; + + //Fluid Pipe + static String pipeTier7 = "pipeHugeSteel"; + static String pipeTier8 = "pipeHugeStainlessSteel"; + static String pipeTier9 = "pipeHugeTitanium"; + static String pipeTier10 = "pipeHugeTungstenSteel"; + + //Rubber Ring/Plate + static String itemRubberRing = "ringRubber"; + static String plateRubber = "plateRubber"; + + //Circuits + static String circuitTier6 = "circuitMaster"; + static String circuitTier7 = "circuitUltimate"; + static String circuitTier8 = "circuitSymbiotic"; + static String circuitTier9 = "circuitNeutronic"; + static String circuitTier10 = "circuitQuantum"; + + //small gears + static String smallGearTier7 = "gearGtSmallChrome"; + static String smallGearTier8 = "gearGtSmallIridium"; + static String smallGearTier9 = "gearGtSmallOsmium"; + static String smallGearTier10 = "gearGtSmallNeutronium"; + + //Crafting Tools + static String craftingToolWrench = "craftingToolWrench"; + static String craftingToolScrewdriver = "craftingToolScrewdriver"; + + public static final void RECIPES_LOAD(){ + Utils.LOG_INFO("Loading Recipes for the Various Circuits and Machine components."); + if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK){ + run(); + } + GregtechMachinePhase(); + } + + private static void run(){ + //Electric Motors + UtilsRecipe.addShapedGregtechRecipe( + cableTier7, wireTier7, rodTier7a, + wireTier7, rodTier7b, wireTier7, + rodTier7a, wireTier7, cableTier7, + RECIPE_CONSTANTS.electricMotor_LuV); + UtilsRecipe.addShapedGregtechRecipe( + cableTier8, wireTier8, rodTier8a, + wireTier8, rodTier8b, wireTier8, + rodTier8a, wireTier8, cableTier8, + RECIPE_CONSTANTS.electricMotor_ZPM); + UtilsRecipe.addShapedGregtechRecipe( + cableTier9, wireTier9, rodTier9a, + wireTier9, rodTier9b, wireTier9, + rodTier9a, wireTier9, cableTier9, + RECIPE_CONSTANTS.electricMotor_UV); + UtilsRecipe.addShapedGregtechRecipe( + cableTier10, wireTier10, rodTier10a, + wireTier10, rodTier10b, wireTier10, + rodTier10a, wireTier10, cableTier10, + RECIPE_CONSTANTS.electricMotor_MAX); + + //Electric Pump + UtilsRecipe.addShapedGregtechRecipe( + cableTier7, rotorTier7, itemRubberRing, + craftingToolScrewdriver, pipeTier7, craftingToolWrench, + itemRubberRing, RECIPE_CONSTANTS.electricMotor_LuV, cableTier7, + RECIPE_CONSTANTS.electricPump_LuV); + UtilsRecipe.addShapedGregtechRecipe( + cableTier8, rotorTier8, itemRubberRing, + craftingToolScrewdriver, pipeTier8, craftingToolWrench, + itemRubberRing, RECIPE_CONSTANTS.electricMotor_ZPM, cableTier8, + RECIPE_CONSTANTS.electricPump_ZPM); + UtilsRecipe.addShapedGregtechRecipe( + cableTier9, rotorTier9, itemRubberRing, + craftingToolScrewdriver, pipeTier9, craftingToolWrench, + itemRubberRing, RECIPE_CONSTANTS.electricMotor_UV, cableTier9, + RECIPE_CONSTANTS.electricPump_UV); + UtilsRecipe.addShapedGregtechRecipe( + cableTier10, rotorTier10, itemRubberRing, + craftingToolScrewdriver, pipeTier10, craftingToolWrench, + itemRubberRing, RECIPE_CONSTANTS.electricMotor_MAX, cableTier10, + RECIPE_CONSTANTS.electricPump_MAX); + + //Electric Pump + UtilsRecipe.addShapedGregtechRecipe( + plateTier7, plateTier7, plateTier7, + cableTier7, rodTier7a, rodTier7a, + cableTier7, RECIPE_CONSTANTS.electricMotor_LuV, smallGearTier7, + RECIPE_CONSTANTS.electricPiston_LuV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier8, plateTier8, plateTier8, + cableTier8, rodTier8a, rodTier8a, + cableTier8, RECIPE_CONSTANTS.electricMotor_ZPM, smallGearTier8, + RECIPE_CONSTANTS.electricPiston_ZPM); + UtilsRecipe.addShapedGregtechRecipe( + plateTier9, plateTier9, plateTier9, + cableTier9, rodTier9a, rodTier9a, + cableTier9, RECIPE_CONSTANTS.electricMotor_UV, smallGearTier9, + RECIPE_CONSTANTS.electricPiston_UV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier10, plateTier10, plateTier10, + cableTier10, rodTier10a, rodTier10a, + cableTier10, RECIPE_CONSTANTS.electricMotor_MAX, smallGearTier10, + RECIPE_CONSTANTS.electricPiston_MAX); + + //Robot Arms + UtilsRecipe.addShapedGregtechRecipe( + cableTier7, cableTier7, cableTier7, + RECIPE_CONSTANTS.electricMotor_LuV, rodTier7a, RECIPE_CONSTANTS.electricMotor_LuV, + RECIPE_CONSTANTS.electricPiston_LuV, circuitTier7, rodTier7a, + RECIPE_CONSTANTS.robotArm_LuV); + UtilsRecipe.addShapedGregtechRecipe( + cableTier8, cableTier8, cableTier8, + RECIPE_CONSTANTS.electricMotor_ZPM, rodTier8a, RECIPE_CONSTANTS.electricMotor_ZPM, + RECIPE_CONSTANTS.electricPiston_ZPM, circuitTier8, rodTier8a, + RECIPE_CONSTANTS.robotArm_ZPM); + UtilsRecipe.addShapedGregtechRecipe( + cableTier9, cableTier9, cableTier9, + RECIPE_CONSTANTS.electricMotor_UV, rodTier9a, RECIPE_CONSTANTS.electricMotor_UV, + RECIPE_CONSTANTS.electricPiston_UV, circuitTier9, rodTier9a, + RECIPE_CONSTANTS.robotArm_UV); + UtilsRecipe.addShapedGregtechRecipe( + cableTier10, cableTier10, cableTier10, + RECIPE_CONSTANTS.electricMotor_MAX, rodTier10a, RECIPE_CONSTANTS.electricMotor_MAX, + RECIPE_CONSTANTS.electricPiston_MAX, circuitTier10, rodTier10a, + RECIPE_CONSTANTS.robotArm_MAX); + + //Conveyor Modules + UtilsRecipe.addShapedGregtechRecipe( + plateRubber, plateRubber, plateRubber, + RECIPE_CONSTANTS.electricMotor_LuV, cableTier7, RECIPE_CONSTANTS.electricMotor_LuV, + plateRubber, plateRubber, plateRubber, + RECIPE_CONSTANTS.conveyorModule_LuV); + UtilsRecipe.addShapedGregtechRecipe( + plateRubber, plateRubber, plateRubber, + RECIPE_CONSTANTS.electricMotor_ZPM, cableTier8, RECIPE_CONSTANTS.electricMotor_ZPM, + plateRubber, plateRubber, plateRubber, + RECIPE_CONSTANTS.conveyorModule_ZPM); + UtilsRecipe.addShapedGregtechRecipe( + plateRubber, plateRubber, plateRubber, + RECIPE_CONSTANTS.electricMotor_UV, cableTier9, RECIPE_CONSTANTS.electricMotor_UV, + plateRubber, plateRubber, plateRubber, + RECIPE_CONSTANTS.conveyorModule_UV); + UtilsRecipe.addShapedGregtechRecipe( + plateRubber, plateRubber, plateRubber, + RECIPE_CONSTANTS.electricMotor_MAX, cableTier10, RECIPE_CONSTANTS.electricMotor_MAX, + plateRubber, plateRubber, plateRubber, + RECIPE_CONSTANTS.conveyorModule_MAX); + + //Emitter Modules + UtilsRecipe.addShapedGregtechRecipe( + rodTier7c, rodTier7c, circuitTier7, + cableTier7, circuitTier6, rodTier7c, + circuitTier7, cableTier7, rodTier7c, + RECIPE_CONSTANTS.emitter_LuV); + UtilsRecipe.addShapedGregtechRecipe( + rodTier8c, rodTier8c, circuitTier8, + cableTier8, circuitTier7, rodTier8c, + circuitTier8, cableTier8, rodTier8c, + RECIPE_CONSTANTS.emitter_ZPM); + UtilsRecipe.addShapedGregtechRecipe( + rodTier9c, rodTier9c, circuitTier9, + cableTier9, circuitTier8, rodTier9c, + circuitTier9, cableTier9, rodTier9c, + RECIPE_CONSTANTS.emitter_UV); + UtilsRecipe.addShapedGregtechRecipe( + rodTier10c, rodTier10c, circuitTier10, + cableTier10, circuitTier9, rodTier10c, + circuitTier10, cableTier10, rodTier10c, + RECIPE_CONSTANTS.emitter_MAX); + + //Field Generator Modules + UtilsRecipe.addShapedGregtechRecipe( + wireTier7, circuitTier7, wireTier7, + circuitTier7, circuitTier6, circuitTier7, + wireTier7, circuitTier7, wireTier7, + RECIPE_CONSTANTS.fieldGenerator_LuV); + UtilsRecipe.addShapedGregtechRecipe( + wireTier8, circuitTier8, wireTier8, + circuitTier8, circuitTier7, circuitTier8, + wireTier8, circuitTier8, wireTier8, + RECIPE_CONSTANTS.fieldGenerator_ZPM); + UtilsRecipe.addShapedGregtechRecipe( + wireTier9, circuitTier9, wireTier9, + circuitTier9, circuitTier8, circuitTier9, + wireTier9, circuitTier9, wireTier9, + RECIPE_CONSTANTS.fieldGenerator_UV); + UtilsRecipe.addShapedGregtechRecipe( + wireTier10, circuitTier10, wireTier10, + circuitTier10, circuitTier9, circuitTier10, + wireTier10, circuitTier10, wireTier10, + RECIPE_CONSTANTS.fieldGenerator_MAX); + + //Sensor Modules + UtilsRecipe.addShapedGregtechRecipe( + plateTier7, null, circuitTier6, + plateTier7, rodTier7c, null, + circuitTier7, plateTier7, plateTier7, + RECIPE_CONSTANTS.sensor_LuV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier8, null, circuitTier7, + plateTier8, rodTier8c, null, + circuitTier8, plateTier8, plateTier8, + RECIPE_CONSTANTS.sensor_ZPM); + UtilsRecipe.addShapedGregtechRecipe( + plateTier9, null, circuitTier8, + plateTier9, rodTier9c, null, + circuitTier9, plateTier9, plateTier9, + RECIPE_CONSTANTS.sensor_UV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier10, null, circuitTier9, + plateTier10, rodTier10c, null, + circuitTier10, plateTier10, plateTier10, + RECIPE_CONSTANTS.sensor_MAX); + + Utils.LOG_INFO("Done loading recipes for the Various machine components."); + + } + + private static void GregtechMachinePhase(){ + Utils.LOG_INFO("Adding Gregtech machine recipes for the circuits."); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Silicon, 1L), GregtechItemList.Circuit_Parts_Wiring_IV.get(4L, new Object[0]), GregtechItemList.Circuit_Board_IV.get(1L, new Object[0]), 32, 256); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Silicon, 1L), GregtechItemList.Circuit_Parts_Wiring_LuV.get(4L, new Object[0]), GregtechItemList.Circuit_Board_LuV.get(1L, new Object[0]), 64, 512); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Silicon, 2L), GregtechItemList.Circuit_Parts_Wiring_ZPM.get(4L, new Object[0]), GregtechItemList.Circuit_Board_ZPM.get(1L, new Object[0]), 96, 1024); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Lazurite, 1L), GregtechItemList.Circuit_Parts_Crystal_Chip_IV.get(3L, new Object[0]), GregtechItemList.Circuit_Parts_IV.get(1L, new Object[0]), 32, 512); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Lazurite, 1L), GregtechItemList.Circuit_Parts_Crystal_Chip_LuV.get(3L, new Object[0]), GregtechItemList.Circuit_Parts_LuV.get(1L, new Object[0]), 64, 1024); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Lazurite, 1L), GregtechItemList.Circuit_Parts_Crystal_Chip_ZPM.get(3L, new Object[0]), GregtechItemList.Circuit_Parts_ZPM.get(1L, new Object[0]), 96, 2048); + GT_Values.RA.addForgeHammerRecipe(ItemList.Circuit_Master.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_Crystal_Chip_IV.get(5L, new Object[0]), 32, 256); + GT_Values.RA.addForgeHammerRecipe(GregtechItemList.Circuit_IV.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_Crystal_Chip_LuV.get(5L, new Object[0]), 64, 512); + GT_Values.RA.addForgeHammerRecipe(GregtechItemList.Circuit_LuV.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_Crystal_Chip_ZPM.get(5L, new Object[0]), 128, 1024); + for (Materials tMat : Materials.VALUES) { + if ((tMat.mStandardMoltenFluid != null) && (tMat.contains(SubTag.SOLDERING_MATERIAL))) { + int tMultiplier = tMat.contains(SubTag.SOLDERING_MATERIAL_GOOD) ? 1 : tMat.contains(SubTag.SOLDERING_MATERIAL_BAD) ? 4 : 2; + GT_Values.RA.addAssemblerRecipe(GregtechItemList.Circuit_Board_IV.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_IV.get(1L, new Object[0]), tMat.getMolten(144L * tMultiplier / 4L), GregtechItemList.Circuit_IV.get(1L, new Object[0]), 32, 512); + GT_Values.RA.addAssemblerRecipe(GregtechItemList.Circuit_Board_LuV.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_LuV.get(1L, new Object[0]), tMat.getMolten(144L * tMultiplier / 4L), GregtechItemList.Circuit_LuV.get(1L, new Object[0]), 64, 1024); + GT_Values.RA.addAssemblerRecipe(GregtechItemList.Circuit_Board_ZPM.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_ZPM.get(1L, new Object[0]), tMat.getMolten(144L * tMultiplier / 4L), GregtechItemList.Circuit_ZPM.get(1L, new Object[0]), 96, 2048); + + } + } + } +} diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_Machines.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_Machines.java new file mode 100644 index 0000000000..a0d244ea85 --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_Machines.java @@ -0,0 +1,601 @@ +package gtPlusPlus.core.recipe; + +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gtPlusPlus.core.lib.LoadedMods; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.item.UtilsItems; +import gtPlusPlus.core.util.recipe.UtilsRecipe; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials; +import net.minecraft.item.ItemStack; + +public class RECIPES_Machines { + + //Outputs + //static ItemStack RECIPE_BufferCore_ULV = new ItemStack(GregtechEnergyBuffer.itemBufferCore); + static ItemStack RECIPE_SteamCondenser = GregtechItemList.Condensor_MAX.get(1); + static ItemStack RECIPE_IronBlastFurnace = GregtechItemList.Machine_Iron_BlastFurnace.get(1); + static ItemStack RECIPE_IronPlatedBricks = GregtechItemList.Casing_IronPlatedBricks.get(1); + static ItemStack RECIPE_Buffer_ULV = GregtechItemList.Energy_Buffer_1by1_ULV.get(1); + static ItemStack RECIPE_Buffer_LV = GregtechItemList.Energy_Buffer_1by1_LV.get(1); + static ItemStack RECIPE_Buffer_MV = GregtechItemList.Energy_Buffer_1by1_MV.get(1); + static ItemStack RECIPE_Buffer_HV = GregtechItemList.Energy_Buffer_1by1_HV.get(1); + static ItemStack RECIPE_Buffer_EV = GregtechItemList.Energy_Buffer_1by1_EV.get(1); + static ItemStack RECIPE_Buffer_IV = GregtechItemList.Energy_Buffer_1by1_IV.get(1); + static ItemStack RECIPE_Buffer_LuV = GregtechItemList.Energy_Buffer_1by1_LuV.get(1); + static ItemStack RECIPE_Buffer_ZPM = GregtechItemList.Energy_Buffer_1by1_ZPM.get(1); + static ItemStack RECIPE_Buffer_UV = GregtechItemList.Energy_Buffer_1by1_UV.get(1); + static ItemStack RECIPE_Buffer_MAX = GregtechItemList.Energy_Buffer_1by1_MAX.get(1); + //Industrial Centrifuge + static ItemStack RECIPE_IndustrialCentrifugeController = GregtechItemList.Industrial_Centrifuge.get(1); + static ItemStack RECIPE_IndustrialCentrifugeCasing = GregtechItemList.Casing_Centrifuge1.get(1); + //Industrial Coke Oven + static ItemStack RECIPE_IndustrialCokeOvenController = GregtechItemList.Industrial_CokeOven.get(1); + static ItemStack RECIPE_IndustrialCokeOvenFrame = GregtechItemList.Casing_CokeOven.get(1); + static ItemStack RECIPE_IndustrialCokeOvenCasingA = GregtechItemList.Casing_CokeOven_Coil1.get(1); + static ItemStack RECIPE_IndustrialCokeOvenCasingB = GregtechItemList.Casing_CokeOven_Coil2.get(1); + // + static ItemStack RECIPE_IndustrialElectrolyzerController = GregtechItemList.Industrial_Electrolyzer.get(1); + static ItemStack RECIPE_IndustrialElectrolyzerFrame = GregtechItemList.Casing_Electrolyzer.get(1); + // + static ItemStack RECIPE_IndustrialMaterialPressController = GregtechItemList.Industrial_PlatePress.get(1); + static ItemStack RECIPE_IndustrialMaterialPressFrame = GregtechItemList.Casing_MaterialPress.get(1); + // + static ItemStack RECIPE_IndustrialMacerationStackController = GregtechItemList.Industrial_MacerationStack.get(1); + static ItemStack RECIPE_IndustrialMacerationStackFrame = GregtechItemList.Casing_MacerationStack.get(1); + // + static ItemStack RECIPE_IndustrialWireFactoryController = GregtechItemList.Industrial_WireFactory.get(1); + static ItemStack RECIPE_IndustrialWireFactoryFrame = GregtechItemList.Casing_WireFactory.get(1); + + + //Buffer Cores + static ItemStack RECIPE_BufferCore_ULV = UtilsItems.getItemStack("miscutils:item.itemBufferCore1", 1); + static ItemStack RECIPE_BufferCore_LV = UtilsItems.getItemStack("miscutils:item.itemBufferCore2", 1); + static ItemStack RECIPE_BufferCore_MV = UtilsItems.getItemStack("miscutils:item.itemBufferCore3", 1); + static ItemStack RECIPE_BufferCore_HV = UtilsItems.getItemStack("miscutils:item.itemBufferCore4", 1); + static ItemStack RECIPE_BufferCore_EV = UtilsItems.getItemStack("miscutils:item.itemBufferCore5", 1); + static ItemStack RECIPE_BufferCore_IV = UtilsItems.getItemStack("miscutils:item.itemBufferCore6", 1); + static ItemStack RECIPE_BufferCore_LuV = UtilsItems.getItemStack("miscutils:item.itemBufferCore7", 1); + static ItemStack RECIPE_BufferCore_ZPM = UtilsItems.getItemStack("miscutils:item.itemBufferCore8", 1); + static ItemStack RECIPE_BufferCore_UV = UtilsItems.getItemStack("miscutils:item.itemBufferCore9", 1); + static ItemStack RECIPE_BufferCore_MAX = UtilsItems.getItemStack("miscutils:item.itemBufferCore10", 1); + + + //Wire + static String wireTier1 = "wireGt08Lead"; + static String wireTier2 = "wireGt08Tin"; + static String wireTier3 = "wireGt08Copper"; + static String wireTier4 = "wireGt08Gold"; + static String wireTier5 = "wireGt08Aluminium"; + static String wireTier6 = "wireGt08Tungsten"; + static String wireTier7 = "wireGt08Naquadah"; + static String wireTier8 = "wireGt08Osmium"; + static String wireTier9 = "wireGt08Superconductor"; + static String wireTier10 = "wireGt16Superconductor"; + + //Wire + static String cableTier1 = "cableGt04Lead"; + static String cableTier2 = "cableGt04Tin"; + static String cableTier3 = "cableGt04Copper"; + static String cableTier4 = "cableGt04Gold"; + static String cableTier5 = "cableGt04Aluminium"; + static String cableTier6 = "cableGt04Tungsten"; + static String cableTier7 = "cableGt04Naquadah"; + static String cableTier8 = "cableGt04Osmium"; + static String cableTier9 = "cableGt04NiobiumTitanium"; + static String cableTier10 = "cableGt08NiobiumTitanium"; + + + //Plates + static String plateTier1 = "plateLead"; + static String plateTier2 = "plateTin"; + static String plateTier3 = "plateCopper"; + static String plateTier4 = "plateGold"; + static String plateTier5 = "plateAluminium"; + static String plateTier6 = "plateMaragingSteel250"; + static String plateTier7 = "plateTungsten"; + static String plateTier8 = "plateTungstenSteel"; + static String plateTier9 = "plateZeron100"; + static String plateTier10 = "plateNaquadah"; + static String plateTier11 = "plateNeutronium"; + + //rods + static String rodTier1 = "stickLead"; + static String rodTier2 = "stickTin"; + static String rodTier3 = "stickCopper"; + static String rodTier4 = "stickGold"; + static String rodTier5 = "stickAluminium"; + static String rodTier6 = "stickMaragingSteel250"; + static String rodTier7 = "stickTungsten"; + static String rodTier8 = "stickTungstenSteel"; + static String rodTier9 = "stickZeron100"; + static String rodTier10 = "stickNaquadah"; + static String rodTier11 = "stickNeutronium"; + + + //Machine Casings + static ItemStack machineCasing_ULV; + static ItemStack machineCasing_LV; + static ItemStack machineCasing_MV; + static ItemStack machineCasing_HV; + static ItemStack machineCasing_EV; + static ItemStack machineCasing_IV; + static ItemStack machineCasing_LuV; + static ItemStack machineCasing_ZPM; + static ItemStack machineCasing_UV; + static ItemStack machineCasing_MAX; + + //Gearbox Casings + static ItemStack gearboxCasing_Tier_1; + static ItemStack gearboxCasing_Tier_2; + static ItemStack gearboxCasing_Tier_3; + static ItemStack gearboxCasing_Tier_4; + + //IV MACHINES + public static ItemStack IV_MACHINE_Electrolyzer; + public static ItemStack IV_MACHINE_Centrifuge; + public static ItemStack IV_MACHINE_BendingMachine; + public static ItemStack IV_MACHINE_Wiremill; + public static ItemStack IV_MACHINE_Macerator; + public static ItemStack IV_MACHINE_MassFabricator; + + + //Cables + static String cableGt02Electrum = "cableGt02Electrum"; + + + //Plates + static String plateElectricalSteel= "plateElectricalSteel"; + static String plateEnergeticAlloy= "plateEnergeticAlloy"; + static String plateCobalt = "plateCobalt"; + static String plateBronze = "plateBronze"; + static String plateSteel = "plateSteel"; + + //Pipes + static String pipeLargeCopper="pipeLargeCopper"; + static String pipeHugeSteel="pipeHugeSteel"; + static String pipeHugeStainlessSteel="pipeHugeStainlessSteel"; + static String pipeHugeTitanium="pipeHugeTitanium"; + + //Lava Boiler + static ItemStack boiler_Coal; + static ItemStack blockBricks = UtilsItems.getItemStack("minecraft:brick_block", 1); + + //Batteries + static String batteryBasic = "batteryBasic"; + static String batteryAdvanced = "batteryAdvanced"; + static String batteryElite = "batteryElite"; + static String batteryMaster = "batteryMaster"; + static String batteryUltimate = "batteryUltimate"; + static ItemStack IC2MFE; + static ItemStack IC2MFSU; + + //Circuits + static String circuitPrimitive = "circuitBasic"; + static String circuitTier1 = "circuitGood"; + static String circuitTier2 = "circuitAdvanced"; + static String circuitTier3 = "circuitData"; + static String circuitTier4 = "circuitElite"; + static String circuitTier5 = "circuitMaster"; + static String circuitTier6 = "circuitUltimate"; + static String circuitTier7 = "circuitSymbiotic"; + static String circuitTier8 = "circuitNeutronic"; + static String circuitTier9 = "circuitQuantum"; + + //Machine Components + static ItemStack electricMotor_LV; + static ItemStack electricMotor_MV; + static ItemStack electricMotor_HV; + static ItemStack electricMotor_EV; + static ItemStack electricMotor_IV; + static ItemStack electricPump_LV; + static ItemStack electricPump_MV; + static ItemStack electricPump_HV; + static ItemStack electricPump_EV; + static ItemStack electricPump_IV; + static ItemStack electricPiston_LV; + static ItemStack electricPiston_MV; + static ItemStack electricPiston_HV; + static ItemStack electricPiston_EV; + static ItemStack electricPiston_IV; + static ItemStack robotArm_LV; + static ItemStack robotArm_MV; + static ItemStack robotArm_HV; + static ItemStack robotArm_EV; + static ItemStack robotArm_IV; + static ItemStack conveyorModule_LV; + static ItemStack conveyorModule_MV; + static ItemStack conveyorModule_HV; + static ItemStack conveyorModule_EV; + static ItemStack conveyorModule_IV; + static ItemStack emitter_LV; + static ItemStack emitter_MV; + static ItemStack emitter_HV; + static ItemStack emitter_EV; + static ItemStack emitter_IV; + static ItemStack fieldGenerator_LV; + static ItemStack fieldGenerator_MV; + static ItemStack fieldGenerator_HV; + static ItemStack fieldGenerator_EV; + static ItemStack fieldGenerator_IV; + static ItemStack sensor_LV; + static ItemStack sensor_MV; + static ItemStack sensor_HV; + static ItemStack sensor_EV; + static ItemStack sensor_IV; + + //Misc + static ItemStack INPUT_RCCokeOvenBlock; + static ItemStack INPUT_IECokeOvenBlock; + + + + //RobotArm, Conveyor, Emitter, Sensor, Field Generator + + + public static final void RECIPES_LOAD(){ + run(); + Utils.LOG_INFO("Loading Recipes for the Various machine blocks."); + } + + private static void run(){ + initModItems(); + } + + private static void initModItems(){ + if (LoadedMods.IndustrialCraft2){ + IC2MFE = UtilsItems.getItemStackWithMeta(LoadedMods.IndustrialCraft2, "IC2:blockElectric", "IC2_MFE", 1, 1); + IC2MFSU = UtilsItems.getItemStackWithMeta(LoadedMods.IndustrialCraft2, "IC2:blockElectric", "IC2_MFSU", 2, 1); + } + if (LoadedMods.Gregtech){ + RECIPES_Shapeless.dustStaballoy = UtilsItems.getItemStackWithMeta(LoadedMods.MiscUtils, "gregtech:gt.metaitem.01", "Staballoy Dust", 2319, 2); + machineCasing_ULV = ItemList.Casing_ULV.get(1); + machineCasing_LV = ItemList.Casing_LV.get(1); + machineCasing_MV = ItemList.Casing_MV.get(1); + machineCasing_HV = ItemList.Casing_HV.get(1); + machineCasing_EV = ItemList.Casing_EV.get(1); + machineCasing_IV = ItemList.Casing_IV.get(1); + machineCasing_LuV = ItemList.Casing_LuV.get(1); + machineCasing_ZPM = ItemList.Casing_ZPM.get(1); + machineCasing_UV = ItemList.Casing_UV.get(1); + machineCasing_MAX = ItemList.Casing_MAX.get(1); + + //Gearbox Casings + gearboxCasing_Tier_1 = ItemList.Casing_Gearbox_Bronze.get(1); + gearboxCasing_Tier_2 = ItemList.Casing_Gearbox_Steel.get(1); + gearboxCasing_Tier_3 = ItemList.Casing_Gearbox_Titanium.get(1); + gearboxCasing_Tier_4 = ItemList.Casing_Gearbox_TungstenSteel.get(1); + + //Lava Boiler + boiler_Coal = ItemList.Machine_Bronze_Boiler.get(1); + + //Machine Components + electricMotor_LV = ItemList.Electric_Motor_LV.get(1); + electricMotor_MV = ItemList.Electric_Motor_MV.get(1); + electricMotor_HV = ItemList.Electric_Motor_HV.get(1); + electricMotor_EV = ItemList.Electric_Motor_EV.get(1); + electricMotor_IV = ItemList.Electric_Motor_IV.get(1); + electricPump_LV = ItemList.Electric_Pump_LV.get(1); + electricPump_MV = ItemList.Electric_Pump_MV.get(1); + electricPump_HV = ItemList.Electric_Pump_HV.get(1); + electricPump_EV = ItemList.Electric_Pump_EV.get(1); + electricPump_IV = ItemList.Electric_Pump_IV.get(1); + electricPiston_LV = ItemList.Electric_Piston_LV.get(1); + electricPiston_MV = ItemList.Electric_Piston_MV.get(1); + electricPiston_HV = ItemList.Electric_Piston_HV.get(1); + electricPiston_EV = ItemList.Electric_Piston_EV.get(1); + electricPiston_IV = ItemList.Electric_Piston_IV.get(1); + robotArm_LV = ItemList.Robot_Arm_LV.get(1); + robotArm_MV = ItemList.Robot_Arm_MV.get(1); + robotArm_HV = ItemList.Robot_Arm_HV.get(1); + robotArm_EV = ItemList.Robot_Arm_EV.get(1); + robotArm_IV = ItemList.Robot_Arm_IV.get(1); + conveyorModule_LV = ItemList.Conveyor_Module_LV.get(1); + conveyorModule_MV = ItemList.Conveyor_Module_MV.get(1); + conveyorModule_HV = ItemList.Conveyor_Module_HV.get(1); + conveyorModule_EV = ItemList.Conveyor_Module_EV.get(1); + conveyorModule_IV = ItemList.Conveyor_Module_IV.get(1); + emitter_LV = ItemList.Emitter_LV.get(1); + emitter_MV = ItemList.Emitter_MV.get(1); + emitter_HV = ItemList.Emitter_HV.get(1); + emitter_EV = ItemList.Emitter_EV.get(1); + emitter_IV = ItemList.Emitter_IV.get(1); + fieldGenerator_LV = ItemList.Field_Generator_LV.get(1); + fieldGenerator_MV = ItemList.Field_Generator_MV.get(1); + fieldGenerator_HV = ItemList.Field_Generator_HV.get(1); + fieldGenerator_EV = ItemList.Field_Generator_EV.get(1); + fieldGenerator_IV = ItemList.Field_Generator_IV.get(1); + sensor_LV = ItemList.Sensor_LV.get(1); + sensor_MV = ItemList.Sensor_MV.get(1); + sensor_HV = ItemList.Sensor_HV.get(1); + sensor_EV = ItemList.Sensor_EV.get(1); + sensor_IV = ItemList.Sensor_IV.get(1); + + + //IV MACHINES + IV_MACHINE_Electrolyzer = ItemList.Machine_IV_Electrolyzer.get(1); + IV_MACHINE_BendingMachine= ItemList.Machine_IV_Bender.get(1); + IV_MACHINE_Wiremill= ItemList.Machine_IV_Wiremill.get(1); + IV_MACHINE_Macerator= ItemList.Machine_IV_Macerator.get(1); + IV_MACHINE_MassFabricator= ItemList.Machine_IV_Massfab.get(1); + IV_MACHINE_Centrifuge= ItemList.Machine_IV_Centrifuge.get(1); + + + } + + if(LoadedMods.Railcraft){ + //Misc + INPUT_RCCokeOvenBlock = UtilsItems.getItemStackWithMeta(LoadedMods.Railcraft, "Railcraft:machine.alpha", "Coke_Oven_RC", 7, 1); + } + if(LoadedMods.ImmersiveEngineering){ + //Misc + INPUT_IECokeOvenBlock = UtilsItems.getItemStackWithMeta(LoadedMods.ImmersiveEngineering, "ImmersiveEngineering:stoneDecoration", "Coke_Oven_IE", 1, 1); + } + runModRecipes(); + } + + private static void runModRecipes(){ + if (LoadedMods.Gregtech){ + + UtilsRecipe.addShapedGregtechRecipe( + ItemList.Electric_Piston_EV, GregtechOrePrefixes.circuit.get(Materials.Ultimate), ItemList.Electric_Piston_EV, + ItemList.Electric_Motor_EV, machineCasing_EV, ItemList.Electric_Motor_EV, + "gearGtTitanium", "cableGt02Aluminium", "gearGtTitanium", + UtilsItems.simpleMetaStack("gregtech:gt.blockmachines", 793, 1)); + UtilsRecipe.addShapedGregtechRecipe( + ItemList.Electric_Piston_IV, GregtechOrePrefixes.circuit.get(GT_Materials.Symbiotic), ItemList.Electric_Piston_IV, + ItemList.Electric_Motor_IV, machineCasing_IV, ItemList.Electric_Motor_IV, + "gearGtTungstenSteel", "cableGt02Platinum", "gearGtTungstenSteel", + UtilsItems.simpleMetaStack("gregtech:gt.blockmachines", 794, 1)); + UtilsRecipe.addShapedGregtechRecipe( + RECIPE_CONSTANTS.electricPiston_LuV, GregtechOrePrefixes.circuit.get(GT_Materials.Neutronic), RECIPE_CONSTANTS.electricPiston_LuV, + RECIPE_CONSTANTS.electricMotor_LuV, machineCasing_LuV, RECIPE_CONSTANTS.electricMotor_LuV, + "gearGtChrome", "cableGt02Tungsten", "gearGtChrome", + UtilsItems.simpleMetaStack("gregtech:gt.blockmachines", 795, 1)); + + //Buffer Core + UtilsRecipe.addShapedGregtechRecipe( + plateTier1, cableTier1, plateTier1, + circuitPrimitive, IC2MFE, circuitPrimitive, + plateTier1, cableTier1, plateTier1, + RECIPE_BufferCore_ULV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier2, cableTier2, plateTier2, + circuitTier1, IC2MFE, circuitTier1, + plateTier2, cableTier2, plateTier2, + RECIPE_BufferCore_LV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier3, cableTier3, plateTier3, + RECIPE_BufferCore_LV, circuitTier2, RECIPE_BufferCore_LV, + plateTier3, cableTier3, plateTier3, + RECIPE_BufferCore_MV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier4, cableTier4, plateTier4, + RECIPE_BufferCore_MV, circuitTier3, RECIPE_BufferCore_MV, + plateTier4, cableTier4, plateTier4, + RECIPE_BufferCore_HV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier5, cableTier5, plateTier5, + RECIPE_BufferCore_HV, circuitTier4, RECIPE_BufferCore_HV, + plateTier5, cableTier5, plateTier5, + RECIPE_BufferCore_EV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier6, cableTier6, plateTier6, + RECIPE_BufferCore_EV, circuitTier5, RECIPE_BufferCore_EV, + plateTier6, cableTier6, plateTier6, + RECIPE_BufferCore_IV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier7, cableTier7, plateTier7, + RECIPE_BufferCore_IV, circuitTier6, RECIPE_BufferCore_IV, + plateTier7, cableTier7, plateTier7, + RECIPE_BufferCore_LuV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier8, cableTier8, plateTier8, + RECIPE_BufferCore_LuV, circuitTier7, RECIPE_BufferCore_LuV, + plateTier8, cableTier8, plateTier8, + RECIPE_BufferCore_ZPM); + UtilsRecipe.addShapedGregtechRecipe( + plateTier9, cableTier9, plateTier9, + RECIPE_BufferCore_ZPM, circuitTier8, RECIPE_BufferCore_ZPM, + plateTier9, cableTier9, plateTier9, + RECIPE_BufferCore_UV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier10, cableTier10, plateTier10, + RECIPE_BufferCore_UV, circuitTier9, RECIPE_BufferCore_UV, + plateTier10, cableTier10, plateTier10, + RECIPE_BufferCore_MAX); + + + UtilsRecipe.addShapedGregtechRecipe( + wireTier1, RECIPE_BufferCore_ULV, wireTier1, + wireTier1, machineCasing_ULV, wireTier1, + circuitPrimitive, circuitTier1, circuitPrimitive, + RECIPE_Buffer_ULV); + UtilsRecipe.addShapedGregtechRecipe( + wireTier2, RECIPE_BufferCore_LV, wireTier2, + wireTier2, machineCasing_LV, wireTier2, + circuitTier1, RECIPE_BufferCore_LV, circuitTier1, + RECIPE_Buffer_LV); + UtilsRecipe.addShapedGregtechRecipe( + wireTier3, RECIPE_BufferCore_MV, wireTier3, + wireTier3, machineCasing_MV, wireTier3, + circuitTier2, RECIPE_BufferCore_MV, circuitTier2, + RECIPE_Buffer_MV); + UtilsRecipe.addShapedGregtechRecipe( + wireTier4, RECIPE_BufferCore_HV, wireTier4, + wireTier4, machineCasing_HV, wireTier4, + circuitTier3, RECIPE_BufferCore_HV, circuitTier3, + RECIPE_Buffer_HV); + UtilsRecipe.addShapedGregtechRecipe( + wireTier5, RECIPE_BufferCore_EV, wireTier5, + wireTier5, machineCasing_EV, wireTier5, + circuitTier4, RECIPE_BufferCore_EV, circuitTier4, + RECIPE_Buffer_EV); + UtilsRecipe.addShapedGregtechRecipe( + wireTier6, RECIPE_BufferCore_IV, wireTier6, + wireTier6, machineCasing_IV, wireTier6, + circuitTier5, RECIPE_BufferCore_IV, circuitTier5, + RECIPE_Buffer_IV); + UtilsRecipe.addShapedGregtechRecipe( + wireTier7, RECIPE_BufferCore_LuV, wireTier7, + wireTier7, machineCasing_LuV, wireTier7, + circuitTier6, RECIPE_BufferCore_LuV, circuitTier6, + RECIPE_Buffer_LuV); + UtilsRecipe.addShapedGregtechRecipe( + wireTier8, RECIPE_BufferCore_ZPM, wireTier8, + wireTier8, machineCasing_ZPM, wireTier8, + circuitTier7, RECIPE_BufferCore_ZPM, circuitTier7, + RECIPE_Buffer_ZPM); + UtilsRecipe.addShapedGregtechRecipe( + wireTier9, RECIPE_BufferCore_UV, wireTier9, + wireTier9, machineCasing_UV, wireTier9, + circuitTier8, RECIPE_BufferCore_UV, circuitTier8, + RECIPE_Buffer_UV); + UtilsRecipe.addShapedGregtechRecipe( + plateTier11, RECIPE_BufferCore_MAX, plateTier11, + wireTier10, machineCasing_MAX, wireTier10, + circuitTier9, RECIPE_BufferCore_MAX, circuitTier9, + RECIPE_Buffer_MAX); + + //Steam Condenser + UtilsRecipe.addShapedGregtechRecipe( + pipeLargeCopper, pipeHugeSteel, pipeLargeCopper, + plateEnergeticAlloy, electricPump_HV, plateEnergeticAlloy, + plateEnergeticAlloy, pipeLargeCopper, plateEnergeticAlloy, + RECIPE_SteamCondenser); + + //Iron BF + UtilsRecipe.addShapedGregtechRecipe( + "plateDoubleAnyIron", "craftingFurnace", "plateDoubleAnyIron", + boiler_Coal, machineCasing_ULV, boiler_Coal, + "plateDoubleAnyIron", "bucketLava", "plateDoubleAnyIron", + RECIPE_IronBlastFurnace); + //Iron plated Bricks + UtilsRecipe.addShapedGregtechRecipe( + "plateAnyIron", RECIPES_Tools.craftingToolHardHammer, "plateAnyIron", + "plateAnyIron", blockBricks, "plateAnyIron", + "plateAnyIron", RECIPES_Tools.craftingToolWrench, "plateAnyIron", + RECIPE_IronPlatedBricks); + + /*//Electrolyzer Frame Casing + UtilsRecipe.addShapedGregtechRecipe( + "platePotin", "stickLongChrome", "platePotin", + "stickLongPotin", "frameGtPotin", "stickLongPotin", + "platePotin", "stickLongPotin", "platePotin", + RECIPE_IndustrialCentrifugeCasing); + //Industrial Electrolyzer + UtilsRecipe.addShapedGregtechRecipe( + "plateStellite", circuitTier6, "plateStellite", + machineCasing_EV, IV_MACHINE_Electrolyzer, machineCasing_EV, + "plateStellite", "rotorStellite", "plateStellite", + RECIPE_IndustrialCentrifugeController);*/ + + //Industrial Centrifuge + UtilsRecipe.addShapedGregtechRecipe( + circuitTier6, pipeHugeStainlessSteel, circuitTier6, + plateTier6, IV_MACHINE_Centrifuge, plateTier6, + plateTier8, machineCasing_IV, plateTier8, + RECIPE_IndustrialCentrifugeController); + //Centrifuge Casing + UtilsRecipe.addShapedGregtechRecipe( + plateTier6, "stickTumbaga", plateTier6, + plateTier8, "stickTumbaga", plateTier8, + plateTier6, "stickTumbaga", plateTier6, + RECIPE_IndustrialCentrifugeCasing); + + if (LoadedMods.Railcraft){ + //Industrial Coke Oven + UtilsRecipe.addShapedGregtechRecipe( + plateCobalt, circuitTier4, plateCobalt, + machineCasing_HV, INPUT_RCCokeOvenBlock, machineCasing_HV, + plateCobalt, circuitTier5, plateCobalt, + RECIPE_IndustrialCokeOvenController); + } + if (LoadedMods.ImmersiveEngineering){ + //Industrial Coke Oven + UtilsRecipe.addShapedGregtechRecipe( + plateCobalt, circuitTier4, plateCobalt, + machineCasing_HV, INPUT_IECokeOvenBlock, machineCasing_HV, + plateCobalt, circuitTier5, plateCobalt, + RECIPE_IndustrialCokeOvenController); + } + //Coke Oven Frame Casing + UtilsRecipe.addShapedGregtechRecipe( + plateTier8, rodTier8, plateTier8, + rodTier8, "frameGtTantalloy61", rodTier8, + plateTier8, rodTier8, plateTier8, + RECIPE_IndustrialCokeOvenFrame); + //Coke Oven Coil 1 + UtilsRecipe.addShapedGregtechRecipe( + plateBronze, plateBronze, plateBronze, + "frameGtBronze", gearboxCasing_Tier_1, "frameGtBronze", + plateBronze, plateBronze, plateBronze, + RECIPE_IndustrialCokeOvenCasingA); + //Coke Oven Coil 2 + UtilsRecipe.addShapedGregtechRecipe( + plateSteel, plateSteel, plateSteel, + "frameGtSteel", gearboxCasing_Tier_2, "frameGtSteel", + plateSteel, plateSteel, plateSteel, + RECIPE_IndustrialCokeOvenCasingB); + + //Electrolyzer Frame Casing + UtilsRecipe.addShapedGregtechRecipe( + "platePotin", "stickLongChrome", "platePotin", + "stickLongPotin", "frameGtPotin", "stickLongPotin", + "platePotin", "stickLongPotin", "platePotin", + RECIPE_IndustrialElectrolyzerFrame); + //Industrial Electrolyzer + UtilsRecipe.addShapedGregtechRecipe( + "plateStellite", circuitTier6, "plateStellite", + machineCasing_EV, IV_MACHINE_Electrolyzer, machineCasing_EV, + "plateStellite", "rotorStellite", "plateStellite", + RECIPE_IndustrialElectrolyzerController); + + //Material Press Frame Casing + UtilsRecipe.addShapedGregtechRecipe( + "plateTitanium", "stickLongTumbaga", "plateTitanium", + "stickTantalloy60", "frameGtTumbaga", "stickTantalloy60", + "plateTitanium", "stickLongTumbaga", "plateTitanium", + RECIPE_IndustrialMaterialPressFrame); + //Industrial Material Press + UtilsRecipe.addShapedGregtechRecipe( + "plateTitanium", circuitTier5, "plateTitanium", + machineCasing_EV, IV_MACHINE_BendingMachine, machineCasing_EV, + "plateTitanium", circuitTier5, "plateTitanium", + RECIPE_IndustrialMaterialPressController); + + //Maceration Frame Casing + UtilsRecipe.addShapedGregtechRecipe( + "platePalladium", "platePalladium", "platePalladium", + "stickPlatinum", "frameGtInconel625", "stickPlatinum", + "platePalladium", "stickLongPalladium", "platePalladium", + RECIPE_IndustrialMacerationStackFrame); + //Industrial Maceration stack + UtilsRecipe.addShapedGregtechRecipe( + "plateTungstenCarbide", IV_MACHINE_Macerator, "plateTungstenCarbide", + IV_MACHINE_Macerator, circuitTier8, IV_MACHINE_Macerator, + "plateTungstenCarbide", machineCasing_IV, "plateTungstenCarbide", + RECIPE_IndustrialMacerationStackController); + + //Wire Factory Frame Casing + UtilsRecipe.addShapedGregtechRecipe( + "plateBlueSteel", "stickBlueSteel", "plateBlueSteel", + "stickBlueSteel", "frameGtBlueSteel", "stickBlueSteel", + "plateBlueSteel", "stickBlueSteel", "plateBlueSteel", + RECIPE_IndustrialWireFactoryFrame); + //Industrial Wire Factory + UtilsRecipe.addShapedGregtechRecipe( + "plateZeron100", machineCasing_IV, "plateZeron100", + circuitTier6, IV_MACHINE_Wiremill, circuitTier6, + "plateZeron100", machineCasing_IV, "plateZeron100", + RECIPE_IndustrialWireFactoryController); + + + } + + + Utils.LOG_INFO("Done loading recipes for the Various machine blocks."); + } +} diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_Shapeless.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_Shapeless.java new file mode 100644 index 0000000000..2a79aa92c9 --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_Shapeless.java @@ -0,0 +1,46 @@ +package gtPlusPlus.core.recipe; + +import gregtech.api.enums.ItemList; +import gtPlusPlus.core.lib.LoadedMods; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.recipe.UtilsRecipe; +import net.minecraft.item.ItemStack; + +public class RECIPES_Shapeless { + + static ItemStack dustStaballoy; + + //Circuits + static String circuitPrimitive = "circuitPrimitive"; + static String circuitBasic = "circuitBasic"; + static String circuitGood = "circuitGood"; + static String circuitAdvanced = "circuitAdvanced"; + static String circuitData = "circuitData"; + static String circuitElite = "circuitElite"; + static String circuitMaster = "circuitMaster"; + static String circuitUltimate = "circuitUltimate"; + static ItemStack gearboxCasing_Tier_1; + + public static final void RECIPES_LOAD(){ + //run(); + Utils.LOG_INFO("Loading Shapeless Recipes."); + } + + private static void run(){ + //Gregtech items + if (LoadedMods.Gregtech){ + gearboxCasing_Tier_1 = ItemList.Casing_Gearbox_Bronze.get(1); + + UtilsRecipe.shapelessBuilder(dustStaballoy, + "dustTitanium", "dustUranium", "dustUranium", + "dustUranium", "dustUranium", "dustUranium", + "dustUranium", "dustUranium", "dustUranium"); + + UtilsRecipe.shapelessBuilder(gearboxCasing_Tier_1, + circuitPrimitive, circuitPrimitive, circuitPrimitive, + circuitPrimitive, circuitPrimitive, circuitPrimitive, + circuitPrimitive, circuitPrimitive, circuitPrimitive); + } + } + +} diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_Tools.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_Tools.java new file mode 100644 index 0000000000..2f97d7e7ff --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_Tools.java @@ -0,0 +1,177 @@ +package gtPlusPlus.core.recipe; + +import gtPlusPlus.core.item.ModItems; +import gtPlusPlus.core.util.item.UtilsItems; +import gtPlusPlus.core.util.recipe.UtilsRecipe; +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +public class RECIPES_Tools { + + //Outputs + public static ItemStack RECIPE_StaballoyPickaxe = new ItemStack(ModItems.itemStaballoyPickaxe); + public static ItemStack RECIPE_StaballoyAxe = new ItemStack(ModItems.itemStaballoyAxe); + public static ItemStack RECIPE_SandstoneHammer = new ItemStack(ModItems.itemSandstoneHammer); + public static ItemStack RECIPE_StaballoyIngot = new ItemStack(ModItems.itemIngotStaballoy); + public static ItemStack RECIPE_SandStone = new ItemStack(Blocks.sandstone, 2); + public static ItemStack RECIPE_Sand = new ItemStack(Blocks.sand, 4); + + public static ItemStack RECIPE_DivisionSigil; + + //MC Items + public static Item Apple = Items.apple; + + //MC Blocks + public static Block CobbleStone = Blocks.cobblestone; + public static Block Dirt = Blocks.dirt; + public static Block Sand = Blocks.sand; + public static Block Gravel = Blocks.gravel; + public static Block Sandstone = Blocks.sandstone; + + //null + public static String empty = " "; + + //Batteries + public static String batteryBasic = "batteryBasic"; + public static String batteryAdvanced = "batteryAdvanced"; + public static String batteryElite = "batteryElite"; + public static String batteryMaster = "batteryMaster"; + public static String batteryUltimate = "batteryUltimate"; + + //Circuits + public static String circuitPrimitive = "circuitPrimitive"; + public static String circuitBasic = "circuitBasic"; + public static String circuitGood = "circuitGood"; + public static String circuitAdvanced = "circuitAdvanced"; + public static String circuitElite = "circuitElite"; + public static String circuitMaster = "circuitMaster"; + public static String circuitUltimate = "circuitUltimate"; + + //Cables + public static String cableGt01Electrum = "cableGt01Electrum"; + public static String cableGt02Electrum = "cableGt02Electrum"; + public static String cableGt01RedstoneAlloy = "cableGt01RedstoneAlloy"; + public static String cableGt02RedstoneAlloy = "cableGt02RedstoneAlloy"; + public static String cableGt01Copper = "cableGt01Copper"; + public static String cableGt02Copper = "cableGt02Copper"; + public static String cableGt01AnnealedCopper = "cableGt01AnnealedCopper"; + public static String cableGt02AnnealedCopper = "cableGt02AnnealedCopper"; + + //Rods + public static String stickStaballoy= "stickStaballoy"; + public static String stickTitanium= "stickTitanium"; + public static String stickIron= "stickIron"; + public static String stickGold= "stickGold"; + public static String stickSilver= "stickSilver"; + public static String stickSteel= "stickSteel"; + public static String stickBronze= "stickBronze"; + public static String stickTungsten= "stickTungsten"; + public static String stickRedAlloy= "stickRedAlloy"; + public static String stickInvar= "stickInvar"; + public static String stickElectrum= "stickElectrum"; + public static String stickElectricalSteel= "stickElectricalSteel"; + + //Plates + public static String plateStaballoy= "plateStaballoy"; + public static String plateTitanium= "plateTitanium"; + public static String plateIron= "plateIron"; + public static String plateGold= "plateGold"; + public static String plateSilver= "plateSilver"; + public static String plateSteel= "plateSteel"; + public static String plateBronze= "plateBronze"; + public static String plateTungsten= "plateTungsten"; + public static String plateRedAlloy= "plateRedAlloy"; + public static String plateInvar= "plateInvar"; + public static String plateElectrum= "plateElectrum"; + public static String plateElectricalSteel= "plateElectricalSteel"; + + //Ingots + public static String ingotStaballoy= "ingotStaballoy"; + public static String ingotTitanium= "ingotTitanium"; + public static String ingotIron= "ingotIron"; + public static String ingotGold= "ingotGold"; + public static String ingotSilver= "ingotSilver"; + public static String ingotSteel= "ingotSteel"; + public static String ingotBronze= "ingotBronze"; + public static String ingotTungsten= "ingotTungsten"; + public static String ingotRedAlloy= "ingotRedAlloy"; + public static String ingotInvar= "ingotInvar"; + public static String ingotElectrum= "ingotElectrum"; + public static String ingotUranium= "ingotUranium"; + public static String ingotElectricalSteel= "ingotElectricalSteel"; + + //Crafting Tools + public static String craftingToolHardHammer = "craftingToolHardHammer"; + public static String craftingToolSoftHammer = "craftingToolSoftHammer"; + public static String craftingToolFile = "craftingToolFile"; + public static String craftingToolSaw = "craftingToolSaw"; + public static String craftingToolPickaxe = "craftingToolPickaxe"; + public static String craftingToolWrench = "craftingToolWrench"; + public static String craftingToolCrowbar = "craftingToolCrowbar"; + public static String craftingToolKnife = "craftingToolKnife"; + public static String craftingToolScrewdriver = "craftingToolScrewdriver"; + + public static ItemStack sandHammer = new ItemStack (ModItems.itemSandstoneHammer, 1, OreDictionary.WILDCARD_VALUE); + public static String craftingToolSandHammer = "craftingToolSandHammer"; + + public static ItemStack personalCloakingDevice = UtilsItems.getSimpleStack(ModItems.itemPersonalCloakingDevice); + public static String plateDoubleNiChrome = "plateDoubleNichrome"; + public static String plateIridiumAlloy = "plateAlloyIridium"; + + public static final void RECIPES_LOAD(){ + + + run(); + + } + + private static void run(){ + //Staballoy Pickaxe + UtilsRecipe.recipeBuilder( + plateStaballoy, plateStaballoy, ingotStaballoy, + craftingToolFile, stickTungsten, craftingToolHardHammer, + craftingToolWrench, stickTungsten, craftingToolHardHammer, + RECIPE_StaballoyPickaxe); + + //Staballoy Axe + UtilsRecipe.recipeBuilder( + plateStaballoy, ingotStaballoy, craftingToolHardHammer, + plateStaballoy, stickTungsten, craftingToolHardHammer, + craftingToolFile, stickTungsten, craftingToolWrench, + RECIPE_StaballoyAxe); + + //Cobble to Sand + UtilsRecipe.recipeBuilder( + CobbleStone, CobbleStone, CobbleStone, + CobbleStone, sandHammer, CobbleStone, + CobbleStone, CobbleStone, CobbleStone, + RECIPE_Sand); + + //Cloaking Device + UtilsRecipe.recipeBuilder( + plateDoubleNiChrome, plateIridiumAlloy, plateDoubleNiChrome, + plateIridiumAlloy, batteryUltimate, plateIridiumAlloy, + plateDoubleNiChrome, plateIridiumAlloy, plateDoubleNiChrome, + personalCloakingDevice); + + //Sand to Sandstone + UtilsRecipe.recipeBuilder( + Sand, Sand, Sand, + Sand, sandHammer, Sand, + Sand, Sand, Sand, + RECIPE_SandStone); + + //Sandstone Hammer + UtilsRecipe.recipeBuilder( + plateElectrum, ingotElectrum, plateElectrum, + craftingToolScrewdriver, stickBronze, craftingToolHardHammer, + null, stickSteel, null, + RECIPE_SandstoneHammer); + + } + +} diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPE_Batteries.java b/src/Java/gtPlusPlus/core/recipe/RECIPE_Batteries.java new file mode 100644 index 0000000000..80ee79e292 --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/RECIPE_Batteries.java @@ -0,0 +1,49 @@ +package gtPlusPlus.core.recipe; + +import gregtech.api.enums.ItemList; +import gtPlusPlus.core.lib.LoadedMods; +import gtPlusPlus.core.util.item.UtilsItems; +import gtPlusPlus.core.util.recipe.UtilsRecipe; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import net.minecraft.item.ItemStack; + +public class RECIPE_Batteries { + + static ItemStack RECIPE_Battery_Sodium = GregtechItemList.Battery_RE_EV_Sodium.get(1); + static ItemStack RECIPE_Battery_Cadmium = GregtechItemList.Battery_RE_EV_Cadmium.get(1); + static ItemStack RECIPE_Battery_Lithium = GregtechItemList.Battery_RE_EV_Lithium.get(1); + static ItemStack GT_Battery_Sodium = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32539, 1); + static ItemStack GT_Battery_Cadmium = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32537, 1); + static ItemStack GT_Battery_Lithium = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32538, 1); + static ItemStack machineTransformer_EV; + + public static void RECIPES_LOAD(){ + + if (LoadedMods.Gregtech){ + machineTransformer_EV = ItemList.Transformer_EV_HV.get(1); + run(); + } + } + + private static void run(){ + + + UtilsRecipe.addShapedGregtechRecipe( + GT_Battery_Sodium, RECIPES_Machines.cableTier4, GT_Battery_Sodium, + RECIPES_Machines.circuitTier3, machineTransformer_EV, RECIPES_Machines.circuitTier3, + GT_Battery_Sodium, RECIPES_Machines.cableTier4, GT_Battery_Sodium, + RECIPE_Battery_Sodium); + UtilsRecipe.addShapedGregtechRecipe( + GT_Battery_Cadmium, RECIPES_Machines.cableTier4, GT_Battery_Cadmium, + RECIPES_Machines.circuitTier3, machineTransformer_EV, RECIPES_Machines.circuitTier3, + GT_Battery_Cadmium, RECIPES_Machines.cableTier4, GT_Battery_Cadmium, + RECIPE_Battery_Cadmium); + UtilsRecipe.addShapedGregtechRecipe( + GT_Battery_Lithium, RECIPES_Machines.cableTier4, GT_Battery_Lithium, + RECIPES_Machines.circuitTier3, machineTransformer_EV, RECIPES_Machines.circuitTier3, + GT_Battery_Lithium, RECIPES_Machines.cableTier4, GT_Battery_Lithium, + RECIPE_Battery_Lithium); + + } + +} diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPE_CONSTANTS.java b/src/Java/gtPlusPlus/core/recipe/RECIPE_CONSTANTS.java new file mode 100644 index 0000000000..df945bf9ec --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/RECIPE_CONSTANTS.java @@ -0,0 +1,116 @@ +package gtPlusPlus.core.recipe; + +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.item.UtilsItems; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import net.minecraft.item.ItemStack; + +public class RECIPE_CONSTANTS { + + //Machine Components + public static ItemStack electricMotor_LuV; + public static ItemStack electricMotor_ZPM; + public static ItemStack electricMotor_UV; + public static ItemStack electricMotor_MAX; + public static ItemStack electricPump_LuV; + public static ItemStack electricPump_ZPM; + public static ItemStack electricPump_UV; + public static ItemStack electricPump_MAX; + public static ItemStack electricPiston_LuV; + public static ItemStack electricPiston_ZPM; + public static ItemStack electricPiston_UV ; + public static ItemStack electricPiston_MAX; + public static ItemStack robotArm_LuV; + public static ItemStack robotArm_ZPM; + public static ItemStack robotArm_UV; + public static ItemStack robotArm_MAX; + public static ItemStack conveyorModule_LuV; + public static ItemStack conveyorModule_ZPM; + public static ItemStack conveyorModule_UV; + public static ItemStack conveyorModule_MAX; + public static ItemStack emitter_LuV; + public static ItemStack emitter_ZPM; + public static ItemStack emitter_UV; + public static ItemStack emitter_MAX; + public static ItemStack fieldGenerator_LuV; + public static ItemStack fieldGenerator_ZPM; + public static ItemStack fieldGenerator_UV; + public static ItemStack fieldGenerator_MAX; + public static ItemStack sensor_LuV; + public static ItemStack sensor_ZPM; + public static ItemStack sensor_UV; + public static ItemStack sensor_MAX; + + public static void initialise(){ + if(CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK){ + registerGTExperimentalComponents(); + } + else { + registerGTStandardComponents(); + } + } + + private static void registerGTExperimentalComponents(){ + //Machine Components + electricMotor_LuV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32606, 1); + electricMotor_ZPM = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32607, 1); + electricMotor_UV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32608, 1); + electricPump_LuV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32620, 1); + electricPump_ZPM = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32621, 1); + electricPump_UV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32622, 1); + electricPiston_LuV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32645, 1); + electricPiston_ZPM = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32646, 1); + electricPiston_UV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32647, 1); + robotArm_LuV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32655, 1); + robotArm_ZPM = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32656, 1); + robotArm_UV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32657, 1); + conveyorModule_LuV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32636, 1); + conveyorModule_ZPM = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32637, 1); + conveyorModule_UV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32638, 1); + emitter_LuV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32685, 1); + emitter_ZPM = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32686, 1); + emitter_UV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32687, 1); + fieldGenerator_LuV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32675, 1); + fieldGenerator_ZPM = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32676, 1); + fieldGenerator_UV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32677, 1); + sensor_LuV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32695, 1); + sensor_ZPM = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32696, 1); + sensor_UV = UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 32697, 1); + } + + private static void registerGTStandardComponents(){ + electricMotor_LuV = GregtechItemList.Electric_Motor_LuV.get(1); + electricMotor_ZPM = GregtechItemList.Electric_Motor_ZPM.get(1); + electricMotor_UV = GregtechItemList.Electric_Motor_UV.get(1); + electricMotor_MAX = GregtechItemList.Electric_Motor_MAX.get(1); + electricPump_LuV = GregtechItemList.Electric_Pump_LuV.get(1); + electricPump_ZPM = GregtechItemList.Electric_Pump_ZPM.get(1); + electricPump_UV = GregtechItemList.Electric_Pump_UV.get(1); + electricPump_MAX = GregtechItemList.Electric_Pump_MAX.get(1); + electricPiston_LuV = GregtechItemList.Electric_Piston_LuV.get(1); + electricPiston_ZPM = GregtechItemList.Electric_Piston_ZPM.get(1); + electricPiston_UV = GregtechItemList.Electric_Piston_UV.get(1); + electricPiston_MAX = GregtechItemList.Electric_Piston_MAX.get(1); + robotArm_LuV = GregtechItemList.Robot_Arm_LuV.get(1); + robotArm_ZPM = GregtechItemList.Robot_Arm_ZPM.get(1); + robotArm_UV = GregtechItemList.Robot_Arm_UV.get(1); + robotArm_MAX = GregtechItemList.Robot_Arm_MAX.get(1); + conveyorModule_LuV = GregtechItemList.Conveyor_Module_LuV.get(1); + conveyorModule_ZPM = GregtechItemList.Conveyor_Module_ZPM.get(1); + conveyorModule_UV = GregtechItemList.Conveyor_Module_UV.get(1); + conveyorModule_MAX = GregtechItemList.Conveyor_Module_MAX.get(1); + emitter_LuV = GregtechItemList.Emitter_LuV.get(1); + emitter_ZPM = GregtechItemList.Emitter_ZPM.get(1); + emitter_UV = GregtechItemList.Emitter_UV.get(1); + emitter_MAX = GregtechItemList.Emitter_MAX.get(1); + fieldGenerator_LuV = GregtechItemList.Field_Generator_LuV.get(1); + fieldGenerator_ZPM = GregtechItemList.Field_Generator_ZPM.get(1); + fieldGenerator_UV = GregtechItemList.Field_Generator_UV.get(1); + fieldGenerator_MAX = GregtechItemList.Field_Generator_MAX.get(1); + sensor_LuV = GregtechItemList.Sensor_LuV.get(1); + sensor_ZPM = GregtechItemList.Sensor_ZPM.get(1); + sensor_UV = GregtechItemList.Sensor_UV.get(1); + sensor_MAX = GregtechItemList.Sensor_MAX.get(1); + } + +} diff --git a/src/Java/gtPlusPlus/core/recipe/ShapedRecipeObject.java b/src/Java/gtPlusPlus/core/recipe/ShapedRecipeObject.java new file mode 100644 index 0000000000..c6dc1ede1b --- /dev/null +++ b/src/Java/gtPlusPlus/core/recipe/ShapedRecipeObject.java @@ -0,0 +1,42 @@ +package gtPlusPlus.core.recipe; + +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.recipe.UtilsRecipe; +import net.minecraft.item.ItemStack; + +public class ShapedRecipeObject { + + public Object object_A; + public Object object_B; + public Object object_C; + public Object object_D; + public Object object_E; + public Object object_F; + public Object object_G; + public Object object_H; + public Object object_I; + public ItemStack object_OUTPUT; + + public ShapedRecipeObject( + Object input_A,Object input_B,Object input_C, + Object input_D,Object input_E,Object input_F, + Object input_G,Object input_H,Object input_I, + ItemStack input_Output){ + this.object_A = input_A; + this.object_B = input_B; + this.object_C = input_C; + this.object_D = input_D; + this.object_E = input_E; + this.object_F = input_F; + this.object_G = input_G; + this.object_H = input_H; + this.object_I = input_I; + this.object_OUTPUT = input_Output; + Utils.LOG_SPECIFIC_WARNING("ShapedRecipeObject", "New object created.", 36); + } + + public void buildRecipe(){ + UtilsRecipe.recipeBuilder(object_A, object_B, object_C, object_D, object_E, object_F, object_G, object_H, object_I, object_OUTPUT); + } + +} |