diff options
Diffstat (limited to 'src/main/java/gtPlusPlus/xmod/gregtech/loaders')
31 files changed, 7784 insertions, 0 deletions
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/Gregtech_Blocks.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/Gregtech_Blocks.java new file mode 100644 index 0000000000..1a3d07f510 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/Gregtech_Blocks.java @@ -0,0 +1,34 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import gtPlusPlus.core.block.ModBlocks; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaCasingBlocks; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaCasingBlocks2; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaCasingBlocks3; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaCasingBlocks4; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaCasingBlocks5; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaCasingBlocks6; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaCasingBlocksPipeGearbox; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaSpecialMachineCasings; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaSpecialMultiCasings; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaSpecialMultiCasings2; +import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaTieredCasingBlocks1; + +public class Gregtech_Blocks { + + public static void run() { + + // Casing Blocks + ModBlocks.blockCasingsMisc = new GregtechMetaCasingBlocks(); + ModBlocks.blockCasings2Misc = new GregtechMetaCasingBlocks2(); + ModBlocks.blockCasings3Misc = new GregtechMetaCasingBlocks3(); + ModBlocks.blockCasings4Misc = new GregtechMetaCasingBlocks4(); + ModBlocks.blockCasings5Misc = new GregtechMetaCasingBlocks5(); + ModBlocks.blockCasings6Misc = new GregtechMetaCasingBlocks6(); + + ModBlocks.blockCasingsTieredGTPP = new GregtechMetaTieredCasingBlocks1(); + ModBlocks.blockSpecialMultiCasings = new GregtechMetaSpecialMultiCasings(); + ModBlocks.blockSpecialMultiCasings2 = new GregtechMetaSpecialMultiCasings2(); + ModBlocks.blockCustomMachineCasings = new GregtechMetaSpecialMachineCasings(); + ModBlocks.blockCustomPipeGearCasings = new GregtechMetaCasingBlocksPipeGearbox(); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingAngleGrinder.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingAngleGrinder.java new file mode 100644 index 0000000000..e2723e5248 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingAngleGrinder.java @@ -0,0 +1,133 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import net.minecraft.item.ItemStack; + +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_ModHandler; +import gregtech.api.util.GT_ModHandler.RecipeBits; +import gregtech.api.util.GT_OreDictUnificator; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.material.ELEMENT; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.MaterialUtils; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials; +import gtPlusPlus.xmod.gregtech.api.interfaces.internal.Interface_OreRecipeRegistrator; +import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechTools; + +public class ProcessingAngleGrinder implements Interface_OreRecipeRegistrator, Runnable { + + public ProcessingAngleGrinder() { + GregtechOrePrefixes.toolAngleGrinder.add(this); + } + + @Override + public void registerOre(final GregtechOrePrefixes aPrefix, final Materials aMaterial, final String aOreDictName, + final String aModName, final ItemStack aStack) { + if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint)) { + if (aMaterial != Materials.Rubber) { + if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY)) + && (!aMaterial.contains(SubTag.NO_SMASHING))) {} + } + } + } + + @Override + public void registerOre(final GregtechOrePrefixes aPrefix, final GT_Materials aMaterial, final String aOreDictName, + final String aModName, final ItemStack aStack) { + // TODO Auto-generated method stub + + } + + public void materialsLoops() { + final Materials[] i = Materials.values(); + final int size = i.length; + Logger.MATERIALS("Materials to attempt tool gen. with: " + size); + int used = 0; + Materials aMaterial = null; + for (Materials materials : i) { + aMaterial = materials; + if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint) + && (aMaterial != Materials.Rubber) + && (aMaterial != Materials._NULL)) { + if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY)) + && (!aMaterial.contains(SubTag.NO_SMASHING)) + && (!aMaterial.contains(SubTag.TRANSPARENT)) + && (!aMaterial.contains(SubTag.FLAMMABLE)) + && (!aMaterial.contains(SubTag.MAGICAL)) + && (!aMaterial.contains(SubTag.NO_SMELTING))) { + Logger.MATERIALS("Generating Angle Grinder from " + MaterialUtils.getMaterialName(aMaterial)); + // Input 1 + + final ItemStack plate = GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L); + final ItemStack longrod = GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L); + + if ((null != plate && longrod != null)) { + addRecipe(aMaterial, 1600000L, 3, ItemList.Battery_RE_HV_Lithium.get(1)); + addRecipe(aMaterial, 1200000L, 3, ItemList.Battery_RE_HV_Cadmium.get(1)); + addRecipe(aMaterial, 800000L, 3, ItemList.Battery_RE_HV_Sodium.get(1)); + used++; + } else { + Logger.MATERIALS( + "Unable to generate Angle Grinder from " + MaterialUtils.getMaterialName(aMaterial) + + ", Plate or Long Rod may be invalid. Invalid | Plate? " + + (plate == null) + + " | Rod? " + + (longrod == null) + + " |"); + } + // GT_ModHandler.addCraftingRecipe(, + // GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | + // GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"P H", "PIP", " I ", + // Character.valueOf('I'), OrePrefixes.ingot.get(aMaterial), + // Character.valueOf('P'), OrePrefixes.plate.get(aMaterial), + // Character.valueOf('H'), OrePrefixes.toolHeadHammer.get(aMaterial)}); + } else { + Logger + .MATERIALS("Unable to generate Angle Grinder from " + MaterialUtils.getMaterialName(aMaterial)); + } + } else { + Logger.MATERIALS("Unable to generate Angle Grinder from " + MaterialUtils.getMaterialName(aMaterial)); + } + } + + Logger.INFO("Materials used for tool gen: " + used); + } + + @Override + public void run() { + Logger.INFO("Generating Angle Grinders for all valid GT Materials."); + this.materialsLoops(); + } + + public boolean addRecipe(Materials aMaterial, long aBatteryStorage, int aVoltageTier, ItemStack aBattery) { + + ItemStack aOutputStack = MetaGeneratedGregtechTools.INSTANCE.getToolWithStats( + MetaGeneratedGregtechTools.ANGLE_GRINDER, + 1, + aMaterial, + Materials.Titanium, + new long[] { aBatteryStorage, GT_Values.V[aVoltageTier], 3L, -1L }); + + long aDura = MetaGeneratedGregtechTools.getToolMaxDamage(aOutputStack); + if (aDura <= 32000) { + Logger.MATERIALS( + "Unable to generate Angle Grinder from " + MaterialUtils.getMaterialName(aMaterial) + + ", Durability: " + + aDura); + return false; + } + + return GT_ModHandler.addCraftingRecipe( + aOutputStack, + RecipeBits.DISMANTLEABLE | RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | RecipeBits.BUFFERED, + new Object[] { "SXL", "GMG", "PBP", 'X', ItemList.Component_Grinder_Tungsten.get(1), 'M', + CI.getElectricMotor(aVoltageTier, 1), 'S', OrePrefixes.screw.get(Materials.Titanium), 'L', + OrePrefixes.stickLong.get(aMaterial), 'P', OrePrefixes.plate.get(aMaterial), 'G', + ELEMENT.STANDALONE.BLACK_METAL.getGear(1), 'B', aBattery }); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricSnips.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricSnips.java new file mode 100644 index 0000000000..9a60f2c6bf --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricSnips.java @@ -0,0 +1,137 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import net.minecraft.item.ItemStack; + +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 gregtech.common.items.GT_MetaGenerated_Tool_01; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.material.ELEMENT; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.MaterialUtils; +import gtPlusPlus.core.util.minecraft.RecipeUtils; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials; +import gtPlusPlus.xmod.gregtech.api.interfaces.internal.Interface_OreRecipeRegistrator; +import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechTools; + +public class ProcessingElectricSnips implements Interface_OreRecipeRegistrator, Runnable { + + public ProcessingElectricSnips() { + GregtechOrePrefixes.toolElectricSnips.add(this); + } + + @Override + public void registerOre(final GregtechOrePrefixes aPrefix, final Materials aMaterial, final String aOreDictName, + final String aModName, final ItemStack aStack) { + if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint)) { + if (aMaterial != Materials.Rubber) { + if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY)) + && (!aMaterial.contains(SubTag.NO_SMASHING))) {} + } + } + } + + @Override + public void registerOre(final GregtechOrePrefixes aPrefix, final GT_Materials aMaterial, final String aOreDictName, + final String aModName, final ItemStack aStack) { + // TODO Auto-generated method stub + + } + + public void materialsLoops() { + final Materials[] i = Materials.values(); + final int size = i.length; + Logger.MATERIALS("Materials to attempt tool gen. with: " + size); + int used = 0; + Materials aMaterial = null; + for (Materials materials : i) { + aMaterial = materials; + if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint) + && (aMaterial != Materials.Rubber) + && (aMaterial != Materials._NULL)) { + if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY)) + && (!aMaterial.contains(SubTag.NO_SMASHING)) + && (!aMaterial.contains(SubTag.TRANSPARENT)) + && (!aMaterial.contains(SubTag.FLAMMABLE)) + && (!aMaterial.contains(SubTag.MAGICAL)) + && (!aMaterial.contains(SubTag.NO_SMELTING))) { + Logger.MATERIALS("Generating Electric Snips from " + MaterialUtils.getMaterialName(aMaterial)); + // Input 1 + + final ItemStack plate = GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L); + + if ((null != plate)) { + addRecipe(aMaterial, 1600000L, 3, ItemList.Battery_RE_HV_Lithium.get(1)); + addRecipe(aMaterial, 1200000L, 3, ItemList.Battery_RE_HV_Cadmium.get(1)); + addRecipe(aMaterial, 800000L, 3, ItemList.Battery_RE_HV_Sodium.get(1)); + used++; + } else { + Logger.MATERIALS( + "Unable to generate Electric Snips from " + MaterialUtils.getMaterialName(aMaterial) + + ", Plate or Long Rod may be invalid. Invalid | Plate? " + + (plate == null) + + " | Rod? " + + " |"); + } + // GT_ModHandler.addCraftingRecipe(, + // GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | + // GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"P H", "PIP", " I ", + // Character.valueOf('I'), OrePrefixes.ingot.get(aMaterial), + // Character.valueOf('P'), OrePrefixes.plate.get(aMaterial), + // Character.valueOf('H'), OrePrefixes.toolHeadHammer.get(aMaterial)}); + } else { + Logger.MATERIALS( + "Unable to generate Electric Snips from " + MaterialUtils.getMaterialName(aMaterial)); + } + } else { + Logger.MATERIALS("Unable to generate Electric Snips from " + MaterialUtils.getMaterialName(aMaterial)); + } + } + + Logger.INFO("Materials used for tool gen: " + used); + } + + @Override + public void run() { + Logger.INFO("Generating Electric Snips for all valid GT Materials."); + this.materialsLoops(); + } + + public boolean addRecipe(Materials aMaterial, long aBatteryStorage, int aVoltageTier, ItemStack aBattery) { + + ItemStack aOutputStack = MetaGeneratedGregtechTools.INSTANCE.getToolWithStats( + MetaGeneratedGregtechTools.ELECTRIC_SNIPS, + 1, + aMaterial, + Materials.Titanium, + new long[] { aBatteryStorage, GT_Values.V[aVoltageTier], 3L, -1L }); + + ItemStack aInputCutter = GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.WIRECUTTER, 1, aMaterial, aMaterial, null); + + long aDura = MetaGeneratedGregtechTools.getToolMaxDamage(aOutputStack); + if (aDura <= 32000) { + Logger.MATERIALS( + "Unable to generate Electric Snips from " + MaterialUtils.getMaterialName(aMaterial) + + ", Durability: " + + aDura); + return false; + } + return RecipeUtils.addShapedRecipe( + OrePrefixes.wireFine.get(Materials.Electrum), + aInputCutter, + OrePrefixes.wireFine.get(Materials.Electrum), + ELEMENT.STANDALONE.WHITE_METAL.getGear(1), + CI.getElectricMotor(aVoltageTier, 1), + ELEMENT.STANDALONE.WHITE_METAL.getGear(1), + OrePrefixes.plate.get(aMaterial), + aBattery, + OrePrefixes.plate.get(aMaterial), + aOutputStack); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_AlloySmelter.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_AlloySmelter.java new file mode 100644 index 0000000000..d455697330 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_AlloySmelter.java @@ -0,0 +1,63 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeGen_AlloySmelter extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_AlloySmelter(final Material M) { + this.toGenerate = M; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateRecipes(this.toGenerate); + } + + private void generateRecipes(final Material material) { + final int tVoltageMultiplier = material.vVoltageMultiplier; + + // Nuggets + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) + && ItemUtils.checkForInvalidItems(material.getNugget(1))) + GT_Values.RA.addAlloySmelterRecipe( + material.getIngot(1), + ItemList.Shape_Mold_Nugget.get(0), + material.getNugget(9), + (int) Math.max(material.getMass() * 2L, 1L), + tVoltageMultiplier); + + // Gears + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getGear(1))) + GT_Values.RA.addAlloySmelterRecipe( + material.getIngot(8), + ItemList.Shape_Mold_Gear.get(0), + material.getGear(1), + (int) Math.max(material.getMass() * 2L, 1L), + tVoltageMultiplier); + + // Ingot + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) + && ItemUtils.checkForInvalidItems(material.getNugget(1))) + GT_Values.RA.addAlloySmelterRecipe( + material.getNugget(9), + ItemList.Shape_Mold_Ingot.get(0), + material.getIngot(1), + (int) Math.max(material.getMass() * 2L, 1L), + tVoltageMultiplier); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Assembler.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Assembler.java new file mode 100644 index 0000000000..1594568d23 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Assembler.java @@ -0,0 +1,69 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeGen_Assembler extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_Assembler(final Material M) { + this.toGenerate = M; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateRecipes(this.toGenerate); + } + + private void generateRecipes(final Material material) { + + // Frame Box + if (ItemUtils.checkForInvalidItems(new ItemStack[] { material.getRod(1), material.getFrameBox(1) })) + GT_Values.RA.addAssemblerRecipe( + material.getRod(4), + ItemUtils.getGregtechCircuit(4), + material.getFrameBox(1), + 60, + material.vVoltageMultiplier); + + // Rotor + if (ItemUtils + .checkForInvalidItems(new ItemStack[] { material.getPlate(1), material.getRing(1), material.getRotor(1) })) + addAssemblerRecipe( + material.getPlate(4), + material.getRing(1), + material.getRotor(1), + 240, + material.vVoltageMultiplier); + } + + private static void addAssemblerRecipe(final ItemStack input1, final ItemStack input2, final ItemStack output1, + final int seconds, final int euCost) { + GT_Values.RA.addAssemblerRecipe( + input1, + input2, + FluidUtils.getFluidStack("molten.solderingalloy", 16), + output1, + seconds, + euCost); + GT_Values.RA + .addAssemblerRecipe(input1, input2, FluidUtils.getFluidStack("molten.tin", 32), output1, seconds, euCost); + GT_Values.RA + .addAssemblerRecipe(input1, input2, FluidUtils.getFluidStack("molten.lead", 48), output1, seconds, euCost); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Base.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Base.java new file mode 100644 index 0000000000..d000889757 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Base.java @@ -0,0 +1,15 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.core.material.Material; + +public abstract class RecipeGen_Base implements RunnableWithInfo<Material> { + + protected Material toGenerate; + protected boolean disableOptional; + + @Override + public Material getInfoData() { + return toGenerate; + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java new file mode 100644 index 0000000000..2d573c9fb7 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java @@ -0,0 +1,321 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.recipe.GTPPRecipeCategories; +import gtPlusPlus.api.recipe.GTPPRecipeMaps; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.ALLOY; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.material.MaterialStack; +import gtPlusPlus.core.material.nuclear.FLUORIDES; +import gtPlusPlus.core.material.nuclear.NUCLIDE; +import gtPlusPlus.core.material.state.MaterialState; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; + +public class RecipeGen_BlastSmelter extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_BlastSmelter(final Material M) { + this.toGenerate = M; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateARecipe(this.toGenerate); + } + + private void generateARecipe(final Material M) { + + // Add a Blast Smelting Recipe, Let's go! + ItemStack tStack; + if (null != (tStack = M.getDust(1))) { + + final Material[] badMaterials = { FLUORIDES.THORIUM_HEXAFLUORIDE, FLUORIDES.THORIUM_TETRAFLUORIDE, + ALLOY.BLOODSTEEL, NUCLIDE.LiFBeF2ThF4UF4, NUCLIDE.LiFBeF2ZrF4UF4, NUCLIDE.LiFBeF2ZrF4U235 }; + for (final Material R : badMaterials) { + if (M == R) { + return; + } + } + + // Prepare some Variables + ItemStack[] components; + ArrayList<MaterialStack> tMaterial = new ArrayList<>(); + int inputStackCount = 0; + int fluidAmount = 0; + final boolean doTest = true; + tMaterial = M.getComposites(); + + // This Bad boy here is what dictates unique recipes. + ItemStack circuitGT; + + // Set a duration - OLD + /* + * int duration = 0; if (M.getMeltingPointK() > 150){ duration = (int) Math.max(M.getMass() / 50L, 1L) * + * M.getMeltingPointK(); } else { duration = (int) Math.max(M.getMass() / 50L, 1L) * 150; } + */ + + long aVoltage = MaterialUtils.getVoltageForTier(M.vTier); + + // Set a duration - NEW + int duration = 120 * M.vTier * 10; + + if (M.vTier <= 4) { + duration = 20 * M.vTier * 10; + } + + int mMaterialListSize = 0; + + int mTotalPartsCounter = M.smallestStackSizeWhenProcessing; + + if (M.getComposites() != null) { + for (final gtPlusPlus.core.material.MaterialStack ternkfsdf : M.getComposites()) { + if (ternkfsdf != null) { + mMaterialListSize++; + // mTotalPartsCounter += ternkfsdf.getSmallestStackSizes()[0]; + } + } + } else { + mMaterialListSize = 1; + } + + if (duration <= 0) { + final int second = 20; + duration = 14 * second * mMaterialListSize * 8; + } + + Logger.WARNING("[BAS] Size: " + mMaterialListSize); + + // Make a simple one Material MaterialStack[] and log it for validity. + circuitGT = ItemUtils.getGregtechCircuit(1); + final ItemStack[] tItemStackTest = new ItemStack[] { circuitGT, tStack }; + inputStackCount = 1; + fluidAmount = 144 * inputStackCount; + Logger.WARNING( + "[BAS] Adding an Alloy Blast Smelter Recipe for " + M.getLocalizedName() + + ". Gives " + + fluidAmount + + "L of molten metal."); + for (int das = 0; das < tItemStackTest.length; das++) { + if (tItemStackTest[das] != null) { + Logger.WARNING( + "[BAS] tMaterial[" + das + + "]: " + + tItemStackTest[das].getDisplayName() + + " Meta: " + + tItemStackTest[das].getItemDamage() + + ", Amount: " + + tItemStackTest[das].stackSize); + } + } + + final boolean hasMoreInputThanACircuit = (tItemStackTest.length > 1); + + // Generate Recipes for all singular materials that can be made molten. + if (hasMoreInputThanACircuit) { + if (M.requiresBlastFurnace()) { + GT_Values.RA.stdBuilder() + .itemInputs(tItemStackTest) + .fluidOutputs(M.getFluidStack(fluidAmount)) + .duration(duration / (mTotalPartsCounter > 0 ? mTotalPartsCounter : 1)) + .eut(aVoltage) + .recipeCategory(GTPPRecipeCategories.absNonAlloyRecipes) + .addTo(GTPPRecipeMaps.alloyBlastSmelterRecipes); + } else { + Logger.WARNING("[BAS] Failed."); + } + } else { + if (CORE.RA.addBlastSmelterRecipe( + tItemStackTest, + M.getFluidStack(fluidAmount), + 100, + duration / (mTotalPartsCounter > 0 ? mTotalPartsCounter : 1) / 2, + (int) aVoltage)) { + Logger.WARNING("[BAS] Success."); + if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Ingot.get(0), + M.getFluidStack(144), + M.getIngot(1), + duration / 2, + 60)) { + Logger.WARNING("[BAS] Success, Also added a Fluid solidifier recipe."); + /* + * if (GT_Values.RA.addFluidExtractionRecipe(M.getIngot(1), null, M.getFluidStack(144), 100, + * duration/2, 60)){ Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe."); } if + * (GT_Values.RA.addFluidExtractionRecipe(M.getNugget(1), null, M.getFluidStack(16), 100, + * duration/2/9, 60)){ Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe."); } + */ + /* + * if (GT_Values.RA.addFluidExtractionRecipe(M.getSmallDust(1), null, M.getFluid(36), 100, + * duration/2/4, 60)){ Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe."); } + * if (GT_Values.RA.addFluidExtractionRecipe(M.getTinyDust(1), null, M.getFluid(16), 100, + * duration/2/9, 60)){ Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe."); } + */ + } + } else { + Logger.WARNING("[BAS] Failed."); + } + } + + if (tMaterial != null) { + // Reset the Variables for compounds if last recipe was a success. + inputStackCount = 0; + + // If this Material has some kind of compound list, proceed + if (mMaterialListSize > 1) { + final gtPlusPlus.core.material.MaterialStack[] tempStack = new gtPlusPlus.core.material.MaterialStack[mMaterialListSize]; + circuitGT = ItemUtils.getGregtechCircuit(mMaterialListSize); + // Just double checking + if (tempStack.length > 1) { + + // Builds me a MaterialStack[] from the MaterialList of M. + int ooo = 0; + for (final gtPlusPlus.core.material.MaterialStack xMaterial : M.getComposites()) { + if (xMaterial != null) { + if (xMaterial.getStackMaterial() != null) { + Logger.WARNING( + "[BAS] FOUND: " + xMaterial.getStackMaterial() + .getLocalizedName()); + Logger.WARNING( + "[BAS] ADDING: " + xMaterial.getStackMaterial() + .getLocalizedName()); + } + tempStack[ooo] = xMaterial; + } + ooo++; + } + + // Builds me an ItemStack[] of the materials. - Without a circuit - this gets a good count for + // the 144L fluid multiplier + components = new ItemStack[9]; + inputStackCount = 0; + FluidStack componentsFluid = null; + for (int irc = 0; irc < M.getComposites() + .size(); irc++) { + if (M.getComposites() + .get(irc) != null) { + final int r = (int) M.vSmallestRatio[irc]; + inputStackCount = inputStackCount + r; + if ((M.getComposites() + .get(irc) + .getStackMaterial() + .getState() != MaterialState.SOLID) + || !ItemUtils.checkForInvalidItems( + M.getComposites() + .get(irc) + .getDustStack(r))) { + final int xr = r; + if ((xr > 0) && (xr <= 100)) { + final int mathmatics = (r * 1000); + componentsFluid = FluidUtils.getFluidStack( + M.getComposites() + .get(irc) + .getStackMaterial() + .getFluidStack(mathmatics), + mathmatics); + } + } else { + components[irc] = M.getComposites() + .get(irc) + .getUnificatedDustStack(r); + } + } + } + + // Adds a circuit + if ((mMaterialListSize < 9) && (mMaterialListSize != 0)) { + final ItemStack[] components_NoCircuit = components; + // Builds me an ItemStack[] of the materials. - With a circuit + components = new ItemStack[components_NoCircuit.length + 1]; + for (int fr = 0; fr < components.length; fr++) { + if (fr == 0) { + components[0] = circuitGT; + } else { + components[fr] = components_NoCircuit[fr - 1]; + } + } + Logger.WARNING( + "[BAS] Should have added a circuit. mMaterialListSize: " + mMaterialListSize + + " | circuit: " + + components[0].getDisplayName()); + } else { + Logger.WARNING("[BAS] Did not add a circuit. mMaterialListSize: " + mMaterialListSize); + } + + // Set Fluid output + fluidAmount = 144 * inputStackCount; + + Logger.WARNING( + "[BAS] Adding an Alloy Blast Smelter Recipe for " + M.getLocalizedName() + + " using it's compound dusts. This material has " + + inputStackCount + + " parts. Gives " + + fluidAmount + + "L of molten metal."); + Logger.WARNING("[BAS] tMaterial.length: " + components.length + "."); + for (int das = 0; das < components.length; das++) { + if (components[das] != null) { + Logger.WARNING( + "[BAS] tMaterial[" + das + + "]: " + + components[das].getDisplayName() + + " Meta: " + + components[das].getItemDamage() + + ", Amount: " + + components[das].stackSize); + } + } + + // Adds Recipe + if (M.requiresBlastFurnace()) { + if (CORE.RA.addBlastSmelterRecipe( + components, + componentsFluid, + M.getFluidStack(fluidAmount), + 100, + duration, + (int) aVoltage)) { + Logger.WARNING("[BAS] Success."); + } else { + Logger.WARNING("[BAS] Failed."); + } + } else { + if (CORE.RA.addBlastSmelterRecipe( + components, + componentsFluid, + M.getFluidStack(fluidAmount), + 100, + duration, + (int) aVoltage / 2)) { + Logger.WARNING("[BAS] Success."); + } else { + Logger.WARNING("[BAS] Failed."); + } + } + } + } + } else { + Logger.WARNING("[BAS] doTest: " + doTest + " | tMaterial != null: " + (tMaterial != null)); + } + } + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelterGT_GTNH.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelterGT_GTNH.java new file mode 100644 index 0000000000..5398a6a0b5 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelterGT_GTNH.java @@ -0,0 +1,252 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +import org.apache.commons.lang3.ArrayUtils; + +import gregtech.api.enums.GT_Values; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GT_Recipe; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.minecraft.ItemStackData; +import gtPlusPlus.api.recipe.GTPPRecipeCategories; +import gtPlusPlus.api.recipe.GTPPRecipeMaps; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.math.MathUtils; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeGen_BlastSmelterGT_GTNH { + + private static Map<String, FluidStack> mCachedIngotToFluidRegistry = new HashMap<>(); + private static Map<String, String> mCachedHotToColdRegistry = new HashMap<>(); + + private static synchronized void setIngotToFluid(final ItemStackData stack, final FluidStack fluid) { + if (stack != null && fluid != null) { + mCachedIngotToFluidRegistry.put(stack.getUniqueDataIdentifier(), fluid); + } + } + + private static synchronized void setHotToCold(final ItemStackData hot, final ItemStackData cold) { + if (hot != null && cold != null) { + mCachedHotToColdRegistry.put(hot.getUniqueDataIdentifier(), cold.getUniqueDataIdentifier()); + } + } + + private static synchronized FluidStack getFluidFromIngot(final ItemStackData ingot) { + ItemStackData h = ingot; + if (mCachedIngotToFluidRegistry.containsKey(h.getUniqueDataIdentifier())) { + Logger.MACHINE_INFO("[ABS] mCachedIngotToFluidRegistry contains Output Ingot."); + return mCachedIngotToFluidRegistry.get(h.getUniqueDataIdentifier()); + } + if (mCachedHotToColdRegistry.containsKey(h.getUniqueDataIdentifier())) { + Logger.MACHINE_INFO("[ABS] mCachedHotToColdRegistry contains Output Ingot."); + return mCachedIngotToFluidRegistry.get(mCachedHotToColdRegistry.get(h.getUniqueDataIdentifier())); + } + Logger.MACHINE_INFO("[ABS] Neither Cache contains Output Ingot."); + return null; + } + + private static boolean isValid(final ItemStack[] inputs, final ItemStack outputs[], final FluidStack[] fluidIn, + final FluidStack fluidOut) { + if (inputs != null && outputs != null + && fluidIn != null + && fluidOut != null + && inputs.length > 0 + && outputs.length > 0) { + return true; + } + return false; + } + + public static synchronized boolean generateGTNHBlastSmelterRecipesFromEBFList() { + + // Make a counting object + int mSuccess = 0; + + Logger.INFO("[ABS] Starting recipe generation based on EBF recipe map."); + Logger.INFO("[ABS] Caching Ingots and their Molten fluid.."); + // Ingots/Dusts -> Fluids + for (GT_Recipe x : RecipeMaps.fluidExtractionRecipes.getAllRecipes()) { + ItemStack validInput = null; + FluidStack validOutput = null; + // If there aren't both non empty inputs and outputs, we skip + if (ArrayUtils.isEmpty(x.mInputs) || ArrayUtils.isEmpty(x.mFluidOutputs)) { + continue; + } + + for (int tag : OreDictionary.getOreIDs(x.mInputs[0])) { + String oreName = OreDictionary.getOreName(tag) + .toLowerCase(); + String mType = "ingot"; + if (oreName.startsWith(mType) && !oreName.contains("double") + && !oreName.contains("triple") + && !oreName.contains("quad") + && !oreName.contains("quintuple")) { + validInput = x.mInputs[0]; + } + } + + validOutput = x.mFluidOutputs[0]; + + if (validInput != null) { + ItemStackData R = new ItemStackData(validInput); + setIngotToFluid(R, validOutput); + Logger.MACHINE_INFO( + "[ABS][I2F] Cached " + validInput.getDisplayName() + + " to " + + validOutput.getLocalizedName() + + ". Stored Under ID of " + + R.getUniqueDataIdentifier()); + } + } + + Logger.INFO("[ABS] Caching Ingots and their Hot form..."); + // Hot Ingots -> Cold Ingots + for (GT_Recipe x : RecipeMaps.vacuumFreezerRecipes.getAllRecipes()) { + ItemStack validInput = null; + ItemStack validOutput = null; + // If we the input is an ingot and it and the output are valid, map it to cache. + if (ArrayUtils.isNotEmpty(x.mInputs) && x.mInputs[0] != null) { + validInput = x.mInputs[0]; + } + if (ArrayUtils.isNotEmpty(x.mOutputs) && x.mOutputs[0] != null) { + validOutput = x.mOutputs[0]; + } + if (validInput != null && validOutput != null) { + ItemStackData R1 = new ItemStackData(validInput); + ItemStackData R2 = new ItemStackData(validOutput); + setHotToCold(R1, R2); + Logger.MACHINE_INFO( + "[ABS][H2C] Cached " + validInput.getDisplayName() + + " to " + + validOutput.getDisplayName() + + ". Stored Under ID of " + + R1.getUniqueDataIdentifier() + + ", links to ID " + + R2.getUniqueDataIdentifier()); + } + } + + Logger.INFO("[ABS] Generating recipes based on existing EBF recipes."); + // Okay, so now lets Iterate existing EBF recipes. + for (GT_Recipe x : RecipeMaps.blastFurnaceRecipes.getAllRecipes()) { + ItemStack[] inputs, outputs; + FluidStack[] inputsF; + int voltage, time, special; + boolean enabled; + inputs = x.mInputs.clone(); + outputs = x.mOutputs.clone(); + inputsF = x.mFluidInputs.clone(); + voltage = x.mEUt; + time = x.mDuration; + enabled = x.mEnabled; + special = x.mSpecialValue; + + // continue to next recipe if the Temp is too high. + if (special > 3600) { + Logger.MACHINE_INFO("[ABS] Skipping ABS addition for GTNH due to temp."); + continue; + } else { + FluidStack mMoltenStack = null; + int mMoltenCount = 0; + // If We have a valid Output, let's try use our cached data to get it's molten form. + if (x.mOutputs != null && x.mOutputs[0] != null) { + mMoltenCount = x.mOutputs[0].stackSize; + ItemStackData R = new ItemStackData(x.mOutputs[0]); + Logger.MACHINE_INFO( + "[ABS] Found " + x.mOutputs[0].getDisplayName() + + " as valid EBF output, finding it's fluid from the cache. We will require " + + (144 * mMoltenCount) + + "L. Looking for ID " + + R.getUniqueDataIdentifier()); + FluidStack tempFluid = getFluidFromIngot(R); + if (tempFluid != null) { + // Logger.MACHINE_INFO("[ABS] Got Fluid from Cache."); + mMoltenStack = FluidUtils.getFluidStack(tempFluid, mMoltenCount * 144); + } else { + Logger.MACHINE_INFO("[ABS] Failed to get Fluid from Cache."); + } + } + // If this recipe is enabled and we have a valid molten fluidstack, let's try add this recipe. + if (enabled && isValid(inputs, outputs, inputsF, mMoltenStack)) { + // Boolean to decide whether or not to create a new circuit later + boolean circuitFound = false; + + // Build correct input stack + ArrayList<ItemStack> aTempList = new ArrayList<>(); + for (ItemStack recipeItem : inputs) { + if (ItemUtils.isControlCircuit(recipeItem)) { + circuitFound = true; + } + aTempList.add(recipeItem); + } + + inputs = aTempList.toArray(new ItemStack[aTempList.size()]); + int inputLength = inputs.length; + // If no circuit was found, increase array length by 1 to add circuit at newInput[0] + if (!circuitFound) { + inputLength++; + } + + ItemStack[] newInput = new ItemStack[inputLength]; + + int l = 0; + // If no circuit was found, add a circuit here + if (!circuitFound) { + l = 1; + newInput[0] = CI.getNumberedCircuit(inputs.length); + } + + for (ItemStack y : inputs) { + newInput[l++] = y; + } + + GT_Values.RA.stdBuilder() + .itemInputs(newInput) + .fluidInputs(inputsF) + .fluidOutputs(mMoltenStack) + .duration(MathUtils.roundToClosestInt(time * 0.8)) + .eut(voltage) + .recipeCategory( + inputLength <= 2 ? GTPPRecipeCategories.absNonAlloyRecipes + : GTPPRecipeMaps.alloyBlastSmelterRecipes.getDefaultRecipeCategory()) + .addTo(GTPPRecipeMaps.alloyBlastSmelterRecipes); + } else { + if (!enabled) { + Logger.MACHINE_INFO("[ABS] Failure. EBF recipe was not enabled."); + } else { + Logger.MACHINE_INFO("[ABS] Failure. Invalid Inputs or Outputs."); + if (inputs == null) { + Logger.MACHINE_INFO("[ABS] Inputs were not Valid."); + } else { + Logger.MACHINE_INFO("[ABS] inputs size: " + inputs.length); + } + if (outputs == null) { + Logger.MACHINE_INFO("[ABS] Outputs were not Valid."); + } else { + Logger.MACHINE_INFO("[ABS] outputs size: " + outputs.length); + } + if (inputsF == null) { + Logger.MACHINE_INFO("[ABS] Input Fluids were not Valid."); + } else { + Logger.MACHINE_INFO("[ABS] inputsF size: " + inputsF.length); + } + if (mMoltenStack == null) { + Logger.MACHINE_INFO("[ABS] Output Fluid were not Valid."); + } + } + } + } + } + + Logger.INFO("[ABS] Processed " + mSuccess + " recipes."); + return mSuccess > 0; + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_DustGeneration.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_DustGeneration.java new file mode 100644 index 0000000000..1499ea3cad --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_DustGeneration.java @@ -0,0 +1,448 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.material.MaterialStack; +import gtPlusPlus.core.material.state.MaterialState; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.math.MathUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.RecipeUtils; + +public class RecipeGen_DustGeneration extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_DustGeneration(final Material M) { + this(M, false); + } + + public RecipeGen_DustGeneration(final Material M, final boolean O) { + this.toGenerate = M; + this.disableOptional = O; + mRecipeGenMap.add(this); + final ItemStack normalDust = M.getDust(1); + final ItemStack smallDust = M.getSmallDust(1); + final ItemStack tinyDust = M.getTinyDust(1); + if (tinyDust != null && normalDust != null) { + if (RecipeUtils.addShapedRecipe( + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + normalDust)) { + Logger.INFO("9 Tiny dust to 1 Dust Recipe: " + M.getLocalizedName() + " - Success"); + } else { + Logger.INFO("9 Tiny dust to 1 Dust Recipe: " + M.getLocalizedName() + " - Failed"); + } + + if (RecipeUtils + .addShapedRecipe(normalDust, null, null, null, null, null, null, null, null, M.getTinyDust(9))) { + Logger.INFO("9 Tiny dust from 1 Recipe: " + M.getLocalizedName() + " - Success"); + } else { + Logger.INFO("9 Tiny dust from 1 Recipe: " + M.getLocalizedName() + " - Failed"); + } + } + + if (smallDust != null && normalDust != null) { + if (RecipeUtils.addShapedRecipe( + smallDust, + smallDust, + null, + smallDust, + smallDust, + null, + null, + null, + null, + normalDust)) { + Logger.INFO("4 Small dust to 1 Dust Recipe: " + M.getLocalizedName() + " - Success"); + } else { + Logger.INFO("4 Small dust to 1 Dust Recipe: " + M.getLocalizedName() + " - Failed"); + } + if (RecipeUtils + .addShapedRecipe(null, normalDust, null, null, null, null, null, null, null, M.getSmallDust(4))) { + Logger.INFO("4 Small dust from 1 Dust Recipe: " + M.getLocalizedName() + " - Success"); + } else { + Logger.INFO("4 Small dust from 1 Dust Recipe: " + M.getLocalizedName() + " - Failed"); + } + } + } + + @Override + public void run() { + generateRecipes(this.toGenerate, this.disableOptional); + } + + private void generateRecipes(final Material material, final boolean disableOptional) { + + Logger.INFO("Generating Shaped Crafting recipes for " + material.getLocalizedName()); + + final ItemStack normalDust = material.getDust(1); + final ItemStack smallDust = material.getSmallDust(1); + final ItemStack tinyDust = material.getTinyDust(1); + + final ItemStack[] inputStacks = material.getMaterialComposites(); + final ItemStack outputStacks = material.getDust(material.smallestStackSizeWhenProcessing); + + // Macerate blocks back to dusts. + final ItemStack materialBlock = material.getBlock(1); + final ItemStack materialFrameBox = material.getFrameBox(1); + + if (ItemUtils.checkForInvalidItems(materialBlock)) { + GT_ModHandler.addPulverisationRecipe(materialBlock, material.getDust(9)); + } + + if (ItemUtils.checkForInvalidItems(materialFrameBox)) { + GT_ModHandler.addPulverisationRecipe(materialFrameBox, material.getDust(2)); + } + + if (ItemUtils.checkForInvalidItems(smallDust) && ItemUtils.checkForInvalidItems(tinyDust)) { + generatePackagerRecipes(material); + } + + ItemStack ingot = material.getIngot(1); + if (ItemUtils.checkForInvalidItems(normalDust) && ItemUtils.checkForInvalidItems(ingot)) { + addFurnaceRecipe(material); + addMacerationRecipe(material); + } + + // Is this a composite? + if ((inputStacks != null) && !disableOptional) { + // Is this a composite? + Logger.WARNING("mixer length: " + inputStacks.length); + if ((inputStacks.length != 0) && (inputStacks.length <= 4)) { + // Log Input items + Logger.WARNING(ItemUtils.getArrayStackNames(inputStacks)); + final long[] inputStackSize = material.vSmallestRatio; + Logger.WARNING("mixer is stacksizeVar null? " + (inputStackSize != null)); + // Is smallest ratio invalid? + if (inputStackSize != null) { + // set stack sizes on an input ItemStack[] + for (short x = 0; x < inputStacks.length; x++) { + if ((inputStacks[x] != null) && (inputStackSize[x] != 0)) { + inputStacks[x].stackSize = (int) inputStackSize[x]; + } + } + // Relog input values, with stack sizes + Logger.WARNING(ItemUtils.getArrayStackNames(inputStacks)); + + // Get us four ItemStacks to input into the mixer + ItemStack[] input = new ItemStack[4]; + + input[0] = (inputStacks.length >= 1) ? ((inputStacks[0] == null) ? null : inputStacks[0]) : null; + input[1] = (inputStacks.length >= 2) ? ((inputStacks[1] == null) ? null : inputStacks[1]) : null; + input[2] = (inputStacks.length >= 3) ? ((inputStacks[2] == null) ? null : inputStacks[2]) : null; + input[3] = (inputStacks.length >= 4) ? ((inputStacks[3] == null) ? null : inputStacks[3]) : null; + + if (inputStacks.length == 1) { + input[1] = input[0]; + input[0] = CI.getNumberedCircuit(inputStacks.length + 10); + } else if (inputStacks.length == 2) { + input[2] = input[1]; + input[1] = input[0]; + input[0] = CI.getNumberedCircuit(inputStacks.length + 10); + + } else if (inputStacks.length == 3) { + input[3] = input[2]; + input[2] = input[1]; + input[1] = input[0]; + input[0] = CI.getNumberedCircuit(inputStacks.length + 10); + } + + /* + * for (int g = 0; g<4; g++) { if(inputStacks.length > g) { input[g] = inputStacks[g] != null ? + * inputStacks[g] : null; } else { input[g] = CI.getNumberedCircuit(g+10); break; } } + */ + + // Add mixer Recipe + FluidStack oxygen = GT_Values.NF; + if (material.getComposites() != null) { + for (final MaterialStack x : material.getComposites()) { + if (!material.getComposites() + .isEmpty()) { + if (x != null) { + if (x.getStackMaterial() != null) { + if (x.getStackMaterial() + .getDust(1) == null) { + if (x.getStackMaterial() + .getState() != MaterialState.SOLID + && x.getStackMaterial() + .getState() != MaterialState.ORE + && x.getStackMaterial() + .getState() != MaterialState.PLASMA) { + oxygen = x.getStackMaterial() + .getFluidStack(1000); + break; + } + } + } + } + } + } + } + + input = ItemUtils.cleanItemStackArray(input); + + // Add mixer Recipe + if (GT_Values.RA.addMixerRecipe( + input[0], + input[1], + input[2], + input[3], + oxygen, + null, + outputStacks, + (int) Math.max(material.getMass() * 2L * 1, 1), + material.vVoltageMultiplier)) // Was 6, but let's try 2. This makes Potin LV, for example. + { + Logger.WARNING("Dust Mixer Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Dust Mixer Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Add Shapeless recipe for low tier alloys. + /* + * if (tVoltageMultiplier <= 30){ if (RecipeUtils.addShapedGregtechRecipe(inputStacks, + * outputStacks)){ + * Logger.WARNING("Dust Shapeless Recipe: "+material.getLocalizedName()+" - Success"); } else { + * Logger.WARNING("Dust Shapeless Recipe: "+material.getLocalizedName()+" - Failed"); } } + */ + } + } + } + } + + public static boolean addMixerRecipe_Standalone(final Material material) { + final ItemStack[] inputStacks = material.getMaterialComposites(); + final ItemStack outputStacks = material.getDust(material.smallestStackSizeWhenProcessing); + // Is this a composite? + if ((inputStacks != null)) { + // Is this a composite? + Logger.WARNING("mixer length: " + inputStacks.length); + if ((inputStacks.length >= 1) && (inputStacks.length <= 4)) { + // Log Input items + Logger.WARNING(ItemUtils.getArrayStackNames(inputStacks)); + final long[] inputStackSize = material.vSmallestRatio; + Logger.WARNING("mixer is stacksizeVar not null? " + (inputStackSize != null)); + // Is smallest ratio invalid? + if (inputStackSize != null) { + // set stack sizes on an input ItemStack[] + for (short x = 0; x < inputStacks.length; x++) { + if ((inputStacks[x] != null) && (inputStackSize[x] != 0)) { + inputStacks[x].stackSize = (int) inputStackSize[x]; + } + } + // Relog input values, with stack sizes + Logger.WARNING(ItemUtils.getArrayStackNames(inputStacks)); + + // Get us four ItemStacks to input into the mixer + ItemStack input1, input2, input3, input4; + input1 = inputStacks[0]; + input2 = (inputStacks.length >= 2) ? (input2 = (inputStacks[1] == null) ? null : inputStacks[1]) + : null; + input3 = (inputStacks.length >= 3) ? (input3 = (inputStacks[2] == null) ? null : inputStacks[2]) + : null; + input4 = (inputStacks.length >= 4) ? (input4 = (inputStacks[3] == null) ? null : inputStacks[3]) + : null; + + if (inputStacks.length == 1) { + input2 = input1; + input1 = CI.getNumberedCircuit(20); + } else if (inputStacks.length == 2) { + input3 = input2; + input2 = input1; + input1 = CI.getNumberedCircuit(20); + + } else if (inputStacks.length == 3) { + input4 = input3; + input3 = input2; + input2 = input1; + input1 = CI.getNumberedCircuit(20); + } + + // Add mixer Recipe + FluidStack oxygen = GT_Values.NF; + if (material.getComposites() != null) { + int compSlot = 0; + for (final MaterialStack x : material.getComposites()) { + if (!material.getComposites() + .isEmpty()) { + if (x != null) { + if (x.getStackMaterial() != null) { + if (x.getStackMaterial() + .getDust(1) == null) { + MaterialState f = x.getStackMaterial() + .getState(); + if (f == MaterialState.GAS || f == MaterialState.LIQUID + || f == MaterialState.PURE_LIQUID + || f == MaterialState.PURE_GAS) { + oxygen = x.getStackMaterial() + .getFluidStack((int) (material.vSmallestRatio[compSlot] * 1000)); + } + } + } + } + } + compSlot++; + } + } + + // Add mixer Recipe + try { + if (GT_Values.RA.addMixerRecipe( + input1, + input2, + input3, + input4, + oxygen, + null, + outputStacks, + (int) Math.max(material.getMass() * 2L * 1, 1), + material.vVoltageMultiplier)) // Was 6, but let's try 2. This makes Potin LV, for + // example. + { + Logger.WARNING("Dust Mixer Recipe: " + material.getLocalizedName() + " - Success"); + return true; + } else { + Logger.WARNING("Dust Mixer Recipe: " + material.getLocalizedName() + " - Failed"); + return false; + } + } catch (Throwable t) { + t.printStackTrace(); + } + } else { + Logger.WARNING("inputStackSize == NUll - " + material.getLocalizedName()); + } + } else { + Logger.WARNING("InputStacks is out range 1-4 - " + material.getLocalizedName()); + } + } else { + Logger.WARNING("InputStacks == NUll - " + material.getLocalizedName()); + } + return false; + } + + public static boolean generatePackagerRecipes(Material aMatInfo) { + AutoMap<Boolean> aResults = new AutoMap<>(); + // Small Dust + aResults.put( + GT_Values.RA.addBoxingRecipe( + GT_Utility.copyAmount(4L, new Object[] { aMatInfo.getSmallDust(4) }), + ItemList.Schematic_Dust.get(0L, new Object[0]), + aMatInfo.getDust(1), + 100, + 4)); + // Tiny Dust + aResults.put( + GT_Values.RA.addBoxingRecipe( + GT_Utility.copyAmount(9L, new Object[] { aMatInfo.getTinyDust(9) }), + ItemList.Schematic_Dust.get(0L, new Object[0]), + aMatInfo.getDust(1), + 100, + 4)); + + for (boolean b : aResults) { + if (!b) { + return false; + } + } + return true; + } + + private void addMacerationRecipe(Material aMatInfo) { + try { + Logger.MATERIALS("Adding Maceration recipe for " + aMatInfo.getLocalizedName() + " Ingot -> Dusts"); + final int chance = (aMatInfo.vTier * 10) / MathUtils.randInt(10, 20); + GT_ModHandler.addPulverisationRecipe(aMatInfo.getIngot(1), aMatInfo.getDust(1), null, chance); + } catch (Throwable t) { + t.printStackTrace(); + } + } + + private void addFurnaceRecipe(Material aMatInfo) { + + ItemStack aDust = aMatInfo.getDust(1); + ItemStack aOutput; + try { + if (aMatInfo.requiresBlastFurnace()) { + aOutput = aMatInfo.getHotIngot(1); + if (ItemUtils.checkForInvalidItems(aOutput)) { + if (addBlastFurnaceRecipe(aMatInfo, aDust, null, aOutput, null, aMatInfo.getMeltingPointK())) { + Logger + .MATERIALS("Successfully added a blast furnace recipe for " + aMatInfo.getLocalizedName()); + } else { + Logger.MATERIALS("Failed to add a blast furnace recipe for " + aMatInfo.getLocalizedName()); + } + } else { + Logger.MATERIALS("Failed to add a blast furnace recipe for " + aMatInfo.getLocalizedName()); + } + } else { + aOutput = aMatInfo.getIngot(1); + if (ItemUtils.checkForInvalidItems(aOutput)) { + if (CORE.RA.addSmeltingAndAlloySmeltingRecipe(aDust, aOutput)) { + Logger.MATERIALS("Successfully added a furnace recipe for " + aMatInfo.getLocalizedName()); + } else { + Logger.MATERIALS("Failed to add a furnace recipe for " + aMatInfo.getLocalizedName()); + } + } + } + } catch (Throwable t) { + t.printStackTrace(); + } + } + + private boolean addBlastFurnaceRecipe(Material aMatInfo, final ItemStack input1, final ItemStack input2, + final ItemStack output1, final ItemStack output2, final int tempRequired) { + + try { + int timeTaken = 125 * aMatInfo.vTier * 10; + + if (aMatInfo.vTier <= 4) { + timeTaken = 25 * aMatInfo.vTier * 10; + } + int aSlot = aMatInfo.vTier; + if (aSlot < 2) { + aSlot = 2; + } + long aVoltage = aMatInfo.vVoltageMultiplier; + + return GT_Values.RA.addBlastRecipe( + input1, + input2, + GT_Values.NF, + GT_Values.NF, + output1, + output2, + timeTaken, + (int) aVoltage, + tempRequired); + } catch (Throwable t) { + t.printStackTrace(); + return false; + } + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Extruder.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Extruder.java new file mode 100644 index 0000000000..a69a96b925 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Extruder.java @@ -0,0 +1,159 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeGen_Extruder extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_Extruder(final Material M) { + this.toGenerate = M; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateRecipes(this.toGenerate); + } + + private void generateRecipes(final Material material) { + + final ItemStack itemIngot = material.getIngot(1); + final ItemStack itemPlate = material.getPlate(1); + final ItemStack itemGear = material.getGear(1); + + final ItemStack shape_Plate = ItemList.Shape_Extruder_Plate.get(0); + final ItemStack shape_Ring = ItemList.Shape_Extruder_Ring.get(0); + final ItemStack shape_Gear = ItemList.Shape_Extruder_Gear.get(0); + final ItemStack shape_Rod = ItemList.Shape_Extruder_Rod.get(0); + final ItemStack shape_Bolt = ItemList.Shape_Extruder_Bolt.get(0); + final ItemStack shape_Block = ItemList.Shape_Extruder_Block.get(0); + final ItemStack shape_Ingot = ItemList.Shape_Extruder_Ingot.get(0); + + Logger.WARNING("Generating Extruder recipes for " + material.getLocalizedName()); + + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) + && ItemUtils.checkForInvalidItems(material.getBlock(1))) { + // Ingot Recipe + if (GT_Values.RA.addExtruderRecipe( + material.getBlock(1), + shape_Ingot, + material.getIngot(9), + (int) Math.max(material.getMass() * 2L * 1, 1), + material.vVoltageMultiplier)) { + Logger.WARNING("Extruder Ingot Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Extruder Ingot Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Block Recipe + if (GT_Values.RA.addExtruderRecipe( + material.getIngot(9), + shape_Block, + material.getBlock(1), + (int) Math.max(material.getMass() * 2L * 1, 1), + material.vVoltageMultiplier)) { + Logger.WARNING("Extruder Block Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Extruder Block Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Plate Recipe + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) + && ItemUtils.checkForInvalidItems(material.getPlate(1))) + if (GT_Values.RA.addExtruderRecipe(itemIngot, shape_Plate, itemPlate, 10, material.vVoltageMultiplier)) { + Logger.WARNING("Extruder Plate Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Extruder Plate Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Ring Recipe + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getRing(1))) + if (!material.isRadioactive) { + if (GT_Values.RA.addExtruderRecipe( + itemIngot, + shape_Ring, + material.getRing(4), + (int) Math.max(material.getMass() * 2L * 1, 1), + material.vVoltageMultiplier)) { + Logger.WARNING("Extruder Ring Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Extruder Ring Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Gear Recipe + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getGear(1))) + if (!material.isRadioactive) { + if (GT_Values.RA.addExtruderRecipe( + material.getIngot(4), + shape_Gear, + itemGear, + (int) Math.max(material.getMass() * 5L, 1), + material.vVoltageMultiplier)) { + Logger.WARNING("Extruder Gear Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Extruder Gear Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Rod Recipe + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getRod(1))) + if (GT_Values.RA.addExtruderRecipe( + itemIngot, + shape_Rod, + material.getRod(2), + (int) Math.max(material.getMass() * 2L * 1, 1), + material.vVoltageMultiplier)) { + Logger.WARNING("Extruder Rod Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Extruder Rod Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Bolt Recipe + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getBolt(1))) + if (!material.isRadioactive) { + if (GT_Values.RA.addExtruderRecipe( + itemIngot, + shape_Bolt, + material.getBolt(8), + (int) Math.max(material.getMass() * 2L * 1, 1), + material.vVoltageMultiplier)) { + Logger.WARNING("Extruder Bolt Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Extruder Bolt Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Rotor Recipe + // Shape_Extruder_Rotor + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) + && ItemUtils.checkForInvalidItems(material.getRotor(1))) + if (GT_Values.RA.addExtruderRecipe( + material.getIngot(5), + ItemList.Shape_Extruder_Rotor.get(0), + material.getRotor(1), + (int) Math.max(material.getMass() * 5L * 1, 1), + material.vVoltageMultiplier)) { + Logger.WARNING("Extruder Rotor Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Extruder Rotor Recipe: " + material.getLocalizedName() + " - Failed"); + } + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_FluidCanning.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_FluidCanning.java new file mode 100644 index 0000000000..fb6dc807ef --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_FluidCanning.java @@ -0,0 +1,222 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.recipe.RecipeMap; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GT_Recipe; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.reflect.ReflectionUtils; + +public class RecipeGen_FluidCanning implements Runnable { + + public static void init() { + FluidCanningRunnableHandler x = new FluidCanningRunnableHandler(); + x.run(); + } + + private static class FluidCanningRunnableHandler implements RunnableWithInfo<String> { + + @Override + public void run() { + mHasRun = true; + for (RecipeGen_FluidCanning aRecipe : mCache) { + aRecipe.run(); + } + } + + @Override + public String getInfoData() { + return "Fluid Canning Recipes"; + } + } + + private static boolean mHasRun = false; + + private static HashSet<RecipeGen_FluidCanning> mCache = new HashSet<>(); + + private static void addRunnableToRecipeCache(RecipeGen_FluidCanning r) { + if (mHasRun) { + CORE.crash(); + } + mCache.add(r); + } + + protected boolean disableOptional; + + private final GT_Recipe recipe; + private final boolean isValid; + + public boolean valid() { + return isValid; + } + + // Alternative Constructor + public RecipeGen_FluidCanning(boolean aExtracting, ItemStack aEmpty, ItemStack aFull, FluidStack aFluidIn, + FluidStack aFluidOut, Integer aDuration, Integer aEUt) { + ItemStack aInput; + ItemStack aOutput; + FluidStack aFluidInput; + FluidStack aFluidOutput; + + // Safety check on the duration + if (aDuration == null || aDuration <= 0) { + aDuration = (aFluidIn != null) ? (aFluidIn.amount / 62) + : ((aFluidOut != null) ? (aFluidOut.amount / 62) : 10); + } + + // Safety check on the EU + if (aEUt == null || aEUt <= 0) { + if (aExtracting) { + aEUt = 2; + } else { + aEUt = 1; + } + } + + // Set Item stacks correctly, invert if extraction recipe. + if (aExtracting) { + aInput = aFull; + aOutput = aEmpty; + aFluidInput = GT_Values.NF; + aFluidOutput = aFluidIn; + } else { + aInput = aEmpty; + aOutput = aFull; + aFluidInput = aFluidIn; + aFluidOutput = aFluidOut != null ? aFluidOut : GT_Values.NF; + } + + // Check validity + + GT_Recipe aRecipe = new GT_Recipe( + true, + new ItemStack[] { aInput }, + new ItemStack[] { aOutput }, + null, + new int[] { 10000 }, + new FluidStack[] { aFluidInput }, + new FluidStack[] { aFluidOutput }, + aDuration, + aEUt, + 0); + + // Check Valid + boolean aTempValidityCheck = false; + // Logger.INFO("Validity Check."); + if (aExtracting) { + Logger.INFO("Extracting."); + if (aInput != null && aFluidOutput != null) { + // Logger.INFO("Pass."); + aTempValidityCheck = true; + } + } else { + // Logger.INFO("Canning."); + if (aInput != null && aOutput != null && (aFluidInput != null || aFluidOutput != null)) { + // Logger.INFO("Pass."); + aTempValidityCheck = true; + } + } + + if (aTempValidityCheck) { + // Valid Recipe + recipe = aRecipe; + disableOptional = aExtracting; + isValid = true; + addRunnableToRecipeCache(this); + } else { + // Logger.INFO("Failed Validity Check."); + isValid = false; + disableOptional = aExtracting; + aRecipe.mEnabled = false; + aRecipe.mHidden = true; + recipe = null; + } + } + + @Override + public void run() { + Logger.INFO("Processing Recipe with Hash: " + recipe.hashCode()); + generateRecipes(); + } + + private void generateRecipes() { + if (isValid && recipe != null) { + if (this.disableOptional) { + addFluidExtractionRecipe(recipe); + } else { + addFluidCannerRecipe(recipe); + } + } + } + + private void addFluidExtractionRecipe(GT_Recipe aRecipe) { + CORE.crash(); + Logger.INFO( + "[FE-Debug] " + aRecipe.mFluidOutputs[0].amount + + "L of " + + aRecipe.mFluidOutputs[0].getLocalizedName() + + " fluid extractor from 1 " + + aRecipe.mInputs[0].getDisplayName() + + " - Success. Time: " + + aRecipe.mDuration + + ", Voltage: " + + aRecipe.mEUt); + int aCount1 = getMapSize(RecipeMaps.fluidExtractionRecipes); + int aCount2 = aCount1; + RecipeMaps.fluidExtractionRecipes.addRecipe(aRecipe); + aCount1 = getMapSize(RecipeMaps.fluidExtractionRecipes); + if (aCount1 <= aCount2) { + Logger.INFO( + "[ERROR] Failed adding Extraction recipe for " + ItemUtils.getArrayStackNames(aRecipe.mInputs) + + ", " + + ItemUtils.getArrayStackNames(aRecipe.mOutputs) + + ", " + + ItemUtils.getArrayStackNames(aRecipe.mFluidInputs) + + ", " + + ItemUtils.getArrayStackNames(aRecipe.mFluidOutputs)); + dumpStack(); + } + } + + private void addFluidCannerRecipe(GT_Recipe aRecipe) { + boolean result; + int aCount1 = getMapSize(RecipeMaps.fluidCannerRecipes); + int aCount2 = aCount1; + RecipeMaps.fluidCannerRecipes.addRecipe(aRecipe); + aCount1 = getMapSize(RecipeMaps.fluidCannerRecipes); + if (aCount1 <= aCount2) { + Logger.INFO( + "[ERROR] Failed adding Canning recipe for " + ItemUtils.getArrayStackNames(aRecipe.mInputs) + + ", " + + ItemUtils.getArrayStackNames(aRecipe.mOutputs) + + ", " + + ItemUtils.getArrayStackNames(aRecipe.mFluidInputs) + + ", " + + ItemUtils.getArrayStackNames(aRecipe.mFluidOutputs)); + dumpStack(); + } + } + + private void dumpStack() { + int parents = 2; + for (int i = 0; i < 6; i++) { + Logger.INFO( + (disableOptional ? "EXTRACTING" : "CANNING") + " DEBUG | " + + (i == 0 ? "Called from: " : "Parent: ") + + ReflectionUtils.getMethodName(i + parents)); + } + } + + private int getMapSize(RecipeMap<?> aMap) { + return aMap.getAllRecipes() + .size(); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Fluids.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Fluids.java new file mode 100644 index 0000000000..dd0c1b505c --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Fluids.java @@ -0,0 +1,212 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeGen_Fluids extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_Fluids(final Material M) { + this(M, false); + } + + public RecipeGen_Fluids(final Material M, final boolean dO) { + this.toGenerate = M; + this.disableOptional = dO; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateRecipes(this.toGenerate, this.disableOptional); + } + + private void generateRecipes(final Material material, final boolean dO) { + + if (material == null) { + return; + } + + // Melting Shapes to fluid + if (material.getFluidStack(1) != null && !material.getFluidStack(1) + .getUnlocalizedName() + .toLowerCase() + .contains("plasma")) { + + // Making Shapes from fluid + + // Ingot + if (ItemUtils.checkForInvalidItems(material.getIngot(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Ingot.get(0), // Item Shape + material.getFluidStack(144), // Fluid Input + material.getIngot(1), // output + 32, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING("144l fluid molder for 1 ingot Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("144l fluid molder for 1 ingot Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Plate + if (ItemUtils.checkForInvalidItems(material.getPlate(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Plate.get(0), // Item Shape + material.getFluidStack(144), // Fluid Input + material.getPlate(1), // output + 32, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING("144l fluid molder for 1 plate Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("144l fluid molder for 1 plate Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Nugget + if (ItemUtils.checkForInvalidItems(material.getNugget(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Nugget.get(0), // Item Shape + material.getFluidStack(16), // Fluid Input + material.getNugget(1), // output + 16, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING("16l fluid molder for 1 nugget Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("16l fluid molder for 1 nugget Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Gears + if (ItemUtils.checkForInvalidItems(material.getGear(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Gear.get(0), // Item Shape + material.getFluidStack(576), // Fluid Input + material.getGear(1), // output + 128, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING("576l fluid molder for 1 gear Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("576l fluid molder for 1 gear Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Blocks + if (ItemUtils.checkForInvalidItems(material.getBlock(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Block.get(0), // Item Shape + material.getFluidStack(144 * 9), // Fluid Input + material.getBlock(1), // output + 288, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 block Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 block Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // GTNH + + // Rod + if (ItemUtils.checkForInvalidItems(material.getRod(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Rod.get(0), // Item Shape + material.getFluidStack(72), // Fluid Input + material.getRod(1), // output + 150, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 rod Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 rod Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Rod Long + if (ItemUtils.checkForInvalidItems(material.getLongRod(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Rod_Long.get(0), // Item + // Shape + material.getFluidStack(144), // Fluid Input + material.getLongRod(1), // output + 300, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 rod long Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 rod long Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Bolt + if (ItemUtils.checkForInvalidItems(material.getBolt(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Bolt.get(0), // Item Shape + material.getFluidStack(18), // Fluid Input + material.getBolt(1), // output + 50, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 bolt Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 bolt Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Screw + if (ItemUtils.checkForInvalidItems(material.getScrew(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Screw.get(0), // Item Shape + material.getFluidStack(18), // Fluid Input + material.getScrew(1), // output + 50, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 screw Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 screw Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Ring + if (ItemUtils.checkForInvalidItems(material.getRing(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Ring.get(0), // Item Shape + material.getFluidStack(36), // Fluid Input + material.getRing(1), // output + 100, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 ring Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 ring Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Rotor + if (ItemUtils.checkForInvalidItems(material.getRotor(1))) if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Rotor.get(0), // Item Shape + material.getFluidStack(612), // Fluid Input + material.getRotor(1), // output + 100, // Duration + material.vVoltageMultiplier // Eu Tick + )) { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 rotor Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING( + (144 * 9) + "l fluid molder from 1 rotor Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Fluorite.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Fluorite.java new file mode 100644 index 0000000000..a3ba819fb6 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Fluorite.java @@ -0,0 +1,267 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_ModHandler; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.material.nuclear.FLUORIDES; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; +import gtPlusPlus.core.util.minecraft.RecipeUtils; + +public class RecipeGen_Fluorite extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_Fluorite(final Material material) { + this.toGenerate = material; + mRecipeGenMap.add(this); + + /** + * Shaped Crafting + */ + RecipeUtils.addShapedRecipe( + CI.craftingToolHammer_Hard, + null, + null, + material.getCrushedPurified(1), + null, + null, + null, + null, + null, + material.getDustPurified(1)); + + RecipeUtils.addShapedRecipe( + CI.craftingToolHammer_Hard, + null, + null, + material.getCrushed(1), + null, + null, + null, + null, + null, + material.getDustImpure(1)); + + RecipeUtils.addShapedRecipe( + CI.craftingToolHammer_Hard, + null, + null, + material.getCrushedCentrifuged(1), + null, + null, + null, + null, + null, + material.getDust(1)); + + final ItemStack normalDust = material.getDust(1); + final ItemStack smallDust = material.getSmallDust(1); + final ItemStack tinyDust = material.getTinyDust(1); + + if (RecipeUtils.addShapedRecipe( + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + normalDust)) { + Logger.WARNING("9 Tiny dust to 1 Dust Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("9 Tiny dust to 1 Dust Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (RecipeUtils + .addShapedRecipe(normalDust, null, null, null, null, null, null, null, null, material.getTinyDust(9))) { + Logger.WARNING("9 Tiny dust from 1 Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("9 Tiny dust from 1 Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (RecipeUtils + .addShapedRecipe(smallDust, smallDust, null, smallDust, smallDust, null, null, null, null, normalDust)) { + Logger.WARNING("4 Small dust to 1 Dust Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("4 Small dust to 1 Dust Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (RecipeUtils + .addShapedRecipe(null, normalDust, null, null, null, null, null, null, null, material.getSmallDust(4))) { + Logger.WARNING("4 Small dust from 1 Dust Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("4 Small dust from 1 Dust Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + @Override + public void run() { + generateRecipes(this.toGenerate); + } + + public static void generateRecipes(final Material material) { + + int tVoltageMultiplier = MaterialUtils.getVoltageForTier(material.vTier); + + final ItemStack dustStone = ItemUtils.getItemStackOfAmountFromOreDict("dustStone", 1); + + ItemStack tinyDustA = FLUORIDES.FLUORITE.getTinyDust(1); + ItemStack tinyDustB = FLUORIDES.FLUORITE.getTinyDust(1); + ItemStack matDust = FLUORIDES.FLUORITE.getDust(1); + ItemStack matDustA = FLUORIDES.FLUORITE.getDust(1); + + /** + * Package + */ + // Allow ore dusts to be packaged + if (ItemUtils.checkForInvalidItems(material.getSmallDust(1)) + && ItemUtils.checkForInvalidItems(material.getTinyDust(1))) { + RecipeGen_DustGeneration.generatePackagerRecipes(material); + } + + /** + * Macerate + */ + // Macerate ore to Crushed + if (GT_Values.RA.addPulveriserRecipe( + material.getOre(1), + new ItemStack[] { material.getCrushed(2) }, + new int[] { 10000 }, + 20 * 20, + tVoltageMultiplier / 2)) { + Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate ore to Crushed ore'"); + } + // Macerate raw ore to Crushed + if (GT_Values.RA.addPulveriserRecipe( + material.getRawOre(1), + new ItemStack[] { material.getCrushed(2) }, + new int[] { 10000 }, + 20 * 20, + tVoltageMultiplier / 2)) { + Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate raw ore to Crushed ore'"); + } + + // Macerate Centrifuged to Pure Dust + if (GT_Values.RA.addPulveriserRecipe( + material.getCrushedCentrifuged(1), + new ItemStack[] { matDust, matDustA }, + new int[] { 10000, 1000 }, + 20 * 20, + tVoltageMultiplier / 2)) { + Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate Centrifuged ore to Pure Dust'"); + } + if (GT_ModHandler.addThermalCentrifugeRecipe( + material.getCrushedPurified(1), + (int) Math.min(5000L, Math.abs(material.getMass() * 20L)), + material.getCrushedCentrifuged(1), + tinyDustA, + dustStone)) { + Logger.MATERIALS( + "[ThermalCentrifuge] Added Recipe: 'Washed ore to Centrifuged Ore' | Input: " + + material.getCrushedPurified(1) + .getDisplayName() + + " | Outputs: " + + material.getCrushedCentrifuged(1) + .getDisplayName() + + ", " + + tinyDustA.getDisplayName() + + ", " + + dustStone.getDisplayName() + + "."); + } + + GT_Values.RA.addChemicalBathRecipe( + FLUORIDES.FLUORITE.getCrushed(2), + FluidUtils.getFluidStack("hydrogen", 2000), + FLUORIDES.FLUORITE.getCrushedPurified(8), + FLUORIDES.FLUORITE.getDustImpure(4), + FLUORIDES.FLUORITE.getDustPurified(2), + new int[] { 10000, 5000, 1000 }, + 30 * 20, + 240); + + /** + * Forge Hammer + */ + if (GT_Values.RA.addForgeHammerRecipe(material.getCrushedCentrifuged(1), matDust, 10, tVoltageMultiplier / 4)) { + Logger.MATERIALS("[ForgeHammer] Added Recipe: 'Crushed Centrifuged to Pure Dust'"); + } + + /** + * Centrifuge + */ + // Purified Dust to Clean + if (GT_Values.RA.addCentrifugeRecipe( + material.getDustPurified(1), + null, + null, // In Fluid + null, // Out Fluid + matDust, + tinyDustA, + null, + null, + null, + null, + new int[] { 10000, 10000 }, // Chances + (int) Math.max(1L, material.getMass() * 8L), // Time + tVoltageMultiplier / 2)) { // Eu + Logger.MATERIALS("[Centrifuge] Added Recipe: Purified Dust to Clean Dust"); + } + + // Impure Dust to Clean + if (GT_Values.RA.addCentrifugeRecipe( + material.getDustImpure(1), + null, + null, // In Fluid + null, // Out Fluid + matDust, + tinyDustB, + null, + null, + null, + null, + new int[] { 10000, 10000 }, // Chances + (int) Math.max(1L, material.getMass() * 8L), // Time + tVoltageMultiplier / 2)) { // Eu + Logger.MATERIALS("[Centrifuge] Added Recipe: Inpure Dust to Clean Dust"); + } + + // 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), FLUORIDES.FLUORITE.getDust(37), }, + FluidUtils.getFluidStack("sulfuricacid", 8000), + aGregtechHydro, // Fluid output (slot 2) + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumSulfate", 15), + ItemUtils.getItemStackOfAmountFromOreDict("dustSilver", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustGold", 2), + ItemUtils.getItemStackOfAmountFromOreDict("dustTin", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustCopper", 2) }, + new int[] { 10000, 1000, 1000, 3000, 2000 }, + 10 * 60 * 20, + 240); // EU + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MaterialProcessing.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MaterialProcessing.java new file mode 100644 index 0000000000..83bbe6a6d7 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MaterialProcessing.java @@ -0,0 +1,318 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.api.objects.data.Pair; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.material.MaterialStack; +import gtPlusPlus.core.material.state.MaterialState; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeGen_MaterialProcessing extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_MaterialProcessing(final Material M) { + this(M, false); + } + + public RecipeGen_MaterialProcessing(final Material M, final boolean O) { + this.toGenerate = M; + this.disableOptional = O; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateRecipes(this.toGenerate, this.disableOptional); + } + + private void generateRecipes(final Material material, final boolean disableOptional) { + if (disableOptional) { + return; + } + + if (material.getMaterialComposites().length > 1) { + Logger.MATERIALS("[Recipe Generator Debug] [" + material.getLocalizedName() + "]"); + final int tVoltageMultiplier = material.vVoltageMultiplier; + int[] partSizes = new int[99]; + if (material.vSmallestRatio != null) { + partSizes = new int[material.vSmallestRatio.length]; + for (int hu = 0; hu < material.vSmallestRatio.length; hu++) { + partSizes[hu] = (int) material.vSmallestRatio[hu]; + } + } + AutoMap<Pair<Integer, Material>> componentMap = new AutoMap<>(); + int alnsnfds = 0; + for (MaterialStack r : material.getComposites()) { + if (r != null) { + componentMap.put(new Pair<>(partSizes[alnsnfds], r.getStackMaterial())); + } + alnsnfds++; + } + + /** + * Centrifuge + */ + + // Process Dust + if (componentMap.size() > 0 && componentMap.size() <= 6) { + ItemStack mInternalOutputs[] = new ItemStack[6]; + int mChances[] = new int[6]; + int mCellCount = 0; + + int mTotalCount = 0; + + int mCounter = 0; + for (Pair<Integer, Material> f : componentMap) { + if (f.getValue() + .getState() != MaterialState.SOLID) { + Logger.MATERIALS( + "[Centrifuge] Found Fluid Component, adding " + f.getKey() + + " cells of " + + f.getValue() + .getLocalizedName() + + "."); + mInternalOutputs[mCounter++] = f.getValue() + .getCell(f.getKey()); + mCellCount += f.getKey(); + mTotalCount += f.getKey(); + Logger.MATERIALS( + "[Centrifuge] In total, adding " + mCellCount + + " cells for " + + material.getLocalizedName() + + " processing."); + } else { + Logger.MATERIALS( + "[Centrifuge] Found Solid Component, adding " + f.getKey() + + " dusts of " + + f.getValue() + .getLocalizedName() + + "."); + mInternalOutputs[mCounter++] = f.getValue() + .getDust(f.getKey()); + mTotalCount += f.getKey(); + } + } + + // Build Output Array + for (int g = 0; g < mInternalOutputs.length; g++) { + Logger.MATERIALS( + "[Centrifuge] Is output[" + g + + "] valid with a chance? " + + (mInternalOutputs[g] != null ? 10000 : 0)); + mChances[g] = (mInternalOutputs[g] != null ? 10000 : 0); + } + + ItemStack emptyCell = null; + if (mCellCount > 0) { + emptyCell = ItemUtils.getItemStackOfAmountFromOreDict("cellEmpty", mCellCount); + Logger.MATERIALS("[Centrifuge] Recipe now requires " + mCellCount + " empty cells as input."); + } + + ItemStack mainDust = material.getDust(material.smallestStackSizeWhenProcessing); + if (mainDust != null) { + Logger.MATERIALS( + "[Centrifuge] Recipe now requires " + material.smallestStackSizeWhenProcessing + + "x " + + mainDust.getDisplayName() + + " as input."); + } else { + mainDust = material.getDust(mTotalCount); + Logger.MATERIALS("[Centrifuge] Could not find valid input dust, trying alternative."); + if (mainDust != null) { + Logger.MATERIALS( + "[Centrifuge] Recipe now requires " + mTotalCount + + "x " + + mainDust.getDisplayName() + + " as input."); + } else { + Logger.MATERIALS("[Centrifuge] Could not find valid input dust, exiting."); + } + } + + for (int j = 0; j < mInternalOutputs.length; j++) { + if (mInternalOutputs[j] == null) { + mInternalOutputs[j] = GT_Values.NI; + Logger.MATERIALS("[Centrifuge] Set slot " + j + " to null."); + } else { + Logger.MATERIALS( + "[Centrifuge] Set slot " + j + " to " + mInternalOutputs[j].getDisplayName() + "."); + } + } + + try { + if (addCentrifgeRecipe( + mainDust, + emptyCell, // input 2 + null, // Input fluid 1 + null, // Output fluid 1 + mInternalOutputs[0], + mInternalOutputs[1], + mInternalOutputs[2], + mInternalOutputs[3], + mInternalOutputs[4], + mInternalOutputs[5], + mChances, + 20 * 1 * (tVoltageMultiplier / 10), + tVoltageMultiplier)) { + Logger.MATERIALS( + "[Centrifuge] Generated Centrifuge recipe for " + material.getDust(1) + .getDisplayName()); + } else { + Logger.MATERIALS( + "[Centrifuge] Failed to generate Centrifuge recipe for " + material.getDust(1) + .getDisplayName()); + } + } catch (Throwable t) { + t.printStackTrace(); + } + } else if (componentMap.size() > 6 && componentMap.size() <= 9) { + Logger.MATERIALS( + "[Issue][Electrolyzer] " + material.getLocalizedName() + + " is composed of over 6 materials, so an electrolyzer recipe for processing cannot be generated. Trying to create one for the Dehydrator instead."); + + ItemStack mInternalOutputs[] = new ItemStack[9]; + int mChances[] = new int[9]; + int mCellCount = 0; + + int mTotalCount = 0; + + int mCounter = 0; + for (Pair<Integer, Material> f : componentMap) { + if (f.getValue() + .getState() != MaterialState.SOLID) { + Logger.MATERIALS( + "[Dehydrator] Found Fluid Component, adding " + f.getKey() + + " cells of " + + f.getValue() + .getLocalizedName() + + "."); + mInternalOutputs[mCounter++] = f.getValue() + .getCell(f.getKey()); + mCellCount += f.getKey(); + mTotalCount += f.getKey(); + Logger.MATERIALS( + "[Dehydrator] In total, adding " + mCellCount + + " cells for " + + material.getLocalizedName() + + " processing."); + } else { + Logger.MATERIALS( + "[Dehydrator] Found Solid Component, adding " + f.getKey() + + " dusts of " + + f.getValue() + .getLocalizedName() + + "."); + mInternalOutputs[mCounter++] = f.getValue() + .getDust(f.getKey()); + mTotalCount += f.getKey(); + } + } + + // Build Output Array + for (int g = 0; g < mInternalOutputs.length; g++) { + Logger.MATERIALS( + "[Dehydrator] Is output[" + g + + "] valid with a chance? " + + (mInternalOutputs[g] != null ? 10000 : 0)); + mChances[g] = (mInternalOutputs[g] != null ? 10000 : 0); + } + + ItemStack emptyCell = null; + if (mCellCount > 0) { + emptyCell = CI.emptyCells(mCellCount); + Logger.MATERIALS("[Dehydrator] Recipe now requires " + mCellCount + " empty cells as input."); + } + + ItemStack mainDust = material.getDust(material.smallestStackSizeWhenProcessing); + if (mainDust != null) { + Logger.MATERIALS( + "[Dehydrator] Recipe now requires " + material.smallestStackSizeWhenProcessing + + "x " + + mainDust.getDisplayName() + + " as input."); + } else { + mainDust = material.getDust(mTotalCount); + Logger.MATERIALS("[Dehydrator] Could not find valid input dust, trying alternative."); + if (mainDust != null) { + Logger.MATERIALS( + "[Dehydrator] Recipe now requires " + mTotalCount + + "x " + + mainDust.getDisplayName() + + " as input."); + } else { + Logger.MATERIALS("[Dehydrator] Could not find valid input dust, exiting."); + } + } + + for (int j = 0; j < mInternalOutputs.length; j++) { + if (mInternalOutputs[j] == null) { + mInternalOutputs[j] = GT_Values.NI; + Logger.MATERIALS("[Dehydrator] Set slot " + j + " to null."); + } else { + Logger.MATERIALS( + "[Dehydrator] Set slot " + j + " to " + mInternalOutputs[j].getDisplayName() + "."); + } + } + + try { + + if (CORE.RA.addDehydratorRecipe( + new ItemStack[] { mainDust, emptyCell }, + null, + null, + mInternalOutputs, + mChances, + 20 * 1 * (tVoltageMultiplier / 10), + tVoltageMultiplier)) { + Logger.MATERIALS( + "[Dehydrator] Generated Dehydrator recipe for " + material.getDust(1) + .getDisplayName()); + } else { + Logger.MATERIALS( + "[Dehydrator] Failed to generate Dehydrator recipe for " + material.getDust(1) + .getDisplayName()); + } + } catch (Throwable t) { + t.printStackTrace(); + } + } + } + } + + @Deprecated + public static boolean addCentrifgeRecipe(ItemStack aInput1, ItemStack aInput2, FluidStack aFluidInput, + FluidStack aFluidOutput, ItemStack aOutput1, ItemStack aOutput2, ItemStack aOutput3, ItemStack aOutput4, + ItemStack aOutput5, ItemStack aOutput6, int[] aChances, int aDuration, int aEUt) { + return GT_Values.RA.addCentrifugeRecipe( + aInput1, + aInput2, + aFluidInput, + aFluidOutput, + aOutput1, + aOutput2, + aOutput3, + aOutput4, + aOutput5, + aOutput6, + aChances, + aDuration, + aEUt); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MetalRecipe.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MetalRecipe.java new file mode 100644 index 0000000000..f11b97cbda --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MetalRecipe.java @@ -0,0 +1,112 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_ModHandler; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeGen_MetalRecipe extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_MetalRecipe(final Material M) { + this.toGenerate = M; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateRecipes(this.toGenerate); + } + + private void generateRecipes(final Material material) { + + Logger.WARNING("Generating Metal recipes for " + material.getLocalizedName()); + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) + && ItemUtils.checkForInvalidItems(material.getBlock(1))) + if (GT_ModHandler.addCompressionRecipe(material.getIngot(9), material.getBlock(1))) { + Logger.WARNING("Compress Block Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Compress Block Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getRod(1))) + if (GT_Values.RA.addLatheRecipe( + material.getIngot(1), + material.getRod(1), + material.getSmallDust(2), + (int) Math.max(material.getMass() / 8L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Lathe Rod Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Lathe Rod Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (ItemUtils.checkForInvalidItems(material.getRod(1)) && ItemUtils.checkForInvalidItems(material.getBolt(1))) + if (GT_Values.RA.addCutterRecipe( + material.getRod(1), + material.getBolt(4), + null, + (int) Math.max(material.getMass() * 2L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Cut Bolt Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Cut Bolt Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (ItemUtils.checkForInvalidItems(material.getIngot(1)) + && ItemUtils.checkForInvalidItems(material.getHotIngot(1))) + if (CORE.RA.addVacuumFreezerRecipe( + material.getHotIngot(1), + material.getIngot(1), + (int) Math.max(material.getMass() * 3L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Cool Hot Ingot Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Cool Hot Ingot Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (ItemUtils.checkForInvalidItems(material.getRod(1)) + && ItemUtils.checkForInvalidItems(material.getLongRod(1))) { + if (GT_Values.RA.addForgeHammerRecipe( + material.getRod(2), + material.getLongRod(1), + (int) Math.max(material.getMass(), 1L), + 16)) { + Logger.WARNING("Hammer Long Rod Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Hammer Long Rod Recipe: " + material.getLocalizedName() + " - Failed"); + } + + GT_Values.RA.addCutterRecipe( + material.getLongRod(1), + material.getRod(2), + null, + (int) Math.max(material.getMass(), 1L), + 4); + } + + if (ItemUtils.checkForInvalidItems(material.getBolt(1)) && ItemUtils.checkForInvalidItems(material.getScrew(1))) + if (GT_Values.RA.addLatheRecipe( + material.getBolt(1), + material.getScrew(1), + null, + (int) Math.max(material.getMass() / 8L, 1L), + 4)) { + Logger.WARNING("Lathe Screw Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Lathe Screw Recipe: " + material.getLocalizedName() + " - Failed"); + } + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MultisUsingFluidInsteadOfCells.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MultisUsingFluidInsteadOfCells.java new file mode 100644 index 0000000000..208be14c8c --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MultisUsingFluidInsteadOfCells.java @@ -0,0 +1,187 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.recipe.RecipeMap; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.recipe.GT_RecipeUtils; + +public class RecipeGen_MultisUsingFluidInsteadOfCells { + + private static ItemStack mEmptyCell; + private static final AutoMap<ItemStack> mItemsToIgnore = new AutoMap<>(); + private static boolean mInit = false; + + private static void init() { + if (!mInit) { + mInit = true; + mItemsToIgnore.add( + ItemUtils.simpleMetaStack( + CI.emptyCells(1) + .getItem(), + 8, + 1)); + } + } + + private static boolean doesItemMatchIgnoringStackSize(ItemStack a, ItemStack b) { + if (a == null || b == null) { + return false; + } + if (a.getItem() == b.getItem()) { + return a.getItemDamage() == b.getItemDamage(); + } + return false; + } + + private static boolean isEmptyCell(ItemStack aCell) { + if (aCell == null) { + return false; + } + if (mEmptyCell == null) { + mEmptyCell = CI.emptyCells(1); + } + if (mEmptyCell != null) { + ItemStack aTempStack = mEmptyCell.copy(); + aTempStack.stackSize = aCell.stackSize; + return GT_Utility.areStacksEqual(aTempStack, aCell); + } + return false; + } + + private static synchronized FluidStack getFluidFromItemStack(final ItemStack ingot) { + if (ingot == null) { + return null; + } + return GT_Utility.getFluidForFilledItem(ingot, true); + } + + public static synchronized int generateRecipesNotUsingCells(RecipeMap<?> aInputs, RecipeMap<?> aOutputs) { + init(); + int aRecipesHandled = 0; + int aInvalidRecipesToConvert = 0; + int aOriginalCount = aInputs.getAllRecipes() + .size(); + ArrayList<GT_Recipe> deDuplicationInputArray = new ArrayList<>(); + + recipe: for (GT_Recipe x : aInputs.getAllRecipes()) { + if (x != null) { + + ItemStack[] aInputItems = x.mInputs.clone(); + ItemStack[] aOutputItems = x.mOutputs.clone(); + FluidStack[] aInputFluids = x.mFluidInputs.clone(); + FluidStack[] aOutputFluids = x.mFluidOutputs.clone(); + + AutoMap<ItemStack> aInputItemsMap = new AutoMap<>(); + AutoMap<ItemStack> aOutputItemsMap = new AutoMap<>(); + AutoMap<FluidStack> aInputFluidsMap = new AutoMap<>(); + AutoMap<FluidStack> aOutputFluidsMap = new AutoMap<>(); + + // Iterate Inputs, Convert valid items into fluids + for (ItemStack aInputStack : aInputItems) { + FluidStack aFoundFluid = getFluidFromItemStack(aInputStack); + if (aFoundFluid == null) { + for (ItemStack aBadStack : mItemsToIgnore) { + if (doesItemMatchIgnoringStackSize(aInputStack, aBadStack)) { + continue recipe; // Skip this recipe entirely if we find an item we don't like + } + } + if (!isEmptyCell(aInputStack)) { + aInputItemsMap.add(aInputStack); + } + } else { + aFoundFluid.amount = aFoundFluid.amount * aInputStack.stackSize; + aInputFluidsMap.add(aFoundFluid); + } + } + // Iterate Outputs, Convert valid items into fluids + for (ItemStack aOutputStack : aOutputItems) { + FluidStack aFoundFluid = getFluidFromItemStack(aOutputStack); + if (aFoundFluid == null) { + for (ItemStack aBadStack : mItemsToIgnore) { + if (doesItemMatchIgnoringStackSize(aOutputStack, aBadStack)) { + continue recipe; // Skip this recipe entirely if we find an item we don't like + } + } + if (!isEmptyCell(aOutputStack)) { + aOutputItemsMap.add(aOutputStack); + } + } else { + aFoundFluid.amount = aFoundFluid.amount * aOutputStack.stackSize; + aOutputFluidsMap.add(aFoundFluid); + } + } + // Add Input fluids second + aInputFluidsMap.addAll(Arrays.asList(aInputFluids)); + // Add Output fluids second + aOutputFluidsMap.addAll(Arrays.asList(aOutputFluids)); + + // Make some new Arrays + ItemStack[] aNewItemInputs = new ItemStack[aInputItemsMap.size()]; + ItemStack[] aNewItemOutputs = new ItemStack[aOutputItemsMap.size()]; + FluidStack[] aNewFluidInputs = new FluidStack[aInputFluidsMap.size()]; + FluidStack[] aNewFluidOutputs = new FluidStack[aOutputFluidsMap.size()]; + + // Add AutoMap contents to Arrays + for (int i = 0; i < aInputItemsMap.size(); i++) { + aNewItemInputs[i] = aInputItemsMap.get(i); + } + for (int i = 0; i < aOutputItemsMap.size(); i++) { + aNewItemOutputs[i] = aOutputItemsMap.get(i); + } + for (int i = 0; i < aInputFluidsMap.size(); i++) { + aNewFluidInputs[i] = aInputFluidsMap.get(i); + } + for (int i = 0; i < aOutputFluidsMap.size(); i++) { + aNewFluidOutputs[i] = aOutputFluidsMap.get(i); + } + + if (!ItemUtils.checkForInvalidItems(aNewItemInputs, aNewItemOutputs)) { + aInvalidRecipesToConvert++; + continue; // Skip this recipe entirely if we find an item we don't like + } + GT_Recipe aNewRecipe = new GT_Recipe( + false, + aNewItemInputs, + aNewItemOutputs, + x.mSpecialItems, + x.mChances, + aNewFluidInputs, + aNewFluidOutputs, + x.mDuration, + x.mEUt, + x.mSpecialValue); + aNewRecipe.owners = new ArrayList<>(x.owners); + + // add all recipes to an intermediate array + deDuplicationInputArray.add(aNewRecipe); + + aRecipesHandled++; + } else { + aInvalidRecipesToConvert++; + } + } + // cast arraylist of input to a regular array and pass it to a duplicate recipe remover. + List<GT_Recipe> deDuplicationOutputArray = GT_RecipeUtils + .removeDuplicates(deDuplicationInputArray, aOutputs.unlocalizedName); + // add each recipe from the above output to the intended recipe map + for (GT_Recipe recipe : deDuplicationOutputArray) { + aOutputs.add(recipe); + } + Logger.INFO("Generated Recipes for " + aOutputs.unlocalizedName); + Logger.INFO("Original Map contains " + aOriginalCount + " recipes."); + Logger.INFO("Output Map contains " + aRecipesHandled + " recipes."); + Logger.INFO("There were " + aInvalidRecipesToConvert + " invalid recipes."); + return aRecipesHandled; + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Ore.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Ore.java new file mode 100644 index 0000000000..32d6a1066b --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Ore.java @@ -0,0 +1,750 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.util.GT_ModHandler; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.api.objects.data.Pair; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.material.MaterialStack; +import gtPlusPlus.core.material.state.MaterialState; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; +import gtPlusPlus.core.util.minecraft.RecipeUtils; + +public class RecipeGen_Ore extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_Ore(final Material M) { + this(M, false); + } + + public RecipeGen_Ore(final Material M, final boolean O) { + this.toGenerate = M; + this.disableOptional = O; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateRecipes(this.toGenerate, this.disableOptional); + } + + private static Material mStone; + + private void generateRecipes(final Material material, final boolean disableOptional) { + + if (mStone == null) { + mStone = MaterialUtils.generateMaterialFromGtENUM(Materials.Stone); + } + + // if (material.getMaterialComposites().length > 1){ + Logger.MATERIALS("[Recipe Generator Debug] [" + material.getLocalizedName() + "]"); + int tVoltageMultiplier = MaterialUtils.getVoltageForTier(material.vTier); + + final ItemStack dustStone = ItemUtils.getItemStackOfAmountFromOreDict("dustStone", 1); + Material bonusA = null; // Ni + Material bonusB = null; // Tin + + if (material.getComposites() + .size() >= 1 + && material.getComposites() + .get(0) != null) { + bonusA = material.getComposites() + .get(0) + .getStackMaterial(); + } else { + bonusA = material; + } + + boolean allFailed = false; + + // Setup Bonuses + ArrayList<Material> aMatComp = new ArrayList<>(); + for (Material j : MaterialUtils.getCompoundMaterialsRecursively(material)) { + aMatComp.add(j); + } + + if (aMatComp.size() < 3) { + while (aMatComp.size() < 3) { + aMatComp.add(material); + } + } + + AutoMap<Material> amJ = new AutoMap<>(); + int aIndexCounter = 0; + for (Material g : aMatComp) { + if (g.hasSolidForm()) { + if (getDust(g) != null && getTinyDust(g) != null) { + amJ.put(g); + } + } + } + + if (amJ.size() < 2) { + if (material.getComposites() + .size() >= 2 + && material.getComposites() + .get(1) != null) { + bonusB = material.getComposites() + .get(1) + .getStackMaterial(); + // If Secondary Output has no solid output, try the third (If it exists) + if (!bonusB.hasSolidForm() && material.getComposites() + .size() >= 3 + && material.getComposites() + .get(2) != null) { + bonusB = material.getComposites() + .get(2) + .getStackMaterial(); + // If Third Output has no solid output, try the Fourth (If it exists) + if (!bonusB.hasSolidForm() && material.getComposites() + .size() >= 4 + && material.getComposites() + .get(3) != null) { + bonusB = material.getComposites() + .get(3) + .getStackMaterial(); + // If Fourth Output has no solid output, try the Fifth (If it exists) + if (!bonusB.hasSolidForm() && material.getComposites() + .size() >= 5 + && material.getComposites() + .get(4) != null) { + bonusB = material.getComposites() + .get(4) + .getStackMaterial(); + // If Fifth Output has no solid output, default out to Stone dust. + if (!bonusB.hasSolidForm()) { + allFailed = true; + bonusB = mStone; + } + } + } + } + } else { + allFailed = true; + } + } else { + bonusA = amJ.get(0); + bonusB = amJ.get(1); + } + + // Default out if it's made of fluids or some stuff. + if (bonusA == null) { + bonusA = tVoltageMultiplier > 100 ? material : mStone; + } + // Default out if it's made of fluids or some stuff. + if (allFailed || bonusB == null) { + bonusB = tVoltageMultiplier > 100 ? material : mStone; + } + + AutoMap<Pair<Integer, Material>> componentMap = new AutoMap<>(); + for (MaterialStack r : material.getComposites()) { + if (r != null) { + componentMap.put(new Pair<>(r.getPartsPerOneHundred(), r.getStackMaterial())); + } + } + + // Need two valid outputs + if (bonusA == null || bonusB == null || !bonusA.hasSolidForm() || !bonusB.hasSolidForm()) { + if (bonusA == null) { + bonusA = mStone; + } + if (bonusB == null) { + bonusB = mStone; + } + if (!bonusA.hasSolidForm()) { + bonusA = mStone; + } + if (!bonusB.hasSolidForm()) { + bonusB = mStone; + } + } + + ItemStack matDust = getDust(material); + ItemStack matDustA = getDust(bonusA); + ItemStack matDustB = getDust(bonusB); + + /** + * Package + */ + // Allow ore dusts to be packaged + if (ItemUtils.checkForInvalidItems(material.getSmallDust(1)) + && ItemUtils.checkForInvalidItems(material.getTinyDust(1))) { + RecipeGen_DustGeneration.generatePackagerRecipes(material); + } + + /** + * Macerate + */ + // Macerate ore to Crushed + if (GT_Values.RA.addPulveriserRecipe( + material.getOre(1), + new ItemStack[] { material.getCrushed(2) }, + new int[] { 10000 }, + 20 * 20, + tVoltageMultiplier / 2)) { + Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate ore to Crushed ore'"); + } + // Macerate raw ore to Crushed + if (GT_Values.RA.addPulveriserRecipe( + material.getRawOre(1), + new ItemStack[] { material.getCrushed(2) }, + new int[] { 10000 }, + 20 * 20, + tVoltageMultiplier / 2)) { + Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate raw ore to Crushed ore'"); + } + // Macerate Crushed to Impure Dust + if (GT_Values.RA.addPulveriserRecipe( + material.getCrushed(1), + new ItemStack[] { material.getDustImpure(1), matDustA }, + new int[] { 10000, 1000 }, + 20 * 20, + tVoltageMultiplier / 2)) { + Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate Crushed ore to Impure Dust'"); + } + // Macerate Washed to Purified Dust + if (GT_Values.RA.addPulveriserRecipe( + material.getCrushedPurified(1), + new ItemStack[] { material.getDustPurified(1), matDustA }, + new int[] { 10000, 1000 }, + 20 * 20, + tVoltageMultiplier / 2)) { + Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate Washed ore to Purified Dust'"); + } + // Macerate Centrifuged to Pure Dust + if (GT_Values.RA.addPulveriserRecipe( + material.getCrushedCentrifuged(1), + new ItemStack[] { matDust, matDustA }, + new int[] { 10000, 1000 }, + 20 * 20, + tVoltageMultiplier / 2)) { + Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate Centrifuged ore to Pure Dust'"); + } + + /** + * Wash + */ + // Wash into Purified Crushed + /* + * if (GT_Values.RA.addOreWasherRecipe(material.getCrushed(1), material.getCrushedPurified(1), + * bonusA.getTinyDust(1), dustStone, FluidUtils.getWater(1000), 25*20, 16)){ + * Logger.MATERIALS("[OreWasher] Added Recipe: 'Wash Crushed ore into Purified Crushed ore'"); } + */ + // .08 compat method + if (GT_ModHandler.addOreWasherRecipe( + material.getCrushed(1), + new int[] { 10000, 1111, 10000 }, + 1000, + material.getCrushedPurified(1), + matDustA, + dustStone)) { + Logger.MATERIALS("[OreWasher] Added Recipe: 'Wash Crushed ore into Purified Crushed ore'"); + } + + /** + * Thermal Centrifuge + */ + /* + * //Crushed ore to Centrifuged Ore if (GT_Values.RA.addThermalCentrifugeRecipe(material.getCrushed(1), + * material.getCrushedCentrifuged(1), tinyDustB, dustStone, 25*20, 24)){ + * Logger.MATERIALS("[ThermalCentrifuge] Added Recipe: 'Crushed ore to Centrifuged Ore'"); } //Washed ore to + * Centrifuged Ore if (GT_Values.RA.addThermalCentrifugeRecipe(material.getCrushedPurified(1), + * material.getCrushedCentrifuged(1), bonusA.getTinyDust(1), dustStone, 25*20, 24)){ + * Logger.MATERIALS("[ThermalCentrifuge] Added Recipe: 'Washed ore to Centrifuged Ore'"); } + */ + + Logger.MATERIALS("material.getCrushed(1): " + (material.getCrushed(1) != null)); + Logger.MATERIALS("material.getCrushedPurified(1): " + (material.getCrushedPurified(1) != null)); + + Logger.MATERIALS("material.getTinyDust(1): " + (ItemUtils.getItemName(bonusA.getCrushed(1)))); + Logger.MATERIALS("material.getTinyDust(1): " + (ItemUtils.getItemName(bonusB.getCrushed(1)))); + + try { + // .08 compat + if (GT_ModHandler.addThermalCentrifugeRecipe( + material.getCrushed(1), + new int[] { 10000, 1111, 10000 }, + (int) Math.min(5000L, Math.abs(material.getMass() * 20L)), + material.getCrushedCentrifuged(1), + matDustB, + dustStone)) { + Logger.MATERIALS( + "[ThermalCentrifuge] Added Recipe: 'Crushed ore to Centrifuged Ore' | Input: " + + material.getCrushed(1) + .getDisplayName() + + " | Outputs: " + + material.getCrushedCentrifuged(1) + .getDisplayName() + + ", " + + matDustB.getDisplayName() + + ", " + + dustStone.getDisplayName() + + "."); + } + } catch (Throwable t) {} + try { + if (GT_ModHandler.addThermalCentrifugeRecipe( + material.getCrushedPurified(1), + new int[] { 10000, 1111, 10000 }, + (int) Math.min(5000L, Math.abs(material.getMass() * 20L)), + material.getCrushedCentrifuged(1), + matDustA, + dustStone)) { + Logger.MATERIALS( + "[ThermalCentrifuge] Added Recipe: 'Washed ore to Centrifuged Ore' | Input: " + + material.getCrushedPurified(1) + .getDisplayName() + + " | Outputs: " + + material.getCrushedCentrifuged(1) + .getDisplayName() + + ", " + + matDustA.getDisplayName() + + ", " + + dustStone.getDisplayName() + + "."); + } + } catch (Throwable t) {} + + /** + * Forge Hammer + */ + if (GT_Values.RA.addForgeHammerRecipe(material.getCrushedCentrifuged(1), matDust, 10, tVoltageMultiplier / 4)) { + Logger.MATERIALS("[ForgeHammer] Added Recipe: 'Crushed Centrifuged to Pure Dust'"); + } + if (GT_Values.RA.addForgeHammerRecipe( + material.getCrushedPurified(1), + material.getDustPurified(1), + 10, + tVoltageMultiplier / 4)) { + Logger.MATERIALS("[ForgeHammer] Added Recipe: 'Crushed Purified to Purified Dust'"); + } + if (GT_Values.RA.addForgeHammerRecipe(material.getOre(1), material.getCrushed(1), 10, tVoltageMultiplier / 4)) { + Logger.MATERIALS("[ForgeHammer] Added Recipe: 'Ore to Crushed'"); + } + + /** + * Centrifuge + */ + // Purified Dust to Clean + if (GT_Values.RA.addCentrifugeRecipe( + material.getDustPurified(1), + null, + null, // In Fluid + null, // Out Fluid + matDust, + matDustA, + null, + null, + null, + null, + new int[] { 10000, 1111 }, // Chances + (int) Math.max(1L, material.getMass() * 8L), // Time + tVoltageMultiplier / 2)) { // Eu + Logger.MATERIALS("[Centrifuge] Added Recipe: Purified Dust to Clean Dust"); + } + + // Impure Dust to Clean + if (GT_Values.RA.addCentrifugeRecipe( + material.getDustImpure(1), + null, + null, // In Fluid + null, // Out Fluid + matDust, + matDustB, + null, + null, + null, + null, + new int[] { 10000, 1111 }, // Chances + (int) Math.max(1L, material.getMass() * 8L), // Time + tVoltageMultiplier / 2)) { // Eu + Logger.MATERIALS("[Centrifuge] Added Recipe: Inpure Dust to Clean Dust"); + } + + /** + * Electrolyzer + */ + if (!disableOptional) { + // Process Dust + if (componentMap.size() > 0 && componentMap.size() <= 6) { + + ItemStack mInternalOutputs[] = new ItemStack[6]; + int mChances[] = new int[6]; + int mCellCount = 0; + + int mTotalCount = 0; + + int mCounter = 0; + for (Pair<Integer, Material> f : componentMap) { + if (f.getValue() + .getState() != MaterialState.SOLID) { + Logger.MATERIALS( + "[Electrolyzer] Found Fluid Component, adding " + f.getKey() + + " cells of " + + f.getValue() + .getLocalizedName() + + "."); + mInternalOutputs[mCounter++] = f.getValue() + .getCell(f.getKey()); + mCellCount += f.getKey(); + mTotalCount += f.getKey(); + Logger.MATERIALS( + "[Electrolyzer] In total, adding " + mCellCount + + " cells for " + + material.getLocalizedName() + + " processing."); + } else { + Logger.MATERIALS( + "[Electrolyzer] Found Solid Component, adding " + f.getKey() + + " dusts of " + + f.getValue() + .getLocalizedName() + + "."); + mInternalOutputs[mCounter++] = f.getValue() + .getDust(f.getKey()); + mTotalCount += f.getKey(); + } + } + + // Build Output Array + for (int g = 0; g < mInternalOutputs.length; g++) { + Logger.MATERIALS( + "[Electrolyzer] Is output[" + g + + "] valid with a chance? " + + (mInternalOutputs[g] != null ? 10000 : 0)); + mChances[g] = (mInternalOutputs[g] != null ? 10000 : 0); + } + + ItemStack emptyCell = null; + if (mCellCount > 0) { + emptyCell = ItemUtils.getItemStackOfAmountFromOreDict("cellEmpty", mCellCount); + Logger.MATERIALS("[Electrolyzer] Recipe now requires " + mCellCount + " empty cells as input."); + } + + ItemStack mainDust = material.getDust(material.smallestStackSizeWhenProcessing); + if (mainDust != null) { + Logger.MATERIALS( + "[Electrolyzer] Recipe now requires " + material.smallestStackSizeWhenProcessing + + "x " + + mainDust.getDisplayName() + + " as input."); + } else { + mainDust = material.getDust(mTotalCount); + Logger.MATERIALS("[Electrolyzer] Could not find valid input dust, trying alternative."); + if (mainDust != null) { + Logger.MATERIALS( + "[Electrolyzer] Recipe now requires " + mTotalCount + + "x " + + mainDust.getDisplayName() + + " as input."); + } else { + Logger.MATERIALS("[Electrolyzer] Could not find valid input dust, exiting."); + } + } + + for (int j = 0; j < mInternalOutputs.length; j++) { + if (mInternalOutputs[j] == null) { + mInternalOutputs[j] = GT_Values.NI; + Logger.MATERIALS("[Electrolyzer] Set slot " + j + " to null."); + } else { + Logger.MATERIALS( + "[Electrolyzer] Set slot " + j + " to " + mInternalOutputs[j].getDisplayName() + "."); + } + } + + try { + if (addElectrolyzerRecipe( + mainDust, + emptyCell, // input 2 + null, // Input fluid 1 + null, // Output fluid 1 + mInternalOutputs[0], + mInternalOutputs[1], + mInternalOutputs[2], + mInternalOutputs[3], + mInternalOutputs[4], + mInternalOutputs[5], + mChances, + (int) Math.max(material.getMass() * 3L * 1, 1), + tVoltageMultiplier)) { + Logger + .MATERIALS("[Electrolyzer] Generated Electrolyzer recipe for " + matDust.getDisplayName()); + } else { + Logger.MATERIALS( + "[Electrolyzer] Failed to generate Electrolyzer recipe for " + matDust.getDisplayName()); + } + } catch (Throwable t) { + t.printStackTrace(); + } + } else if (componentMap.size() > 6 && componentMap.size() <= 9) { + Logger.MATERIALS( + "[Issue][Electrolyzer] " + material.getLocalizedName() + + " is composed of over 6 materials, so an electrolyzer recipe for processing cannot be generated. Trying to create one for the Dehydrator instead."); + + ItemStack mInternalOutputs[] = new ItemStack[9]; + int mChances[] = new int[9]; + int mCellCount = 0; + + int mTotalCount = 0; + + int mCounter = 0; + for (Pair<Integer, Material> f : componentMap) { + if (f.getValue() + .getState() != MaterialState.SOLID + && f.getValue() + .getState() != MaterialState.ORE) { + Logger.MATERIALS( + "[Dehydrator] Found Fluid Component, adding " + f.getKey() + + " cells of " + + f.getValue() + .getLocalizedName() + + "."); + mInternalOutputs[mCounter++] = f.getValue() + .getCell(f.getKey()); + mCellCount += f.getKey(); + mTotalCount += f.getKey(); + Logger.MATERIALS( + "[Dehydrator] In total, adding " + mCellCount + + " cells for " + + material.getLocalizedName() + + " processing."); + } else { + Logger.MATERIALS( + "[Dehydrator] Found Solid Component, adding " + f.getKey() + + " dusts of " + + f.getValue() + .getLocalizedName() + + "."); + mInternalOutputs[mCounter++] = f.getValue() + .getDust(f.getKey()); + mTotalCount += f.getKey(); + } + } + + // Build Output Array + for (int g = 0; g < mInternalOutputs.length; g++) { + Logger.MATERIALS( + "[Dehydrator] Is output[" + g + + "] valid with a chance? " + + (mInternalOutputs[g] != null ? 10000 : 0)); + mChances[g] = (mInternalOutputs[g] != null ? 10000 : 0); + } + + ItemStack emptyCell = null; + if (mCellCount > 0) { + emptyCell = ItemUtils.getItemStackOfAmountFromOreDict("cellEmpty", mCellCount); + Logger.MATERIALS("[Dehydrator] Recipe now requires " + mCellCount + " empty cells as input."); + } + + ItemStack mainDust = material.getDust(material.smallestStackSizeWhenProcessing); + if (mainDust != null) { + Logger.MATERIALS( + "[Dehydrator] Recipe now requires " + material.smallestStackSizeWhenProcessing + + "x " + + mainDust.getDisplayName() + + " as input."); + } else { + mainDust = material.getDust(mTotalCount); + Logger.MATERIALS("[Dehydrator] Could not find valid input dust, trying alternative."); + if (mainDust != null) { + Logger.MATERIALS( + "[Dehydrator] Recipe now requires " + mTotalCount + + "x " + + mainDust.getDisplayName() + + " as input."); + } else { + Logger.MATERIALS("[Dehydrator] Could not find valid input dust, exiting."); + } + } + + for (int j = 0; j < mInternalOutputs.length; j++) { + if (mInternalOutputs[j] == null) { + mInternalOutputs[j] = GT_Values.NI; + Logger.MATERIALS("[Dehydrator] Set slot " + j + " to null."); + } else { + Logger.MATERIALS( + "[Dehydrator] Set slot " + j + " to " + mInternalOutputs[j].getDisplayName() + "."); + } + } + + try { + if (CORE.RA.addDehydratorRecipe( + new ItemStack[] { mainDust, emptyCell }, + null, + null, + mInternalOutputs, + mChances, + (int) Math.max(material.getMass() * 4L * 1, 1), + tVoltageMultiplier)) { + Logger.MATERIALS("[Dehydrator] Generated Dehydrator recipe for " + matDust.getDisplayName()); + Logger.MATERIALS( + "Inputs: " + mainDust.getDisplayName() + + " x" + + mainDust.stackSize + + ", " + + (emptyCell == null ? "No Cells" + : "" + emptyCell.getDisplayName() + " x" + emptyCell.stackSize)); + Logger.MATERIALS("Outputs " + ItemUtils.getArrayStackNames(mInternalOutputs)); + Logger.MATERIALS("Time: " + ((int) Math.max(material.getMass() * 4L * 1, 1))); + Logger.MATERIALS("EU: " + tVoltageMultiplier); + } else { + Logger.MATERIALS( + "[Dehydrator] Failed to generate Dehydrator recipe for " + matDust.getDisplayName()); + } + } catch (Throwable t) { + t.printStackTrace(); + } + } + } + + /** + * Shaped Crafting + */ + RecipeUtils.addShapedRecipe( + CI.craftingToolHammer_Hard, + null, + null, + material.getCrushedPurified(1), + null, + null, + null, + null, + null, + material.getDustPurified(1)); + + RecipeUtils.addShapedRecipe( + CI.craftingToolHammer_Hard, + null, + null, + material.getCrushed(1), + null, + null, + null, + null, + null, + material.getDustImpure(1)); + + RecipeUtils.addShapedRecipe( + CI.craftingToolHammer_Hard, + null, + null, + material.getCrushedCentrifuged(1), + null, + null, + null, + null, + null, + matDust); + + final ItemStack normalDust = matDust; + final ItemStack smallDust = material.getSmallDust(1); + final ItemStack tinyDust = material.getTinyDust(1); + + if (RecipeUtils.addShapedRecipe( + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + tinyDust, + normalDust)) { + Logger.WARNING("9 Tiny dust to 1 Dust Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("9 Tiny dust to 1 Dust Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (RecipeUtils + .addShapedRecipe(normalDust, null, null, null, null, null, null, null, null, material.getTinyDust(9))) { + Logger.WARNING("9 Tiny dust from 1 Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("9 Tiny dust from 1 Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (RecipeUtils + .addShapedRecipe(smallDust, smallDust, null, smallDust, smallDust, null, null, null, null, normalDust)) { + Logger.WARNING("4 Small dust to 1 Dust Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("4 Small dust to 1 Dust Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (RecipeUtils + .addShapedRecipe(null, normalDust, null, null, null, null, null, null, null, material.getSmallDust(4))) { + Logger.WARNING("4 Small dust from 1 Dust Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("4 Small dust from 1 Dust Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // } + } + + public static boolean addElectrolyzerRecipe(ItemStack aInput1, ItemStack aInput2, FluidStack aFluidInput, + FluidStack aFluidOutput, ItemStack aOutput1, ItemStack aOutput2, ItemStack aOutput3, ItemStack aOutput4, + ItemStack aOutput5, ItemStack aOutput6, int[] aChances, int aDuration, int aEUt) { + if (((aInput1 == null) && (aFluidInput == null)) || ((aOutput1 == null) && (aFluidOutput == null))) { + Logger.MATERIALS("[Electrolyzer] Either both inputs or outputs are null."); + return false; + } + if ((aInput1 != null) && (aDuration <= 0)) { + Logger.MATERIALS("[Electrolyzer] Fail 1."); + return false; + } + if ((aFluidInput != null) && (aDuration <= 0)) { + Logger.MATERIALS("[Electrolyzer] Fail 2."); + return false; + } + GT_Values.RA.addElectrolyzerRecipe( + aInput1, + aInput2, + aFluidInput, + aFluidOutput, + aOutput1, + aOutput2, + aOutput3, + aOutput4, + aOutput5, + aOutput6, + aChances, + aDuration, + aEUt); + Logger.MATERIALS("[Electrolyzer] Recipe added."); + return true; + } + + public static ItemStack getTinyDust(Material m) { + ItemStack x = m.getTinyDust(1); + if (x == null) { + x = mStone.getDust(1); + } + return x; + } + + public static ItemStack getDust(Material m) { + ItemStack x = m.getDust(1); + if (x == null) { + x = mStone.getDust(1); + } + return x; + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plasma.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plasma.java new file mode 100644 index 0000000000..01d6f9bb02 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plasma.java @@ -0,0 +1,62 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeGen_Plasma extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_Plasma(final Material M) { + this.toGenerate = M; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateRecipes(this.toGenerate); + } + + private void generateRecipes(final Material material) { + if (material.getPlasma() != null) { + // Cool Plasma + ItemStack aPlasmaCell = material.getPlasmaCell(1); + ItemStack aCell = material.getCell(1); + ItemStack aContainerItem = GT_Utility.getFluidForFilledItem(aPlasmaCell, true) == null + ? GT_Utility.getContainerItem(aPlasmaCell, true) + : CI.emptyCells(1); + if (ItemUtils.checkForInvalidItems(new ItemStack[] { aPlasmaCell, aContainerItem })) { + switch (material.getUnlocalizedName()) { + case "Runite": + GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, aPlasmaCell), aContainerItem, 350_000, 4); + case "CelestialTungsten": + GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, aPlasmaCell), aContainerItem, 720_000, 4); + default: + GT_Values.RA.addFuel( + GT_Utility.copyAmount(1L, aPlasmaCell), + aContainerItem, + (int) Math.max(1024L, 1024L * material.getMass()), + 4); + + } + } + if (ItemUtils.checkForInvalidItems(new ItemStack[] { aCell, aPlasmaCell })) { + GT_Values.RA.addVacuumFreezerRecipe(aPlasmaCell, aCell, (int) Math.max(material.getMass() * 2L, 1L)); + } + } + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plates.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plates.java new file mode 100644 index 0000000000..7eebc16af7 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plates.java @@ -0,0 +1,225 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.item.ItemStack; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.recipe.RecipeMaps; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeGen_Plates extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_Plates(final Material M) { + this.toGenerate = M; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateRecipes(this.toGenerate); + } + + private void generateRecipes(final Material material) { + + final int tVoltageMultiplier = material.getMeltingPointK() >= 2800 ? 60 : 15; + final ItemStack ingotStackOne = material.getIngot(1); + final ItemStack ingotStackTwo = material.getIngot(2); + final ItemStack ingotStackThree = material.getIngot(3); + final ItemStack ingotStackNine = material.getIngot(9); + final ItemStack shape_Mold = ItemList.Shape_Mold_Plate.get(0); + final ItemStack plate_Single = material.getPlate(1); + final ItemStack plate_SingleTwo = material.getPlate(2); + final ItemStack plate_SingleNine = material.getPlate(9); + final ItemStack plate_Double = material.getPlateDouble(1); + final ItemStack plate_Dense = material.getPlateDense(1); + final ItemStack foil_SingleFour = material.getFoil(4); + final ItemStack block = material.getBlock(1); + + Logger.WARNING("Generating Plate recipes for " + material.getLocalizedName()); + + // Forge Hammer + if (ItemUtils.checkForInvalidItems(ingotStackTwo) && ItemUtils.checkForInvalidItems(plate_Single)) + if (addForgeHammerRecipe( + ingotStackThree, + plate_SingleTwo, + (int) Math.max(material.getMass(), 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Forge Hammer Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Forge Hammer Recipe: " + material.getLocalizedName() + " - Failed"); + } + // Bender + if (ItemUtils.checkForInvalidItems(ingotStackOne) && ItemUtils.checkForInvalidItems(plate_Single)) + if (addBenderRecipe( + ingotStackOne, + plate_Single, + (int) Math.max(material.getMass() * 1L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Failed"); + } + if (ItemUtils.checkForInvalidItems(ingotStackOne) && ItemUtils.checkForInvalidItems(foil_SingleFour)) + if (addBenderRecipe( + ingotStackOne, + CI.getNumberedCircuit(10), + foil_SingleFour, + (int) Math.max(material.getMass() * 2L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Failed"); + } + // Alloy Smelter + if (ItemUtils.checkForInvalidItems(ingotStackTwo) && ItemUtils.checkForInvalidItems(plate_Single)) + if (GT_Values.RA.addAlloySmelterRecipe( + ingotStackTwo, + shape_Mold, + plate_Single, + (int) Math.max(material.getMass() * 2L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Alloy Smelter Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Alloy Smelter Recipe: " + material.getLocalizedName() + " - Failed"); + } + // Cutting Machine + if (ItemUtils.checkForInvalidItems(block) && ItemUtils.checkForInvalidItems(plate_Single)) + if (GT_Values.RA.addCutterRecipe( + block, + plate_SingleNine, + null, + (int) Math.max(material.getMass() * 10L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Cutting Machine Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Cutting Machine Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Making Double Plates + if (ItemUtils.checkForInvalidItems(ingotStackTwo) && ItemUtils.checkForInvalidItems(plate_Double)) + if (addBenderRecipe( + ingotStackTwo, + plate_Double, + (int) Math.max(material.getMass() * 2L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (ItemUtils.checkForInvalidItems(plate_SingleTwo) && ItemUtils.checkForInvalidItems(plate_Double)) + if (addBenderRecipe( + plate_SingleTwo, + plate_Double, + (int) Math.max(material.getMass() * 2L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Bender + if (ItemUtils.checkForInvalidItems(material.getPlate(1)) && ItemUtils.checkForInvalidItems(material.getFoil(1))) + if (addBenderRecipe( + material.getPlate(1), + material.getFoil(4), + (int) Math.max(material.getMass(), 1L), + material.vVoltageMultiplier)) { + GregTech_API.registerCover( + material.getFoil(1), + new GT_RenderedTexture(material.getTextureSet().mTextures[70], material.getRGBA(), false), + null); + Logger.WARNING("Bender Foil Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Bender Foil Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Making Dense Plates + if (ItemUtils.checkForInvalidItems(ingotStackNine) && ItemUtils.checkForInvalidItems(plate_Dense)) + if (addBenderRecipe( + ingotStackNine, + plate_Dense, + (int) Math.max(material.getMass() * 2L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Failed"); + } + + if (ItemUtils.checkForInvalidItems(plate_SingleNine) && ItemUtils.checkForInvalidItems(plate_Dense)) + if (addBenderRecipe( + plate_SingleNine, + plate_Dense, + (int) Math.max(material.getMass() * 2L, 1L), + material.vVoltageMultiplier)) { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Bender Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + public static boolean addBenderRecipe(final ItemStack aInput1, final ItemStack aOutput1, int aDuration, + final int aEUt) { + return GT_Values.RA.addBenderRecipe(aInput1, aOutput1, aDuration, aEUt); + } + + public static boolean addBenderRecipe(final ItemStack aInput1, final ItemStack aCircuit, final ItemStack aOutput1, + int aDuration, final int aEUt) { + return GT_Values.RA.addBenderRecipe(aInput1, aCircuit, aOutput1, aDuration, aEUt); + } + + public static boolean addExtruderRecipe(final ItemStack aInput, final ItemStack aShape, final ItemStack aOutput, + int aDuration, final int aEUt) { + if ((aInput == null) || (aShape == null) || (aOutput == null)) { + return false; + } + if (aDuration <= 0) { + return false; + } + RecipeMaps.extruderRecipes.addRecipe( + true, + new ItemStack[] { aInput, aShape }, + new ItemStack[] { aOutput }, + null, + null, + null, + aDuration, + aEUt, + 0); + return true; + } + + public static boolean addForgeHammerRecipe(final ItemStack aInput1, final ItemStack aOutput1, final int aDuration, + final int aEUt) { + if ((aInput1 == null) || (aOutput1 == null)) { + return false; + } + RecipeMaps.hammerRecipes.addRecipe( + true, + new ItemStack[] { aInput1 }, + new ItemStack[] { aOutput1 }, + null, + null, + null, + aDuration, + aEUt, + 0); + return true; + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Recycling.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Recycling.java new file mode 100644 index 0000000000..044ce58c62 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Recycling.java @@ -0,0 +1,400 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import static gregtech.api.enums.GT_Values.L; +import static gregtech.api.enums.GT_Values.M; + +import java.util.ArrayList; +import java.util.Map; + +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +import org.apache.commons.lang3.reflect.FieldUtils; + +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.GT_Utility; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.api.objects.data.Pair; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.state.MaterialState; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.reflect.ReflectionUtils; + +public class RecipeGen_Recycling implements Runnable { + + public static AutoMap<Runnable> mQueuedRecyclingGenerators = new AutoMap<>(); + + public static void executeGenerators() { + if (mQueuedRecyclingGenerators.size() > 0) { + for (Runnable R : mQueuedRecyclingGenerators.values()) { + R.run(); + } + } + } + + final Material toGenerate; + public static Map<String, ItemStack> mNameMap; + + public RecipeGen_Recycling(final Material M) { + this.toGenerate = M; + if (mNameMap == null) { + mNameMap = this.getNameMap(); + } + mQueuedRecyclingGenerators.put(this); + } + + @Override + public void run() { + if (mNameMap != null) { + generateRecipes(this.toGenerate); + } + } + + public static void generateRecipes(final Material material) { + + if (material != null) Logger.WARNING("Generating Recycling recipes for " + material.getLocalizedName()); + + final OrePrefixes[] mValidPrefixesAsString = { OrePrefixes.ingot, OrePrefixes.ingotHot, OrePrefixes.nugget, + OrePrefixes.plate, OrePrefixes.plateDense, OrePrefixes.plateDouble, OrePrefixes.plateTriple, + OrePrefixes.plateQuadruple, OrePrefixes.plateQuintuple, OrePrefixes.stick, OrePrefixes.stickLong, + OrePrefixes.bolt, OrePrefixes.screw, OrePrefixes.ring, OrePrefixes.rotor, OrePrefixes.gearGt, + OrePrefixes.gearGtSmall, OrePrefixes.gear, OrePrefixes.block, OrePrefixes.cableGt01, OrePrefixes.cableGt02, + OrePrefixes.cableGt04, OrePrefixes.cableGt08, OrePrefixes.cableGt12, OrePrefixes.wireFine, + OrePrefixes.wireGt01, OrePrefixes.wireGt02, OrePrefixes.wireGt04, OrePrefixes.wireGt08, + OrePrefixes.wireGt12, OrePrefixes.wireGt16, OrePrefixes.foil, OrePrefixes.frameGt, OrePrefixes.pipeHuge, + OrePrefixes.pipeLarge, OrePrefixes.pipeMedium, OrePrefixes.pipeSmall, OrePrefixes.pipeTiny, }; + + int mSlotIndex = 0; + Pair<OrePrefixes, ItemStack>[] mValidPairs = new Pair[mValidPrefixesAsString.length]; + + for (int r = 0; r < mValidPairs.length; r++) { + ItemStack temp = getItemStackOfAmountFromOreDictNoBroken( + mValidPrefixesAsString[r].name() + Utils.sanitizeString(material.getLocalizedName()), + 1); + if (temp != null) { + mValidPairs[mSlotIndex++] = new Pair<>(mValidPrefixesAsString[r], temp.copy()); + } + } + + if (mValidPairs.length > 0) { + int validCounter = 0; + Pair<OrePrefixes, ItemStack>[] temp = mValidPairs; + for (Pair<OrePrefixes, ItemStack> temp2 : mValidPairs) { + if (temp2 != null) { + Logger.WARNING( + "Valid: " + temp2.getValue() + .getDisplayName()); + validCounter++; + } + } + Pair<OrePrefixes, ItemStack> temp3[] = new Pair[validCounter]; + int temp4 = 0; + for (Pair<OrePrefixes, ItemStack> r : mValidPairs) { + if (r != null) { + temp3[temp4++] = r; + } + } + if (temp3.length > 0) { + mValidPairs = temp3.clone(); + } + } + + if (mValidPrefixesAsString.length >= 1) { + for (final Pair<OrePrefixes, ItemStack> validPrefix : mValidPairs) { + try { + + if (material == null || validPrefix == null + || (material.getState() != MaterialState.SOLID && material.getState() != MaterialState.LIQUID) + || validPrefix.getKey() == OrePrefixes.ingotHot) { + continue; + } + + final ItemStack tempStack = validPrefix.getValue(); + final ItemStack mDust = getDust(material, validPrefix.getKey()); + final Pair<OrePrefixes, ItemStack> mData = getDustData(material, validPrefix.getKey()); + int mFluidAmount = (int) GT_Utility + .translateMaterialToFluidAmount(validPrefix.getKey().mMaterialAmount, true); + + // Maceration + if (ItemUtils.checkForInvalidItems(tempStack)) { + // mValidItems[mSlotIndex++] = tempStack; + if ((mDust != null) && GT_ModHandler.addPulverisationRecipe(tempStack, mDust)) { + Logger.WARNING( + "Recycle Recipe: " + material.getLocalizedName() + + " - Success - Recycle " + + tempStack.getDisplayName() + + " and obtain " + + mDust.getDisplayName()); + } else { + Logger.WARNING("Recycle Recipe: " + material.getLocalizedName() + " - Failed"); + if (mDust == null) { + Logger.WARNING("Invalid Dust output."); + } + } + } + + // Arc Furnace + if (ItemUtils.checkForInvalidItems(tempStack)) {} + + // Fluid Extractor + if (ItemUtils.checkForInvalidItems(tempStack)) { + // mValidItems[mSlotIndex++] = tempStack; + + int aFluidAmount = (int) ((L * validPrefix.getKey().mMaterialAmount) + / (M * tempStack.stackSize)); + int aDuration = (int) Math.max(1, (24 * validPrefix.getKey().mMaterialAmount) / M); + boolean aGenFluidExtraction = CORE.RA.addFluidExtractionRecipe( + tempStack, + material.getFluidStack(aFluidAmount), + aDuration, + material.vVoltageMultiplier); + if (aGenFluidExtraction /* + * (mDust != null) && CORE.RA.addFluidExtractionRecipe(tempStack, + * material.getFluidStack(mFluidAmount), 30, + * material.vVoltageMultiplier) + */) { + Logger.WARNING( + "Fluid Recycle Recipe: " + material.getLocalizedName() + + " - Success - Recycle " + + tempStack.getDisplayName() + + " and obtain " + + aFluidAmount + + "mb of " + + material.getFluidStack(1) + .getLocalizedName() + + ". Time: " + + aDuration + + ", Voltage: " + + material.vVoltageMultiplier); + } else { + Logger.WARNING("Fluid Recycle Recipe: " + material.getLocalizedName() + " - Failed"); + if (mDust == null) { + Logger.WARNING("Invalid Dust output."); + } + } + } + + } catch (final Throwable t) { + t.printStackTrace(); + // Utils.LOG_WARNING("Returning Null. Throwable Info: + // "+t.getMessage()); + // Utils.LOG_WARNING("Throwable Info: "+t.toString()); + // Utils.LOG_WARNING("Throwable Info: + // "+t.getCause().toString()); + } + } + } + } + + public static Pair<OrePrefixes, ItemStack> getDustData(final Material aMaterial, final OrePrefixes aPrefix) { + return getDustData(aMaterial, aPrefix.mMaterialAmount); + } + + public static Pair<OrePrefixes, ItemStack> getDustData(final Material aMaterial, final long aMaterialAmount) { + ItemStack mDust = null; + OrePrefixes mPrefix = null; + + if (aMaterial == null || aMaterialAmount <= 0) { + return null; + } + if ((((aMaterialAmount % M) == 0) || (aMaterialAmount >= (M * 16)))) { + mDust = get(OrePrefixes.dust, aMaterial, aMaterialAmount / M); + mPrefix = OrePrefixes.dust; + } + if ((mDust == null) && ((((aMaterialAmount * 4) % M) == 0) || (aMaterialAmount >= (M * 8)))) { + mDust = get(OrePrefixes.dustSmall, aMaterial, (aMaterialAmount * 4) / M); + mPrefix = OrePrefixes.dustSmall; + } + if ((mDust == null) && (((aMaterialAmount * 9) >= M))) { + mDust = get(OrePrefixes.dustTiny, aMaterial, (aMaterialAmount * 9) / M); + mPrefix = OrePrefixes.dustTiny; + } + + if (mPrefix != null && mDust != null) { + Logger.WARNING("Built valid dust pair."); + return new Pair<>(mPrefix, mDust); + } else { + Logger.WARNING("mPrefix: " + (mPrefix != null)); + Logger.WARNING("mDust: " + (mDust != null)); + } + Logger.WARNING("Failed to build valid dust pair."); + return null; + } + + public static ItemStack getDust(final Material aMaterial, final OrePrefixes aPrefix) { + return aMaterial == null ? null : getDust(aMaterial, aPrefix.mMaterialAmount); + } + + public static ItemStack getDust(final Material aMaterial, final long aMaterialAmount) { + if (aMaterialAmount <= 0) { + return null; + } + ItemStack rStack = null; + if ((((aMaterialAmount % M) == 0) || (aMaterialAmount >= (M * 16)))) { + Logger.WARNING("Trying to get a Dust"); + rStack = get(OrePrefixes.dust, aMaterial, aMaterialAmount / M); + } + if ((rStack == null) && ((((aMaterialAmount * 4) % M) == 0) || (aMaterialAmount >= (M * 8)))) { + Logger.WARNING("Trying to get a Small Dust"); + rStack = get(OrePrefixes.dustSmall, aMaterial, (aMaterialAmount * 4) / M); + } + if ((rStack == null) && (((aMaterialAmount * 9) >= M))) { + Logger.WARNING("Trying to get a Tiny Dust"); + rStack = get(OrePrefixes.dustTiny, aMaterial, (aMaterialAmount * 9) / M); + } + return rStack; + } + + public static ItemStack get(final Object aName, final long aAmount) { + return get(aName, null, aAmount, true, true); + } + + public static ItemStack get(final Object aName, final ItemStack aReplacement, final long aAmount) { + return get(aName, aReplacement, aAmount, true, true); + } + + public static ItemStack get(final OrePrefixes aPrefix, final Material aMaterial, final long aAmount) { + return get(aPrefix, aMaterial, null, aAmount); + } + + public static ItemStack get(final OrePrefixes aPrefix, final Material aMaterial, final ItemStack aReplacement, + final long aAmount) { + return get( + aPrefix.name() + Utils.sanitizeString(aMaterial.getLocalizedName()), + aReplacement, + aAmount, + false, + true); + } + + public static ItemStack get(final Object aName, final ItemStack aReplacement, final long aAmount, + final boolean aMentionPossibleTypos, final boolean aNoInvalidAmounts) { + if (aNoInvalidAmounts && (aAmount < 1L)) { + Logger.WARNING("Returning Null. Method: " + ReflectionUtils.getMethodName(0)); + Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(1)); + Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(2)); + Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(3)); + Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(4)); + return null; + } + if (!mNameMap.containsKey(aName.toString()) && aMentionPossibleTypos) { + Logger.WARNING("Unknown Key for Unification, Typo? " + aName); + } + return GT_Utility.copyAmount( + aAmount, + new Object[] { mNameMap.get(aName.toString()), getFirstOre(aName, aAmount), aReplacement }); + } + + public static ItemStack getFirstOre(final Object aName, final long aAmount) { + if (GT_Utility.isStringInvalid(aName)) { + Logger.WARNING("Returning Null. Method: " + ReflectionUtils.getMethodName(0)); + Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(1)); + Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(2)); + Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(3)); + Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(4)); + return null; + } + final ItemStack tStack = mNameMap.get(aName.toString()); + if (GT_Utility.isStackValid(tStack)) { + Logger.WARNING("Found valid stack."); + return GT_Utility.copyAmount(aAmount, new Object[] { tStack }); + } + return GT_Utility.copyAmount(aAmount, getOres(aName).toArray()); + } + + public static ArrayList<ItemStack> getOres(final Object aOreName) { + final String aName = (aOreName == null) ? "" : aOreName.toString(); + final ArrayList<ItemStack> rList = new ArrayList<>(); + if (GT_Utility.isStringValid(aName)) { + Logger.WARNING("Making a list of all OreDict entries for " + aOreName + "."); + if (rList.addAll(OreDictionary.getOres(aName))) { + Logger.WARNING("Added " + rList.size() + " elements to list."); + } else { + Logger.WARNING("Failed to Add Collection from oreDictionary, forcing an entry."); + rList.add(ItemUtils.getItemStackOfAmountFromOreDict((String) aOreName, 1)); + } + } + return rList; + } + + @SuppressWarnings("unchecked") + public Map<String, ItemStack> getNameMap() { + Map<String, ItemStack> tempMap; + try { + tempMap = (Map<String, ItemStack>) FieldUtils + .readStaticField(GT_OreDictUnificator.class, "sName2StackMap", true); + if (tempMap != null) { + Logger.WARNING("Found 'sName2StackMap' in GT_OreDictUnificator.class."); + return tempMap; + } + } catch (final IllegalAccessException e) { + e.printStackTrace(); + } + Logger.WARNING("Invalid map stored in GT_OreDictUnificator.class, unable to find sName2StackMap field."); + return null; + } + + public static ItemStack getItemStackOfAmountFromOreDictNoBroken(String oredictName, final int amount) { + + try { + + if (oredictName.contains("-") || oredictName.contains("_")) { + oredictName = Utils.sanitizeString(oredictName, new char[] { '-', '_' }); + } else { + oredictName = Utils.sanitizeString(oredictName); + } + + // Adds a check to grab dusts using GT methodology if possible. + ItemStack returnValue = null; + if (oredictName.toLowerCase() + .contains("dust")) { + final String MaterialName = oredictName.toLowerCase() + .replace("dust", ""); + final Materials m = Materials.get(MaterialName); + if (m != null && m != Materials._NULL) { + returnValue = ItemUtils.getGregtechDust(m, amount); + if (ItemUtils.checkForInvalidItems(returnValue)) { + return returnValue; + } + } + } + if (returnValue == null) { + returnValue = getItemStackOfAmountFromOreDict(oredictName, amount); + if (ItemUtils.checkForInvalidItems(returnValue)) { + return returnValue.copy(); + } + } + return null; + } catch (final Throwable t) { + return null; + } + } + + public static ItemStack getItemStackOfAmountFromOreDict(String oredictName, final int amount) { + String mTemp = oredictName; + + // Banned Materials and replacements for GT5.8 compat. + + if (oredictName.toLowerCase() + .contains("ingotclay")) { + return ItemUtils.getSimpleStack(Items.clay_ball, amount); + } + + final ArrayList<ItemStack> oreDictList = OreDictionary.getOres(mTemp); + if (!oreDictList.isEmpty()) { + final ItemStack returnValue = oreDictList.get(0) + .copy(); + returnValue.stackSize = amount; + return returnValue; + } + return null; + // return getItemStackOfAmountFromOreDictNoBroken(mTemp, amount); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_ShapedCrafting.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_ShapedCrafting.java new file mode 100644 index 0000000000..3ef1740189 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_ShapedCrafting.java @@ -0,0 +1,222 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.HashSet; +import java.util.Set; + +import gregtech.api.util.GT_ModHandler; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeGen_ShapedCrafting extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_ShapedCrafting(final Material M) { + this.toGenerate = M; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateRecipes(this.toGenerate); + } + + private void generateRecipes(final Material material) { + Logger.WARNING("Generating Shaped Crafting recipes for " + material.getLocalizedName()); // TODO + + // Single Plate Shaped/Shapeless + if (ItemUtils.checkForInvalidItems(material.getPlate(1)) + && ItemUtils.checkForInvalidItems(material.getIngot(1))) + if (material.getPlate(1) != null && material.getIngot(1) != null) GT_ModHandler.addCraftingRecipe( + material.getPlate(1), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "h", "B", "I", Character.valueOf('I'), material.getIngot(1), Character.valueOf('B'), + material.getIngot(1) }); + + if (ItemUtils.checkForInvalidItems(material.getPlate(1)) + && ItemUtils.checkForInvalidItems(material.getIngot(1))) + GT_ModHandler.addShapelessCraftingRecipe( + material.getPlate(1), + new Object[] { gregtech.api.enums.ToolDictNames.craftingToolForgeHammer, material.getIngot(1), + material.getIngot(1) }); + + // Double Plate Shaped/Shapeless + if (ItemUtils.checkForInvalidItems(material.getPlateDouble(1)) + && ItemUtils.checkForInvalidItems(material.getPlate(1))) + GT_ModHandler.addCraftingRecipe( + material.getPlateDouble(1), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "I", "B", "h", Character.valueOf('I'), material.getPlate(1), Character.valueOf('B'), + material.getPlate(1) }); + + if (ItemUtils.checkForInvalidItems(material.getPlateDouble(1)) + && ItemUtils.checkForInvalidItems(material.getPlate(1))) + GT_ModHandler.addShapelessCraftingRecipe( + material.getPlateDouble(1), + new Object[] { gregtech.api.enums.ToolDictNames.craftingToolForgeHammer, material.getPlate(1), + material.getPlate(1) }); + + // Ring Recipe + if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getRing(1)) + && ItemUtils.checkForInvalidItems(material.getRod(1))) { + if (GT_ModHandler.addCraftingRecipe( + material.getRing(1), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "h ", "fR", 'R', material.getRod(1) })) { + Logger.WARNING("GT:NH Ring Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("GT:NH Ring Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Framebox Recipe + if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getFrameBox(1)) + && ItemUtils.checkForInvalidItems(material.getRod(1))) { + if (GT_ModHandler.addCraftingRecipe( + material.getFrameBox(2), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "RRR", "RwR", "RRR", 'R', material.getRod(1) })) { + Logger.WARNING("Framebox Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Framebox Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Shaped Recipe - Bolts + if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getBolt(1)) + && ItemUtils.checkForInvalidItems(material.getRod(1))) { + if (GT_ModHandler.addCraftingRecipe( + material.getBolt(2), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "s ", " R", 'R', material.getRod(1) })) { + Logger.WARNING("Bolt Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Bolt Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Shaped Recipe - Fine Wire + if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getFoil(1)) + && ItemUtils.checkForInvalidItems(material.getFineWire(1))) { + if (GT_ModHandler.addCraftingRecipe( + material.getFineWire(1), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "Fx", 'F', material.getFoil(1) })) { + Logger.WARNING("Fine Wire Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Fine Wire Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Shaped Recipe - Foil + if (ItemUtils.checkForInvalidItems(material.getFoil(1)) + && ItemUtils.checkForInvalidItems(material.getPlate(1))) { + if (GT_ModHandler.addCraftingRecipe( + material.getFoil(2), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "hP", 'P', material.getPlate(1) })) { + Logger.WARNING("Foil Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Foil Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Shaped Recipe - Ingot to Rod + if (ItemUtils.checkForInvalidItems(material.getRod(1)) && ItemUtils.checkForInvalidItems(material.getIngot(1))) + if (GT_ModHandler.addCraftingRecipe( + material.getRod(1), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "f ", " I", 'I', material.getIngot(1) })) { + Logger.WARNING("Rod Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Rod Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Shaped Recipe - Long Rod to two smalls + if (ItemUtils.checkForInvalidItems(material.getRod(1)) + && ItemUtils.checkForInvalidItems(material.getLongRod(1))) + if (GT_ModHandler.addCraftingRecipe( + material.getRod(2), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "s", "L", 'L', material.getLongRod(1) })) { + Logger.WARNING("Rod Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Rod Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Two small to long rod + if (ItemUtils.checkForInvalidItems(material.getLongRod(1)) + && ItemUtils.checkForInvalidItems(material.getRod(1))) + if (GT_ModHandler.addCraftingRecipe( + material.getLongRod(1), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "RhR", 'R', material.getRod(1) })) { + Logger.WARNING("Long Rod Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Long Rod Recipe: " + material.getLocalizedName() + " - Failed"); + } + + // Rotor Recipe + if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getRotor(1)) + && ItemUtils.checkForInvalidItems(material.getRing(1)) + && !material.isRadioactive + && ItemUtils.checkForInvalidItems(material.getPlate(1)) + && ItemUtils.checkForInvalidItems(material.getScrew(1))) { + if (GT_ModHandler.addCraftingRecipe( + material.getRotor(1), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PhP", "SRf", "PdP", 'P', material.getPlate(1), 'S', material.getScrew(1), 'R', + material.getRing(1), })) { + Logger.WARNING("Rotor Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Rotor Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Gear Recipe + if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getGear(1)) + && ItemUtils.checkForInvalidItems(material.getPlate(1)) + && ItemUtils.checkForInvalidItems(material.getRod(1))) { + if (GT_ModHandler.addCraftingRecipe( + material.getGear(1), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "RPR", "PwP", "RPR", 'P', material.getPlate(1), 'R', material.getRod(1), })) { + Logger.WARNING("Gear Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Gear Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + + // Screws + if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getScrew(1)) + && ItemUtils.checkForInvalidItems(material.getBolt(1))) { + if (GT_ModHandler.addCraftingRecipe( + material.getScrew(1), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "fB", "B ", 'B', material.getBolt(1), })) { + Logger.WARNING("Screw Recipe: " + material.getLocalizedName() + " - Success"); + } else { + Logger.WARNING("Screw Recipe: " + material.getLocalizedName() + " - Failed"); + } + } + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/misc/AddCustomMachineToPA.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/misc/AddCustomMachineToPA.java new file mode 100644 index 0000000000..aab24db6d3 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/misc/AddCustomMachineToPA.java @@ -0,0 +1,13 @@ +package gtPlusPlus.xmod.gregtech.loaders.misc; + +import gregtech.api.util.GT_ProcessingArray_Manager; +import gtPlusPlus.api.recipe.GTPPRecipeMaps; + +public class AddCustomMachineToPA { + + public static void register() { + + // Simple Washers + GT_ProcessingArray_Manager.addRecipeMapToPA("simplewasher.01", GTPPRecipeMaps.simpleWasherRecipes); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_AlgaeFarm.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_AlgaeFarm.java new file mode 100644 index 0000000000..69d79cdc4b --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_AlgaeFarm.java @@ -0,0 +1,192 @@ +package gtPlusPlus.xmod.gregtech.loaders.recipe; + +import java.util.HashMap; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_Recipe; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.api.objects.data.WeightedCollection; +import gtPlusPlus.core.item.chemistry.AgriculturalChem; +import gtPlusPlus.core.util.math.MathUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeLoader_AlgaeFarm { + + private static final HashMap<Integer, AutoMap<GT_Recipe>> mRecipeCache = new HashMap<>(); + private static final HashMap<Integer, AutoMap<GT_Recipe>> mRecipeCompostCache = new HashMap<>(); + + public static void generateRecipes() { + for (int i = 0; i < 10; i++) { + getTieredRecipeFromCache(i, false); + } + for (int i = 0; i < 10; i++) { + getTieredRecipeFromCache(i, true); + } + } + + public static GT_Recipe getTieredRecipeFromCache(int aTier, boolean aCompost) { + HashMap<Integer, AutoMap<GT_Recipe>> aMap = aCompost ? mRecipeCompostCache : mRecipeCache; + String aComp = aCompost ? "(Compost)" : ""; + + AutoMap<GT_Recipe> aTemp = aMap.get(aTier); + if (aTemp == null || aTemp.isEmpty()) { + aTemp = new AutoMap<>(); + aMap.put(aTier, aTemp); + Logger.INFO("Tier " + aTier + aComp + " had no recipes, initialising new map."); + } + if (aTemp.size() < 500) { + Logger + .INFO("Tier " + aTier + aComp + " has less than 500 recipes, generating " + (500 - aTemp.size()) + "."); + for (int i = aTemp.size(); i < 500; i++) { + aTemp.put(generateBaseRecipe(aCompost, aTier)); + } + } + int aIndex = MathUtils.randInt(0, aTemp.isEmpty() ? 1 : aTemp.size()); + Logger.INFO("Using recipe with index of " + aIndex + ". " + aComp); + return aTemp.get(aIndex); + } + + public static int compostForTier(int aTier) { + return aTier > 1 ? (int) Math.min(64, Math.pow(2, aTier - 1)) : 1; + } + + private static GT_Recipe generateBaseRecipe(boolean aUsingCompost, int aTier) { + + // Type Safety + if (aTier < 0) { + return null; + } + + WeightedCollection<Float> aOutputTimeMulti = new WeightedCollection<>(); + for (int i = 100; i > 0; i--) { + float aValue = 0; + if (i < 10) { + aValue = 3f; + } else if (i < 20) { + aValue = 2f; + } else { + aValue = 1f; + } + aOutputTimeMulti.put(i, aValue); + } + + final int[] aDurations = new int[] { 2000, 1800, 1600, 1400, 1200, 1000, 512, 256, 128, 64, 32, 16, 8, 4, 2, + 1 }; + + ItemStack[] aInputs = new ItemStack[] {}; + + if (aUsingCompost) { + // Make it use 4 compost per tier if we have some available + // Compost consumption maxes out at 1 stack per cycle + ItemStack aCompost = ItemUtils.getSimpleStack(AgriculturalChem.mCompost, compostForTier(aTier)); + aInputs = new ItemStack[] { aCompost }; + // Boost Tier by one if using compost so it gets a speed boost + aTier++; + } + + // We set these elsewhere + ItemStack[] aOutputs = getOutputsForTier(aTier); + + GT_Recipe tRecipe = new GT_Recipe( + false, + aInputs, + aOutputs, + (Object) null, + new int[] {}, + new FluidStack[] { GT_Values.NF }, + new FluidStack[] { GT_Values.NF }, + (int) (aDurations[aTier] * aOutputTimeMulti.get() / 2), // Time + 0, + 0); + + tRecipe.mSpecialValue = tRecipe.hashCode(); + + return tRecipe; + } + + private static ItemStack[] getOutputsForTier(int aTier) { + + // Create an Automap to dump contents into + AutoMap<ItemStack> aOutputMap = new AutoMap<>(); + + // Add loot relevant to tier and also add any from lower tiers. + + if (aTier >= 0) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mAlgaeBiosmass, 2)); + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mAlgaeBiosmass, 4)); + if (MathUtils.randInt(0, 10) > 9) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 2)); + } + } + + if (aTier >= 1) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mAlgaeBiosmass, 4)); + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 2)); + if (MathUtils.randInt(0, 10) > 9) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 4)); + } + } + if (aTier >= 2) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 2)); + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 3)); + if (MathUtils.randInt(0, 10) > 9) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 8)); + } + } + if (aTier >= 3) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 4)); + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 1)); + if (MathUtils.randInt(0, 10) > 9) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 4)); + } + } + if (aTier >= 4) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 2)); + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 3)); + if (MathUtils.randInt(0, 10) > 9) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, 4)); + } + } + if (aTier >= 5) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 4)); + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, 2)); + if (MathUtils.randInt(0, 10) > 9) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, 4)); + } + } + // Tier 6 is Highest for outputs + if (aTier >= 6) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, 4)); + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, 2)); + if (MathUtils.randInt(0, 10) > 9) { + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, 8)); + } + } + + // Iterate a special loop at higher tiers to provide more Red/Gold Algae. + for (int i2 = 0; i2 < 20; i2++) { + if (aTier >= (6 + i2)) { + int aMulti = i2 + 1; + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, aMulti * 4)); + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, aMulti * 3)); + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, aMulti * 2)); + aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, aMulti)); + } else { + i2 = 20; + } + } + + // Map the AutoMap contents to an Itemstack Array. + ItemStack[] aOutputs = new ItemStack[aOutputMap.size()]; + for (int i = 0; i < aOutputMap.size(); i++) { + aOutputs[i] = aOutputMap.get(i); + } + + // Return filled ItemStack Array. + return aOutputs; + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_ChemicalSkips.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_ChemicalSkips.java new file mode 100644 index 0000000000..dfa6d9dea6 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_ChemicalSkips.java @@ -0,0 +1,661 @@ +package gtPlusPlus.xmod.gregtech.loaders.recipe; + +import static gregtech.api.enums.Mods.BartWorks; +import static gregtech.api.enums.Mods.EternalSingularity; +import static gregtech.api.enums.Mods.GalaxySpace; +import static gregtech.api.enums.Mods.GoodGenerator; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.util.GT_ModHandler.getModItem; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; +import com.github.technus.tectech.recipe.TT_recipeAdder; +import com.github.technus.tectech.thing.block.QuantumGlassBlock; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsKevlar; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.items.CombType; +import gregtech.loaders.misc.GT_Bees; +import gtPlusPlus.core.item.chemistry.GenericChem; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.ALLOY; +import gtPlusPlus.core.material.ELEMENT; +import gtPlusPlus.core.material.MISC_MATERIALS; +import gtPlusPlus.core.material.Particle; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; + +public class RecipeLoader_ChemicalSkips { + + public static void generate() { + createRecipes(); + } + + private static void createRecipes() { + quantumTransformerRecipes(); + fusionReactorRecipes(); + catalystRecipes(); + tieredCasingRecipes(); + } + + // All the recipes that the QFT can do. Each recipe has a machine tier. + // -> Tier 1 is UEV (UEV circuits and 1 Eternal Singularity); + // -> Tier 2 needs new item from QFT, plus stacks of Infinity; + // -> Tier 3 needs new item from QFT, plus stacks of Transcendent Metal; + // -> Tier 4 needs new item from QFT, plus stacks of Spacetime; + // (Until they are created, the new items are represented by + // HSS-G for Tier 2, HSS-S for Tier 3 and HSS-E for Tier 4) + + private static void quantumTransformerRecipes() { + ItemStack stemcells = GT_Utility.copyAmountUnsafe(64 * 32, ItemList.Circuit_Chip_Stemcell.get(1)); + ItemStack biocells = GT_Utility.copyAmountUnsafe(64 * 32, ItemList.Circuit_Chip_Biocell.get(1)); + // Platline + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { WerkstoffLoader.PTMetallicPowder.get(OrePrefixes.dust, 32), + ItemUtils.getSimpleStack(GenericChem.mPlatinumGroupCatalyst, 0) }, + new FluidStack[] {}, + new FluidStack[] {}, + new ItemStack[] { Materials.Platinum.getDust(64), Materials.Palladium.getDust(64), + Materials.Iridium.getDust(64), Materials.Osmium.getDust(64), + WerkstoffLoader.Rhodium.get(OrePrefixes.dust, 64), + WerkstoffLoader.Ruthenium.get(OrePrefixes.dust, 64) }, + new int[] { 1667, 1667, 1667, 1667, 1667, 1667 }, + 20 * 20, + (int) TierEU.RECIPE_UV, + 1); + + // Early Plastics + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { Materials.Carbon.getDust(64), + ItemUtils.getSimpleStack(GenericChem.mPlasticPolymerCatalyst, 0) }, + new FluidStack[] { Materials.Oxygen.getGas(1000 * 16), Materials.Hydrogen.getGas(1000 * 16), + Materials.Chlorine.getGas(1000 * 16), Materials.Fluorine.getGas(1000 * 16) }, + new FluidStack[] { Materials.Plastic.getMolten(144 * 256), Materials.PolyvinylChloride.getMolten(144 * 128), + Materials.Polystyrene.getMolten(144 * 64), Materials.Polytetrafluoroethylene.getMolten(144 * 128), + Materials.Epoxid.getMolten(144 * 64), Materials.Polybenzimidazole.getMolten(144 * 64) }, + null, + new int[] { 2000, 2000, 2000, 2000, 2000, 2000 }, + 20 * 20, + (int) TierEU.RECIPE_ZPM, + 1); + + // Early Rubbers/Cable Materials + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { Materials.Carbon.getDust(64), + ItemUtils.getSimpleStack(GenericChem.mRubberPolymerCatalyst, 0) }, + new FluidStack[] { Materials.Oxygen.getGas(1000 * 16), Materials.Hydrogen.getGas(1000 * 16), + Materials.Chlorine.getGas(1000 * 16) }, + new FluidStack[] { Materials.Silicone.getMolten(144 * 64), + Materials.StyreneButadieneRubber.getMolten(144 * 64), + Materials.PolyphenyleneSulfide.getMolten(144 * 128), Materials.Rubber.getMolten(144 * 256) }, + null, + new int[] { 2500, 2500, 2500, 2500 }, + 20 * 20, + (int) TierEU.RECIPE_ZPM, + 1); + + // Glues and Solders + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { Materials.Carbon.getDust(32), Materials.Bismuth.getDust(32), + ItemUtils.getSimpleStack(GenericChem.mAdhesionPromoterCatalyst, 0) }, + new FluidStack[] { Materials.Oxygen.getGas(10000), Materials.Hydrogen.getGas(10000) }, + new FluidStack[] { MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(1000 * 32), + Materials.AdvancedGlue.getFluid(1000 * 16), ALLOY.INDALLOY_140.getFluidStack(144 * 64), + Materials.SolderingAlloy.getMolten(144 * 128) }, + new ItemStack[] { ItemList.StableAdhesive.get(1) }, + new int[] { 2000, 2000, 2000, 2000, 2000 }, + 20 * 20, + (int) TierEU.RECIPE_UV, + 1); + + // Titanium, Tungsten, Indium + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { Materials.Lead.getDust(16), Materials.Bauxite.getDust(32), + Materials.Tungstate.getDust(16), ItemUtils.getSimpleStack(GenericChem.mTitaTungstenIndiumCatalyst, 0) }, + new FluidStack[] {}, + new FluidStack[] {}, + new ItemStack[] { Materials.Titanium.getDust(64), Materials.TungstenSteel.getDust(64), + Materials.TungstenCarbide.getDust(64), Materials.Indium.getDust(64) }, + new int[] { 2500, 2500, 2500, 2500 }, + 20 * 20, + (int) TierEU.RECIPE_UV, + 1); + + // Thorium, Uranium, Plutonium + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { Materials.Thorium.getDust(32), Materials.Uranium.getDust(32), + ItemUtils.getSimpleStack(GenericChem.mRadioactivityCatalyst, 0) }, + new FluidStack[] {}, + new FluidStack[] {}, + new ItemStack[] { ELEMENT.getInstance().THORIUM232.getDust(64), + ELEMENT.getInstance().URANIUM233.getDust(64), Materials.Uranium235.getDust(64), + ELEMENT.getInstance().PLUTONIUM238.getDust(64), Materials.Plutonium.getDust(64), + Materials.Plutonium241.getDust(64) }, + new int[] { 1667, 1667, 1667, 1667, 1667, 1667 }, + 20 * 20, + (int) TierEU.RECIPE_UV, + 1); + + // Monaline + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { Materials.Monazite.getDust(32), + ItemUtils.getSimpleStack(GenericChem.mRareEarthGroupCatalyst, 0) }, + new FluidStack[] {}, + new FluidStack[] {}, + new ItemStack[] { Materials.Cerium.getDust(64), Materials.Gadolinium.getDust(64), + Materials.Samarium.getDust(64), getModItem(BartWorks.ID, "gt.bwMetaGenerateddust", 64L, 11002), // Hafnia + getModItem(BartWorks.ID, "gt.bwMetaGenerateddust", 64L, 11007), // Zirconium + ItemList.SuperconductorComposite.get(1) }, + new int[] { 1667, 1667, 1667, 1667, 1667, 1667 }, + 20 * 20, + (int) TierEU.RECIPE_UHV, + 2); + + // Bastline + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { Materials.Bastnasite.getDust(32), + ItemUtils.getSimpleStack(GenericChem.mRareEarthGroupCatalyst, 0) }, + null, + null, + new ItemStack[] { Materials.Holmium.getDust(64), Materials.Cerium.getDust(64), + Materials.Samarium.getDust(64), Materials.Gadolinium.getDust(64), Materials.Lanthanum.getDust(64) }, + new int[] { 2000, 2000, 2000, 2000, 2000 }, + 20 * 20, + (int) TierEU.RECIPE_UHV, + 2); + + // Early Waterline skip (first 4 tiers) + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { ItemUtils.getSimpleStack(GenericChem.mLimpidWaterCatalyst, 0) }, + new FluidStack[] { Materials.Water.getFluid(40000L) }, + new FluidStack[] { Materials.Grade1PurifiedWater.getFluid(20000L), + Materials.Grade2PurifiedWater.getFluid(10000L), Materials.Grade3PurifiedWater.getFluid(5000L), + Materials.Grade4PurifiedWater.getFluid(1000L) }, + new ItemStack[] {}, + new int[] { 2500, 2500, 2500, 2500 }, + 20 * 20, + (int) TierEU.RECIPE_UHV, + 2); + + // Stem Cells + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { Materials.Calcium.getDust(32), Materials.MeatRaw.getDust(32), + getModItem(NewHorizonsCoreMod.ID, "GTNHBioItems", 32, 2), + ItemUtils.getSimpleStack(GenericChem.mRawIntelligenceCatalyst, 0) }, + new FluidStack[] {}, + new FluidStack[] { Materials.GrowthMediumRaw.getFluid(1000 * 1024), + Materials.GrowthMediumSterilized.getFluid(1000 * 512) }, + new ItemStack[] { stemcells }, + new int[] { 3333, 3333, 3333 }, + 20 * 20, + (int) TierEU.RECIPE_UEV, + 3); + + // Unknown Particles + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { ItemUtils.getSimpleStack(GenericChem.mParticleAccelerationCatalyst, 0) }, + new FluidStack[] { Materials.Hydrogen.getGas(10000L), Materials.Deuterium.getGas(1000L) }, + new FluidStack[] { FluidUtils.getFluidStack("plasma.hydrogen", 1000) }, + new ItemStack[] { Particle.getBaseParticle(Particle.UNKNOWN), Particle.getBaseParticle(Particle.GRAVITON), + Particle.getBaseParticle(Particle.PROTON), Particle.getBaseParticle(Particle.ELECTRON) }, + new int[] { 2000, 2000, 2000, 2000, 2000 }, + 5 * 20, + (int) TierEU.RECIPE_UEV, + 3); + + // Lategame Plastics (Missing Radox Polymer and Heavy Radox) + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { Materials.Carbon.getDust(64), Materials.Osmium.getDust(24), + ItemUtils.getSimpleStack(GenericChem.mUltimatePlasticCatalyst, 0) }, + new FluidStack[] { Materials.Hydrogen.getGas(1000 * 16), Materials.Nitrogen.getGas(1000 * 16) }, + new FluidStack[] { FluidUtils.getFluidStack("xenoxene", 1000 * 16), + FluidUtils.getFluidStack("molten.radoxpoly", 144 * 64), + FluidUtils.getFluidStack("heavyradox", 1000 * 16), MaterialsKevlar.Kevlar.getMolten(144 * 64) }, + new ItemStack[] {}, + new int[] { 2500, 2500, 2500, 2500 }, + 20 * 20, + (int) TierEU.RECIPE_UIV, + 4); + + // Lategame Kevlar using Kevlar bee comb + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { GT_Bees.combs.getStackForType(CombType.KEVLAR, 24), Materials.Carbon.getDust(64), + ItemUtils.getSimpleStack(GenericChem.mUltimatePlasticCatalyst, 0) }, + new FluidStack[] { Materials.Nitrogen.getGas(1000 * 16), Materials.Hydrogen.getGas(1000 * 16) }, + new FluidStack[] { MaterialsKevlar.PolyurethaneResin.getFluid(1000 * 32), + MaterialsKevlar.LiquidCrystalKevlar.getFluid(144 * 32), MaterialsKevlar.Kevlar.getMolten(144 * 64) }, + new ItemStack[] {}, + new int[] { 2500, 2500, 2500, 2500 }, + 20 * 20, + (int) TierEU.RECIPE_UIV, + 4); + // Platline skip using Platline Combs (Palladium, Osmium, Iridium, Platinum) + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { GT_Bees.combs.getStackForType(CombType.PLATINUM, 32), + GT_Bees.combs.getStackForType(CombType.PALLADIUM, 32), + GT_Bees.combs.getStackForType(CombType.OSMIUM, 32), GT_Bees.combs.getStackForType(CombType.IRIDIUM, 32), + ItemUtils.getSimpleStack(GenericChem.mPlatinumGroupCatalyst, 0) }, + new FluidStack[] {}, + new FluidStack[] { Materials.Osmium.getMolten(144 * 256), Materials.Palladium.getMolten(144 * 256), + Materials.Iridium.getMolten(144 * 256), Materials.Platinum.getMolten(144 * 256) }, + new ItemStack[] {}, + new int[] { 2500, 2500, 2500, 2500 }, + 20 * 20, + (int) TierEU.RECIPE_UV, + 1); + // Bio Cells and Mutated Solder + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { ItemList.Circuit_Chip_Stemcell.get(16), Materials.InfinityCatalyst.getDust(4), + ItemUtils.getSimpleStack(GenericChem.mBiologicalIntelligenceCatalyst, 0) }, + new FluidStack[] {}, + new FluidStack[] { MISC_MATERIALS.MUTATED_LIVING_SOLDER.getFluidStack(144 * 128), + Materials.BioMediumSterilized.getFluid(1000 * 256), Materials.BioMediumRaw.getFluid(1000 * 512) }, + new ItemStack[] { biocells }, + new int[] { 2500, 2500, 2500, 2500 }, + 20 * 20, + (int) TierEU.RECIPE_UIV, + 4); + + // Advanced Waterline skip (last 4 tiers) + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { ItemUtils.getSimpleStack(GenericChem.mFlawlessWaterCatalyst, 0) }, + new FluidStack[] { Materials.Water.getFluid(40000L) }, + new FluidStack[] { Materials.Grade5PurifiedWater.getFluid(20000L), + Materials.Grade6PurifiedWater.getFluid(10000L), Materials.Grade7PurifiedWater.getFluid(5000L), + Materials.Grade8PurifiedWater.getFluid(1000L) }, + new ItemStack[] {}, + new int[] { 2500, 2500, 2500, 2500 }, + 20 * 20, + (int) TierEU.RECIPE_UIV, + 4); + + // Rare Particles + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { ItemUtils.getSimpleStack(GenericChem.mSynchrotronCapableCatalyst, 0), + GregtechItemList.Laser_Lens_Special.get(1) }, + new FluidStack[] { FluidUtils.getFluidStack("plasma.hydrogen", 30000), Materials.Helium.getPlasma(30000L), + Materials.Americium.getPlasma(30000L), + new FluidStack(ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN.getPlasma(), 30000) }, + new FluidStack[] {}, + new ItemStack[] { Particle.getBaseParticle(Particle.Z_BOSON), Particle.getBaseParticle(Particle.W_BOSON), + Particle.getBaseParticle(Particle.LAMBDA), Particle.getBaseParticle(Particle.OMEGA), + Particle.getBaseParticle(Particle.HIGGS_BOSON) }, + new int[] { 2000, 2000, 2000, 2000, 2000 }, + 200 * 20, + (int) TierEU.RECIPE_UIV, + 4); + + if (GalaxySpace.isModLoaded()) { + // Seaweed + ItemStack seaweed = GT_Utility + .copyAmountUnsafe(64 * 32, getModItem(GalaxySpace.ID, "tcetiedandelions", 1, 4)); + CORE.RA.addQuantumTransformerRecipe( + new ItemStack[] { GT_OreDictUnificator.get("cropSeaweed", 64), Materials.Mytryl.getDust(16), + ItemUtils.getSimpleStack(GenericChem.mAlgagenicGrowthPromoterCatalyst, 0) }, + new FluidStack[] { FluidUtils.getFluidStack("unknowwater", 25_000) }, + new FluidStack[] { FluidUtils.getFluidStack("seaweedbroth", 50_000), + FluidUtils.getFluidStack("iodine", 64_000) }, + new ItemStack[] { seaweed, getModItem(NewHorizonsCoreMod.ID, "item.TCetiESeaweedExtract", 16) }, + new int[] { 2_500, 2_500, 2_500, 2_500 }, + 20 * SECONDS, + (int) TierEU.RECIPE_UIV, + 4); + } + } + + private static void fusionReactorRecipes() { + GT_Values.RA.addFusionReactorRecipe( + new FluidStack[] { Materials.Radon.getPlasma(100), Materials.Nitrogen.getPlasma(100) }, + new FluidStack[] { new FluidStack(ELEMENT.getInstance().NEPTUNIUM.getPlasma(), 100) }, + 30 * 20, + (int) TierEU.RECIPE_UHV, + 1_000_000_000); + + GT_Values.RA.addFusionReactorRecipe( + new FluidStack[] { Materials.Americium.getPlasma(100), Materials.Boron.getPlasma(100) }, + new FluidStack[] { new FluidStack(ELEMENT.getInstance().FERMIUM.getPlasma(), 100) }, + 30 * 20, + (int) TierEU.RECIPE_UHV, + 1_000_000_000); + + // MK5 versions + GT_Values.RA.addFusionReactorRecipe( + new FluidStack[] { new FluidStack(ELEMENT.getInstance().XENON.getPlasma(), 288), + Materials.Yttrium.getMolten(288) }, + new FluidStack[] { new FluidStack(ELEMENT.getInstance().NEPTUNIUM.getPlasma(), 288) }, + 1 * SECONDS + 12 * TICKS, + (int) TierEU.RECIPE_UEV, + 1_000_000_000); + + GT_Values.RA.addFusionReactorRecipe( + new FluidStack[] { new FluidStack(ELEMENT.STANDALONE.FORCE.getPlasma(), 288), + Materials.Rubidium.getMolten(288) }, + new FluidStack[] { new FluidStack(ELEMENT.getInstance().FERMIUM.getPlasma(), 288) }, + 1 * SECONDS + 12 * TICKS, + (int) TierEU.RECIPE_UEV, + 1_000_000_000); + } + + private static void catalystRecipes() { + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), + getModItem(BartWorks.ID, "gt.bwMetaGenerateddust", 64L, 88), Materials.Osmiridium.getDust(64), + Materials.Carbon.getNanite(64) }, + ELEMENT.STANDALONE.HYPOGEN.getFluidStack(360), + ItemUtils.getSimpleStack(GenericChem.mPlatinumGroupCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UEV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), + Materials.Polybenzimidazole.getDust(64), Materials.Polytetrafluoroethylene.getDust(64), + Materials.Carbon.getNanite(64) }, + ELEMENT.STANDALONE.HYPOGEN.getFluidStack(360), + ItemUtils.getSimpleStack(GenericChem.mPlasticPolymerCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UEV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), Materials.Silicone.getDust(64), + Materials.StyreneButadieneRubber.getDust(64), Materials.Carbon.getNanite(64) }, + ELEMENT.STANDALONE.HYPOGEN.getFluidStack(360), + ItemUtils.getSimpleStack(GenericChem.mRubberPolymerCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UEV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), ALLOY.INDALLOY_140.getDust(64), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getCell(64), Materials.Carbon.getNanite(64) }, + ELEMENT.STANDALONE.HYPOGEN.getFluidStack(360), + ItemUtils.getSimpleStack(GenericChem.mAdhesionPromoterCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UHV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), Materials.TungstenSteel.getDust(64), + Materials.Indium.getDust(64), Materials.Carbon.getNanite(64) }, + ELEMENT.STANDALONE.HYPOGEN.getFluidStack(360), + ItemUtils.getSimpleStack(GenericChem.mTitaTungstenIndiumCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UHV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), + ELEMENT.getInstance().URANIUM235.getDust(64), ELEMENT.getInstance().PLUTONIUM241.getDust(64), + Materials.Carbon.getNanite(64) }, + ELEMENT.STANDALONE.HYPOGEN.getFluidStack(360), + ItemUtils.getSimpleStack(GenericChem.mRadioactivityCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UHV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), Materials.Samarium.getDust(64), + Materials.Gadolinium.getDust(64), Materials.Silver.getNanite(1) }, + ELEMENT.STANDALONE.HYPOGEN.getFluidStack(9216), + ItemUtils.getSimpleStack(GenericChem.mRareEarthGroupCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UEV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), + WerkstoffLoader.Hedenbergit.get(OrePrefixes.lens, 1), + GT_OreDictUnificator.get(OrePrefixes.nanite, Materials.Silver, 1, false), + ItemList.Circuit_Silicon_Wafer6.get(64) }, + ELEMENT.STANDALONE.HYPOGEN.getFluidStack(9216), + ItemUtils.getSimpleStack(GenericChem.mLimpidWaterCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UEV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), Materials.Naquadah.getDust(64), + Materials.Adamantium.getDust(64), Materials.Silver.getNanite(1) }, + ELEMENT.STANDALONE.HYPOGEN.getFluidStack(9216), + ItemUtils.getSimpleStack(GenericChem.mSimpleNaquadahCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UEV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), Materials.Naquadria.getDust(64), + Materials.Trinium.getDust(64), Materials.Gold.getNanite(1) }, + MaterialsUEVplus.SpaceTime.getMolten(9216L), + ItemUtils.getSimpleStack(GenericChem.mAdvancedNaquadahCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UIV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), ItemList.Circuit_Chip_Stemcell.get(64), + Materials.Gold.getNanite(1) }, + MaterialsUEVplus.SpaceTime.getMolten(9216L), + ItemUtils.getSimpleStack(GenericChem.mRawIntelligenceCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UIV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), + GregtechItemList.Laser_Lens_Special.get(64), + GT_ModHandler.getModItem(EternalSingularity.ID, "eternal_singularity", 10) }, + MaterialsUEVplus.SpaceTime.getMolten(9216L), + ItemUtils.getSimpleStack(GenericChem.mParticleAccelerationCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UIV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), MaterialsKevlar.Kevlar.getDust(64), + MaterialsUEVplus.TranscendentMetal.getNanite(1) }, + FluidUtils.getFluidStack("molten.shirabon", 92160), + ItemUtils.getSimpleStack(GenericChem.mUltimatePlasticCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UMV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), ItemList.Circuit_Chip_Biocell.get(64), + MaterialsUEVplus.TranscendentMetal.getNanite(1) }, + FluidUtils.getFluidStack("molten.shirabon", 92160), + ItemUtils.getSimpleStack(GenericChem.mBiologicalIntelligenceCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UMV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), + WerkstoffLoader.Hedenbergit.get(OrePrefixes.lens, 64), + GT_OreDictUnificator.get(OrePrefixes.nanite, Materials.Silver, 64, false), + ItemList.Circuit_Silicon_Wafer6.get(64) }, + FluidUtils.getFluidStack("molten.shirabon", 92160), + ItemUtils.getSimpleStack(GenericChem.mFlawlessWaterCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UMV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), + Particle.getBaseParticle(Particle.HIGGS_BOSON), Particle.getIon("Helium", 0), + Particle.getIon("Hydrogen", 0), MaterialsUEVplus.Eternity.getNanite(16) }, + FluidUtils.getFluidStack("molten.shirabon", 92160), + ItemUtils.getSimpleStack(GenericChem.mSynchrotronCapableCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UMV); + + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { CI.getNumberedCircuit(10), CI.getEmptyCatalyst(1), + GT_OreDictUnificator.get("blockShirabon", 16), MaterialsUEVplus.Universium.getNanite(1), + ItemList.Timepiece.get(1) }, + Materials.DarkIron.getMolten(92160), + ItemUtils.getSimpleStack(GenericChem.TemporalHarmonyCatalyst, 1), + 60 * 20, + (int) TierEU.RECIPE_UXV); + + GT_Values.RA.stdBuilder() + .itemInputs( + CI.getNumberedCircuit(10), + CI.getEmptyCatalyst(1), + getModItem(NewHorizonsCoreMod.ID, "item.TCetiESeaweedExtract", 64), + GT_OreDictUnificator.get("dustIodine", 64), + MaterialsUEVplus.TranscendentMetal.getNanite(1)) + .itemOutputs(ItemUtils.getSimpleStack(GenericChem.mAlgagenicGrowthPromoterCatalyst, 1)) + .fluidInputs(FluidUtils.getFluidStack("molten.shirabon", 92_160)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_UMV) + .addTo(assemblerRecipes); + } + + private static void tieredCasingRecipes() { + TT_recipeAdder.addResearchableAssemblylineRecipe( + GregtechItemList.ForceFieldGlass.get(1), + 1024 * 30 * 20, + 1024, + (int) TierEU.RECIPE_ZPM, + 32, + new ItemStack[] { GregtechItemList.ForceFieldGlass.get(1), Materials.Carbon.getNanite(4), + ItemList.Emitter_UV.get(4), + GT_OreDictUnificator.get(OrePrefixes.wireGt16, Materials.SuperconductorUHV, 8), + GregtechItemList.Laser_Lens_Special.get(1), + getModItem(GoodGenerator.ID, "advancedRadiationProtectionPlate", 2) }, + new FluidStack[] { Materials.Thulium.getMolten(144 * 10), MaterialsUEVplus.ExcitedDTCC.getFluid(5000), + new FluidStack(ELEMENT.getInstance().NEPTUNIUM.getPlasma(), 500), + new FluidStack(ELEMENT.getInstance().FERMIUM.getPlasma(), 500) }, + GregtechItemList.NeutronPulseManipulator.get(1), + 60 * 20, + (int) TierEU.RECIPE_UEV); + + TT_recipeAdder.addResearchableAssemblylineRecipe( + GregtechItemList.NeutronPulseManipulator.get(1), + 2048 * 30 * 20, + 2048, + (int) TierEU.RECIPE_UV, + 32, + new ItemStack[] { GregtechItemList.ForceFieldGlass.get(2), Materials.Carbon.getNanite(8), + ItemList.Emitter_UEV.get(4), + GT_OreDictUnificator.get(OrePrefixes.wireGt16, Materials.SuperconductorUEV, 8), + GregtechItemList.Laser_Lens_Special.get(1), + getModItem(GoodGenerator.ID, "advancedRadiationProtectionPlate", 4), ItemList.StableAdhesive.get(4) }, + new FluidStack[] { Materials.Thulium.getMolten(144 * 12), MaterialsUEVplus.ExcitedDTPC.getFluid(5000), + new FluidStack(ELEMENT.getInstance().NEPTUNIUM.getPlasma(), 2500), + new FluidStack(ELEMENT.getInstance().FERMIUM.getPlasma(), 2500) }, + GregtechItemList.CosmicFabricManipulator.get(1), + 75 * 20, + (int) TierEU.RECIPE_UIV); + + TT_recipeAdder.addResearchableAssemblylineRecipe( + GregtechItemList.CosmicFabricManipulator.get(1), + 4096 * 30 * 20, + 4096, + (int) TierEU.RECIPE_ZPM, + 32, + new ItemStack[] { GregtechItemList.ForceFieldGlass.get(4), Materials.Carbon.getNanite(16), + ItemList.Emitter_UIV.get(4), + GT_OreDictUnificator.get(OrePrefixes.wireGt16, Materials.SuperconductorUIV, 8), + GregtechItemList.Laser_Lens_Special.get(1), + getModItem(GoodGenerator.ID, "advancedRadiationProtectionPlate", 8), + ItemList.SuperconductorComposite.get(4) }, + new FluidStack[] { Materials.Thulium.getMolten(144 * 15), MaterialsUEVplus.ExcitedDTRC.getFluid(5000), + new FluidStack(ELEMENT.getInstance().NEPTUNIUM.getPlasma(), 1000 * 10), + new FluidStack(ELEMENT.getInstance().FERMIUM.getPlasma(), 1000 * 10) }, + GregtechItemList.InfinityInfusedManipulator.get(1), + 90 * 20, + (int) TierEU.RECIPE_UMV); + TT_recipeAdder.addResearchableAssemblylineRecipe( + GregtechItemList.InfinityInfusedManipulator.get(1), + 1024 * 30 * 20, + 1024, + (int) TierEU.RECIPE_ZPM, + 32, + new ItemStack[] { GregtechItemList.ForceFieldGlass.get(8), Materials.Carbon.getNanite(32), + ItemList.Emitter_UMV.get(4), + GT_OreDictUnificator.get(OrePrefixes.wireGt16, Materials.SuperconductorUMV, 8), + GregtechItemList.Laser_Lens_Special.get(1), + getModItem(GoodGenerator.ID, "advancedRadiationProtectionPlate", 16), + ItemList.NaquadriaSupersolid.get(4) }, + new FluidStack[] { Materials.Thulium.getMolten(144 * 20), MaterialsUEVplus.ExcitedDTEC.getFluid(5000), + new FluidStack(ELEMENT.getInstance().NEPTUNIUM.getPlasma(), 2000 * 10), + new FluidStack(ELEMENT.getInstance().FERMIUM.getPlasma(), 2000 * 10) }, + GregtechItemList.SpaceTimeContinuumRipper.get(1), + 60 * 20, + (int) TierEU.RECIPE_UXV); + + TT_recipeAdder.addResearchableAssemblylineRecipe( + ItemList.Casing_AdvancedRadiationProof.get(1), + 1024 * 30 * 20, + 1024, + (int) TierEU.RECIPE_ZPM, + 32, + new ItemStack[] { ALLOY.QUANTUM.getFrameBox(1), + GT_OreDictUnificator.get("plateDensePreciousMetalsAlloy", 4), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Neutronium, 16), + ItemList.Field_Generator_UV.get(1), ELEMENT.STANDALONE.CHRONOMATIC_GLASS.getScrew(16) }, + new FluidStack[] { MISC_MATERIALS.MUTATED_LIVING_SOLDER.getFluidStack(144 * 10), }, + GregtechItemList.NeutronShieldingCore.get(1), + 60 * 20, + (int) TierEU.RECIPE_UEV); + + TT_recipeAdder.addResearchableAssemblylineRecipe( + GregtechItemList.NeutronShieldingCore.get(1), + 2048 * 30 * 20, + 2048, + (int) TierEU.RECIPE_UV, + 32, + new ItemStack[] { ALLOY.QUANTUM.getFrameBox(2), + GT_OreDictUnificator.get("plateDenseEnrichedNaquadahAlloy", 4), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Infinity, 16), + ItemList.Field_Generator_UEV.get(1), + // Radox polymer screw. + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.get("RadoxPoly"), 16), + ItemList.StableAdhesive.get(4) }, + new FluidStack[] { MISC_MATERIALS.MUTATED_LIVING_SOLDER.getFluidStack(144 * 20), }, + GregtechItemList.CosmicFabricShieldingCore.get(1), + 75 * 20, + (int) TierEU.RECIPE_UIV); + + TT_recipeAdder.addResearchableAssemblylineRecipe( + GregtechItemList.CosmicFabricShieldingCore.get(1), + 4096 * 30 * 20, + 4096, + (int) TierEU.RECIPE_UHV, + 32, + new ItemStack[] { ALLOY.QUANTUM.getFrameBox(4), ELEMENT.STANDALONE.HYPOGEN.getPlateDense(4), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 16), + ItemList.Field_Generator_UIV.get(1), GT_OreDictUnificator.get("screwMetastableOganesson", 16), + ItemList.SuperconductorComposite.get(4) }, + new FluidStack[] { MISC_MATERIALS.MUTATED_LIVING_SOLDER.getFluidStack(144 * 40), }, + GregtechItemList.InfinityInfusedShieldingCore.get(1), + 90 * 20, + (int) TierEU.RECIPE_UMV); + + TT_recipeAdder.addResearchableAssemblylineRecipe( + GregtechItemList.InfinityInfusedShieldingCore.get(1), + 8192 * 30 * 20, + 8192, + (int) TierEU.RECIPE_UEV, + 32, + new ItemStack[] { ALLOY.QUANTUM.getFrameBox(8), GT_OreDictUnificator.get("plateDenseShirabon", 4), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 16), + ItemList.Field_Generator_UMV.get(1), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Dilithium, 16), + ItemList.NaquadriaSupersolid.get(4) }, + new FluidStack[] { MISC_MATERIALS.MUTATED_LIVING_SOLDER.getFluidStack(144 * 80), }, + GregtechItemList.SpaceTimeBendingCore.get(1), + 120 * 20, + (int) TierEU.RECIPE_UXV); + + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { new ItemStack(QuantumGlassBlock.INSTANCE, 1), ItemList.Field_Generator_ZPM.get(1), + ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN.getLongRod(6), ELEMENT.STANDALONE.CHRONOMATIC_GLASS.getPlate(6) }, + ALLOY.QUANTUM.getFluidStack(144 * 6), + GregtechItemList.ForceFieldGlass.get(1), + 10 * 20, + (int) TierEU.RECIPE_UEV); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_GTNH.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_GTNH.java new file mode 100644 index 0000000000..4aa13a0072 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_GTNH.java @@ -0,0 +1,45 @@ +package gtPlusPlus.xmod.gregtech.loaders.recipe; + +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gtPlusPlus.core.material.ELEMENT; + +public class RecipeLoader_GTNH { + + public static void generate() { + GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Ball.get(0L), + new FluidStack(FluidRegistry.getFluid("ender"), 250), + new ItemStack(Items.ender_pearl, 1, 0), + 100, + 30); + // MK4 + GT_Values.RA.addFusionReactorRecipe( + Materials.Plutonium241.getMolten(144), + Materials.Helium.getGas(1000), + ELEMENT.getInstance().CURIUM.getFluidStack(144), + 96, + 98304, + 500000000); + GT_Values.RA.addFusionReactorRecipe( + ELEMENT.getInstance().CURIUM.getFluidStack(144), + Materials.Helium.getPlasma(144), + ELEMENT.getInstance().CALIFORNIUM.getFluidStack(144), + 128, + 196608, + 750000000); + GT_Values.RA.addFusionReactorRecipe( + Materials.Plutonium241.getMolten(144), + Materials.Calcium.getPlasma(144), + Materials.Flerovium.getMolten(144), + 160, + 196608, + 1000000000); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_GlueLine.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_GlueLine.java new file mode 100644 index 0000000000..a954711fd2 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_GlueLine.java @@ -0,0 +1,395 @@ +package gtPlusPlus.xmod.gregtech.loaders.recipe; + +import static gregtech.api.enums.Mods.BartWorks; +import static gregtech.api.enums.Mods.GalacticraftCore; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.enums.Mods.TecTech; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; + +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.core.item.ModItems; +import gtPlusPlus.core.item.chemistry.AgriculturalChem; +import gtPlusPlus.core.item.chemistry.GenericChem; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.MISC_MATERIALS; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; +import gtPlusPlus.plugin.agrichem.BioRecipes; + +public class RecipeLoader_GlueLine { + + public static void generate() { + createRecipes(); + } + + private static void createRecipes() { + chemicalPlantRecipes(); + chemicalReactorRecipes(); + dehydratorRecipes(); + distillationTowerRecipes(); + fluidHeaterRecipes(); + mixerRecipes(); + + glueUsageRecipes(); + } + + private static void chemicalPlantRecipes() { + // CO + C3H6O2 = C4H6O3 + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getNumberedCircuit(17), ItemUtils.getSimpleStack(GenericChem.mBlueCatalyst, 0) }, + new FluidStack[] { FluidUtils.getFluidStack("carbonmonoxide", 1000), + FluidUtils.getFluidStack("methylacetate", 1000), }, + new ItemStack[] {}, + new FluidStack[] { MISC_MATERIALS.ACETIC_ANHYDRIDE.getFluidStack(1000) }, + 10 * 20, + 500, + 3); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getNumberedCircuit(18) }, + new FluidStack[] { FluidUtils.getFluidStack("aceticacid", 1000), FluidUtils.getFluidStack("chlorine", 1000), + MISC_MATERIALS.ACETIC_ANHYDRIDE.getFluidStack(1000) }, + new ItemStack[] {}, + new FluidStack[] { MISC_MATERIALS.CHLOROACETIC_MIXTURE.getFluidStack(1000), + MISC_MATERIALS.ACETIC_ANHYDRIDE.getFluidStack(950) }, + 150 * 20, + 1000, + 4); + + // Na2CO3 + NaCN + C2H3O2Cl + 2HCl = C3H3NO2 + 3NaCl + CO2 + H2O + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getNumberedCircuit(19), ItemUtils.getSimpleStack(AgriculturalChem.mSodiumCarbonate, 6), + MISC_MATERIALS.SODIUM_CYANIDE.getDust(3) }, + new FluidStack[] { MISC_MATERIALS.CHLOROACETIC_ACID.getFluidStack(1000), + FluidUtils.getFluidStack("hydrochloricacid_gt5u", 2000) }, + new ItemStack[] { MISC_MATERIALS.CYANOACETIC_ACID.getDust(9), Materials.Salt.getDust(6) }, + new FluidStack[] { Materials.CarbonDioxide.getGas(1000), GT_ModHandler.getWater(1000) }, + 20 * 20, + 1000, + 4); + + // CuSO4 + 5C3H3NO2 + 5C2H6O = CuSO4·5(H2O) + 5C5H7NO2 + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getNumberedCircuit(20), ItemUtils.getSimpleStack(GenericChem.mSolidAcidCatalyst, 0), + MISC_MATERIALS.COPPER_SULFATE.getDust(6), MISC_MATERIALS.CYANOACETIC_ACID.getDust(45) }, + new FluidStack[] { Materials.Ethanol.getFluid(5000) }, + new ItemStack[] { MISC_MATERIALS.COPPER_SULFATE_HYDRATED.getDust(11) }, + new FluidStack[] { MISC_MATERIALS.ETHYL_CYANOACETATE.getFluidStack(5000) }, + 500 * 20, + 6000, + 5); + + // C3H3NO2 + C2H6O = C5H7NO2 + H2O + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getNumberedCircuit(21), MISC_MATERIALS.CYANOACETIC_ACID.getDust(9) }, + new FluidStack[] { Materials.Ethanol.getFluid(1000) }, + new ItemStack[] {}, + new FluidStack[] { MISC_MATERIALS.ETHYL_CYANOACETATE.getFluidStack(1000) }, + 1000 * 20, + 6000, + 5); + + BioRecipes.mFormaldehyde = FluidUtils.getFluidStack("fluid.formaldehyde", 1) + .getFluid(); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getNumberedCircuit(22), ItemUtils.getSimpleStack(GenericChem.mSolidAcidCatalyst, 0) }, + new FluidStack[] { MISC_MATERIALS.ETHYL_CYANOACETATE.getFluidStack(100), + FluidUtils.getFluidStack(BioRecipes.mFormaldehyde, 100) }, + new ItemStack[] {}, + new FluidStack[] { MISC_MATERIALS.CYANOACRYLATE_POLYMER.getFluidStack(100), FluidUtils.getWater(1000) }, + 10 * 20, + 8000, + 5); + + // CH4 + NH3 + 3O = HCN + 3H2O + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getNumberedCircuit(23), ItemUtils.getSimpleStack(GenericChem.mPinkCatalyst, 0) }, + new FluidStack[] { FluidUtils.getFluidStack("methane", 2000), FluidUtils.getFluidStack("ammonia", 2000), + FluidUtils.getFluidStack("oxygen", 6000) }, + new ItemStack[] {}, + new FluidStack[] { MISC_MATERIALS.HYDROGEN_CYANIDE.getFluidStack(2000), FluidUtils.getWater(6000) }, + 10 * 20, + 500, + 3); + } + + private static void chemicalReactorRecipes() { + // NaOH + HCN = NaCN + H2O + GT_Values.RA.addChemicalRecipe( + CI.getNumberedCircuit(17), + ItemUtils.getItemStackOfAmountFromOreDict("dustSodiumHydroxide", 3), + MISC_MATERIALS.HYDROGEN_CYANIDE.getFluidStack(1000), + FluidUtils.getWater(1000), + MISC_MATERIALS.SODIUM_CYANIDE.getDust(3), + 10 * 20); + // #addChemicalRecipe won't generate LCR recipe if config >= 10 + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { CI.getNumberedCircuit(17), + ItemUtils.getItemStackOfAmountFromOreDict("dustSodiumHydroxide", 3) }, + new FluidStack[] { MISC_MATERIALS.HYDROGEN_CYANIDE.getFluidStack(1000) }, + new FluidStack[] { FluidUtils.getWater(1000) }, + new ItemStack[] { MISC_MATERIALS.SODIUM_CYANIDE.getDust(3) }, + 10 * 20, + 30); + + // CaCO3 + 2HCl = CaCl2 + CO2 + H2O + if (BartWorks.isModLoaded()) { + GT_Values.RA.stdBuilder() + .itemInputs( + ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 5), + GT_Utility.getIntegratedCircuit(8)) + .itemOutputs(ItemUtils.getItemStackFromFQRN("bartworks:gt.bwMetaGenerateddust:63", 3)) + .fluidInputs(Materials.HydrochloricAcid.getFluid(2000L)) + .fluidOutputs(Materials.CarbonDioxide.getGas(1000)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + } else { + GT_Values.RA.stdBuilder() + .itemInputs( + ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 5), + GT_Utility.getIntegratedCircuit(8)) + .itemOutputs(MISC_MATERIALS.CALCIUM_CHLORIDE.getDust(3)) + .fluidInputs(Materials.HydrochloricAcid.getFluid(2000L)) + .fluidOutputs(Materials.CarbonDioxide.getGas(1000)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + } + + // Cu + 2H2SO4 = CuSO4 + SO2 + 2H2O + // SO2 + 2H2O -> diluted sulfuric acid + GT_Values.RA.addChemicalRecipe( + CI.getNumberedCircuit(19), + ItemUtils.getItemStackOfAmountFromOreDict("dustCopper", 1), + FluidUtils.getFluidStack("sulfuricacid", 2000), + FluidUtils.getFluidStack("dilutedsulfuricacid", 1000), + MISC_MATERIALS.COPPER_SULFATE.getDust(6), + 5 * 20); + // #addChemicalRecipe won't generate LCR recipe if config >= 10 + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { CI.getNumberedCircuit(19), ItemUtils.getItemStackOfAmountFromOreDict("dustCopper", 1) }, + new FluidStack[] { FluidUtils.getFluidStack("sulfuricacid", 2000) }, + new FluidStack[] { FluidUtils.getFluidStack("dilutedsulfuricacid", 1000) }, + new ItemStack[] { MISC_MATERIALS.COPPER_SULFATE.getDust(6) }, + 5 * 20, + 30); + } + + private static void dehydratorRecipes() { + CORE.RA.addDehydratorRecipe( + new ItemStack[] { MISC_MATERIALS.COPPER_SULFATE_HYDRATED.getDust(11), }, + null, + GT_ModHandler.getWater(5000), + new ItemStack[] { MISC_MATERIALS.COPPER_SULFATE.getDust(6) }, + new int[] { 10000, 10000, 10000 }, + 300 * 20, + 10); + } + + private static void distillationTowerRecipes() { + GT_Values.RA.addDistillationTowerRecipe( + MISC_MATERIALS.CHLOROACETIC_MIXTURE.getFluidStack(1000), + new FluidStack[] { MISC_MATERIALS.CHLOROACETIC_ACID.getFluidStack(100), + MISC_MATERIALS.DICHLOROACETIC_ACID.getFluidStack(450), + MISC_MATERIALS.TRICHLOROACETIC_ACID.getFluidStack(450) }, + null, + 4 * 20, + MaterialUtils.getVoltageForTier(5)); + } + + private static void fluidHeaterRecipes() { + + CORE.RA.addFluidHeaterRecipe( + CI.getNumberedCircuit(16), + MISC_MATERIALS.CYANOACRYLATE_POLYMER.getFluidStack(100), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(100), + 30 * 30, + 500); + } + + private static void mixerRecipes() { + GT_Values.RA.addMixerRecipe( + CI.getNumberedCircuit(1), + MISC_MATERIALS.DICHLOROACETIC_ACID.getCell(1), + null, + null, + MISC_MATERIALS.TRICHLOROACETIC_ACID.getFluidStack(1000), + MISC_MATERIALS.CHLOROACETIC_MIXTURE.getFluidStack(2000), + CI.emptyCells(1), + 100, + 100); + + GT_Values.RA.addMixerRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("cellSulfurTrioxide", 1), + CI.getNumberedCircuit(2), + null, + null, + FluidUtils.getFluidStack("sulfuricacid", 1000), + MISC_MATERIALS.SOLID_ACID_MIXTURE.getFluidStack(1000), + CI.emptyCells(1), + 100, + 40); + } + + private static void glueUsageRecipes() { + // Braintech Tape recipe, PBI and superglue make 16 tape at once + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Polybenzimidazole, 1L), + GT_ModHandler.getIC2Item("carbonMesh", 1L), CI.getNumberedCircuit(10) }, + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(100), + ItemList.Duct_Tape.get(16L), + 120, + 30); + + // Maintenance Hatch recipe, using Braintech Tape + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { ItemList.Hull_LV.get(1), ItemList.Duct_Tape.get(1), CI.getNumberedCircuit(1) }, + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(100), + ItemList.Hatch_Maintenance.get(1), + 120, + 30); + + // Graphene recipes from later wafer tiers, using superglue instead of the bronze age glue + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustGraphite", 64), + ItemList.Circuit_Silicon_Wafer4.get(2L), CI.getNumberedCircuit(2) }, + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(500), + ItemUtils.getItemStackOfAmountFromOreDict("dustGraphene", 64), + 400, + 30720); + + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustGraphite", 64), + ItemList.Circuit_Silicon_Wafer5.get(1L), CI.getNumberedCircuit(2) }, + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(250), + ItemUtils.getItemStackOfAmountFromOreDict("dustGraphene", 64), + 80, + 122880); + + GT_Values.RA.addMixerRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sulfur, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lithium, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 4L), + GT_Values.NI, + GT_Values.NI, + GT_Utility.getIntegratedCircuit(1), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(100), + null, + ItemList.SFMixture.get(32), + 1600, + 16); + + GT_Values.RA.addMixerRecipe( + ItemList.GelledToluene.get(1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Aluminium, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Polybenzimidazole, 1L), + GT_Values.NI, + GT_Values.NI, + GT_Utility.getIntegratedCircuit(1), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(100), + null, + ItemList.SFMixture.get(64), + 1600, + 16); + + GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.PolyvinylChloride, 8), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Paper, 32), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(200), + new ItemStack(Items.book, 64, 0), + 32, + 8); + + if (TecTech.isModLoaded()) { + GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Naquadah, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.RedSteel, 18), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(144), + ItemUtils.getItemStackFromFQRN("gregtech:gt.metaitem.01:32505", 1), + 300, + 7680); + + GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.NaquadahAlloy, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Europium, 6), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(288), + ItemUtils.getItemStackFromFQRN("gregtech:gt.metaitem.01:32506", 1), + 200, + 30720); + + GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.ElectrumFlux, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Americium, 18), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(576), + ItemUtils.getItemStackFromFQRN("gregtech:gt.metaitem.01:32507", 1), + 300, + 122880); + + GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get(OrePrefixes.cableGt02, Materials.ElectrumFlux, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Naquadah, 24), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(1152), + ItemUtils.getItemStackFromFQRN("gregtech:gt.metaitem.01:32561", 1), + 100, + 491520); + + GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.ElectrumFlux, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahEnriched, 36), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(2304), + ItemUtils.getItemStackFromFQRN("gregtech:gt.metaitem.01:32562", 1), + 200, + 1966080); + + GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get(OrePrefixes.cableGt08, Materials.ElectrumFlux, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahAlloy, 48), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(4608), + ItemUtils.getItemStackFromFQRN("gregtech:gt.metaitem.01:32563", 1), + 300, + 1966080); + + GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get(OrePrefixes.wireGt16, Materials.SuperconductorUHV, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Neutronium, 56), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(9216), + ItemUtils.getItemStackFromFQRN("gregtech:gt.metaitem.01:32564", 1), + 600, + 1966080); + + GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get(OrePrefixes.wireGt16, Materials.SuperconductorUHV, 2), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.DraconiumAwakened, 64), + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(18432), + ItemUtils.getItemStackFromFQRN("gregtech:gt.metaitem.01:32565", 1), + 1200, + 1966080); + } + if (NewHorizonsCoreMod.isModLoaded() && GalacticraftCore.isModLoaded()) { + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { ItemUtils.getItemStackFromFQRN("GalacticraftMars:item.itemBasicAsteroids:7", 1), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Titanium, 8), + ItemUtils.getItemStackFromFQRN("dreamcraft:item.TungstenString", 8), CI.getNumberedCircuit(1) }, + MISC_MATERIALS.ETHYL_CYANOACRYLATE.getFluidStack(576), + ItemUtils.getItemStackFromFQRN("GalaxySpace:item.ThermalClothT2", 1), + 600, + 1024); + } + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_LFTR.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_LFTR.java new file mode 100644 index 0000000000..81fde457ae --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_LFTR.java @@ -0,0 +1,135 @@ +package gtPlusPlus.xmod.gregtech.loaders.recipe; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.Materials; +import gregtech.api.util.GasSpargingRecipeMap; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.api.recipe.GTPPRecipeMaps; +import gtPlusPlus.core.material.ELEMENT; +import gtPlusPlus.core.material.nuclear.FLUORIDES; +import gtPlusPlus.core.material.nuclear.NUCLIDE; + +public class RecipeLoader_LFTR { + + private static AutoMap<Fluid> mNobleGases; + private static AutoMap<Fluid> mFluorideGases; + private static AutoMap<Fluid> mSpargeGases; + + private static void configureSparging() { + if (mSpargeGases == null) { + mSpargeGases = new AutoMap<>(); + mSpargeGases.add( + Materials.Helium.getGas(1) + .getFluid()); + mSpargeGases.add( + Materials.Fluorine.getGas(1) + .getFluid()); + } + if (mNobleGases == null) { + mNobleGases = new AutoMap<>(); + mNobleGases.add(mSpargeGases.get(0)); + mNobleGases.add(ELEMENT.getInstance().XENON.getFluid()); + mNobleGases.add(ELEMENT.getInstance().NEON.getFluid()); + mNobleGases.add(ELEMENT.getInstance().ARGON.getFluid()); + mNobleGases.add(ELEMENT.getInstance().KRYPTON.getFluid()); + mNobleGases.add(ELEMENT.getInstance().RADON.getFluid()); + } + if (mFluorideGases == null) { + mFluorideGases = new AutoMap<>(); + mFluorideGases.add(mSpargeGases.get(1)); + mFluorideGases.add(FLUORIDES.LITHIUM_FLUORIDE.getFluid()); + mFluorideGases.add(FLUORIDES.NEPTUNIUM_HEXAFLUORIDE.getFluid()); + mFluorideGases.add(FLUORIDES.TECHNETIUM_HEXAFLUORIDE.getFluid()); + mFluorideGases.add(FLUORIDES.SELENIUM_HEXAFLUORIDE.getFluid()); + mFluorideGases.add(FLUORIDES.THORIUM_TETRAFLUORIDE.getFluid()); + } + } + + public static void generate() { + // Fli2BeF4 + Thorium TetraFluoride = Uranium233 + // 72k Ticks/hr + // 1l/4t = 1000l/hr + // 1l/40t = 1000l/10hr (Probably better) LiFBeF2ThF4UF4 + // 1l/20t= 1000l/2.5hr LiFBeF2ZrF4UF4 + // 1l/10t= 1000l/2.5hr LiFBeF2ZrF4U235 + + configureSparging(); + FluidStack Li2BeF4 = NUCLIDE.Li2BeF4.getFluidStack(200); + + // LiFBeF2ThF4UF4 - T3 + GTPPRecipeMaps.liquidFluorineThoriumReactorRecipes.addRecipe( + false, + new ItemStack[] {}, + new ItemStack[] {}, + null, + new int[] { 10000, 10000, 5000, 2500 }, + new FluidStack[] { NUCLIDE.LiFBeF2ThF4UF4.getFluidStack(100), Li2BeF4 }, + new FluidStack[] { NUCLIDE.LiFBeF2UF4FP.getFluidStack(100), NUCLIDE.LiFBeF2ThF4.getFluidStack(200), + FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(20), FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(10) }, + 100 * 20, // time + 0, // cost + 32768 * 4 // fuel value + ); + + // LiFBeF2ZrF4UF4 - T2 + GTPPRecipeMaps.liquidFluorineThoriumReactorRecipes.addRecipe( + false, + new ItemStack[] {}, + new ItemStack[] {}, + null, + new int[] { 10000, 10000, 2500, 1250 }, + new FluidStack[] { NUCLIDE.LiFBeF2ZrF4UF4.getFluidStack(100), Li2BeF4 }, + new FluidStack[] { NUCLIDE.LiFBeF2UF4FP.getFluidStack(50), NUCLIDE.LiFBeF2ThF4.getFluidStack(100), + FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(10), FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(5) }, + 100 * 20, // time + 0, // cost + 8192 * 4 // fuel value + ); + + // LiFBeF2ZrF4U235 - T1 + GTPPRecipeMaps.liquidFluorineThoriumReactorRecipes.addRecipe( + false, + new ItemStack[] {}, + new ItemStack[] {}, + null, + new int[] { 10000, 10000, 1000, 500 }, + new FluidStack[] { NUCLIDE.LiFBeF2ZrF4U235.getFluidStack(100), Li2BeF4 }, + new FluidStack[] { NUCLIDE.LiFBeF2UF4FP.getFluidStack(25), NUCLIDE.LiFThF4.getFluidStack(50), + FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(4), FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(2) }, + 100 * 20, // time + 0, // cost + 8192 // fuel value + ); + + // Sparging NEI Recipes + GasSpargingRecipeMap.addRecipe( + new FluidStack(mSpargeGases.get(0), 1000), + NUCLIDE.LiFBeF2UF4FP.getFluidStack(50), + NUCLIDE.Sparged_LiFBeF2UF4FP.getFluidStack(50), + new FluidStack[] { new FluidStack(mNobleGases.get(1), 10), new FluidStack(mNobleGases.get(2), 10), + new FluidStack(mNobleGases.get(3), 10), new FluidStack(mNobleGases.get(4), 10), + new FluidStack(mNobleGases.get(5), 10) }, + new int[] { 20000, 20000, 20000, 20000, 20000 }); + + GasSpargingRecipeMap.addRecipe( + new FluidStack(mSpargeGases.get(1), 100), + NUCLIDE.LiFThF4.getFluidStack(50), + NUCLIDE.Sparged_LiFThF4.getFluidStack(50), + new FluidStack[] { new FluidStack(mFluorideGases.get(1), 5), new FluidStack(mFluorideGases.get(2), 5), + new FluidStack(mFluorideGases.get(3), 5), new FluidStack(mFluorideGases.get(4), 5), + new FluidStack(mFluorideGases.get(5), 5) }, + new int[] { 1000, 1000, 1000, 1000, 1000 }); + + GasSpargingRecipeMap.addRecipe( + new FluidStack(mSpargeGases.get(1), 100), + NUCLIDE.LiFBeF2ThF4.getFluidStack(50), + NUCLIDE.Sparged_LiFBeF2ThF4.getFluidStack(50), + new FluidStack[] { new FluidStack(mFluorideGases.get(1), 10), new FluidStack(mFluorideGases.get(2), 10), + new FluidStack(mFluorideGases.get(3), 10), new FluidStack(mFluorideGases.get(4), 10), + new FluidStack(mFluorideGases.get(5), 10) }, + new int[] { 2000, 2000, 2000, 2000, 2000 }); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_MolecularTransformer.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_MolecularTransformer.java new file mode 100644 index 0000000000..cd576dbc8d --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_MolecularTransformer.java @@ -0,0 +1,78 @@ +package gtPlusPlus.xmod.gregtech.loaders.recipe; + +import static advsolar.utils.MTRecipeManager.transformerRecipes; +import static gregtech.api.enums.Mods.AdvancedSolarPanel; +import static gregtech.api.enums.Mods.GalaxySpace; + +import advsolar.utils.MTRecipeRecord; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.math.MathUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; + +public class RecipeLoader_MolecularTransformer { + + public static void run() { + + for (MTRecipeRecord aRecipe : transformerRecipes) { + int aEU = MaterialUtils.getVoltageForTier(5); + Logger.INFO("======================="); + Logger.INFO("Generating GT recipe for Molecular Transformer."); + Logger.INFO( + "Input: " + aRecipe.inputStack + .getDisplayName() + ", Output: " + aRecipe.outputStack.getDisplayName() + ", EU/t: " + aEU); + float aTicks = (float) aRecipe.energyPerOperation / (float) aEU; + Logger.INFO("Ticks: " + aTicks); + int aTicksRoundedUp = MathUtils.roundToClosestInt(Math.ceil(aTicks)); + Logger.INFO("Ticks: " + aTicksRoundedUp); + Logger.INFO("Total EU equal or greater? " + ((aTicksRoundedUp * aEU) >= aRecipe.energyPerOperation)); + CORE.RA.addMolecularTransformerRecipe(aRecipe.inputStack, aRecipe.outputStack, aTicksRoundedUp, aEU, 2); + Logger.INFO("======================="); + } + + transformerRecipes.clear(); + if (AdvancedSolarPanel.isModLoaded() && GalaxySpace.isModLoaded()) { + + CORE.RA.addMolecularTransformerRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Glowstone, 1L), + GT_ModHandler.getModItem(AdvancedSolarPanel.ID, "asp_crafting_items", 1L, 9), + 600, + 1920, + 2); + CORE.RA.addMolecularTransformerRecipe( + GT_ModHandler.getModItem(GalaxySpace.ID, "item.GlowstoneDusts", 1L, 0), + GT_ModHandler.getModItem(AdvancedSolarPanel.ID, "asp_crafting_items", 1L, 9), + 150, + 7680, + 2); + CORE.RA.addMolecularTransformerRecipe( + GT_ModHandler.getModItem(GalaxySpace.ID, "item.GlowstoneDusts", 1L, 1), + GT_ModHandler.getModItem(AdvancedSolarPanel.ID, "asp_crafting_items", 1L, 9), + 38, + 30720, + 2); + CORE.RA.addMolecularTransformerRecipe( + GT_ModHandler.getModItem(GalaxySpace.ID, "item.GlowstoneDusts", 1L, 2), + GT_ModHandler.getModItem(AdvancedSolarPanel.ID, "asp_crafting_items", 1L, 9), + 10, + 122880, + 2); + CORE.RA.addMolecularTransformerRecipe( + GT_ModHandler.getModItem(GalaxySpace.ID, "item.GlowstoneDusts", 1L, 3), + GT_ModHandler.getModItem(AdvancedSolarPanel.ID, "asp_crafting_items", 1L, 9), + 3, + 491520, + 2); + CORE.RA.addMolecularTransformerRecipe( + GT_ModHandler.getModItem(GalaxySpace.ID, "item.GlowstoneDusts", 1L, 4), + GT_ModHandler.getModItem(AdvancedSolarPanel.ID, "asp_crafting_items", 1L, 9), + 1, + 1996080, + 2); + } + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_Nuclear.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_Nuclear.java new file mode 100644 index 0000000000..a25ed99dd2 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_Nuclear.java @@ -0,0 +1,680 @@ +package gtPlusPlus.xmod.gregtech.loaders.recipe; + +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.fusionRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.FUSION_THRESHOLD; +import static gtPlusPlus.api.recipe.GTPPRecipeMaps.chemicalDehydratorRecipes; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.item.chemistry.GenericChem; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.ALLOY; +import gtPlusPlus.core.material.ELEMENT; +import gtPlusPlus.core.material.MISC_MATERIALS; +import gtPlusPlus.core.material.nuclear.FLUORIDES; +import gtPlusPlus.core.material.nuclear.NUCLIDE; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class RecipeLoader_Nuclear { + + public static void generate() { + createRecipes(); + RecipeLoader_LFTR.generate(); + RecipeLoader_NuclearFuelProcessing.generate(); + } + + private static void createRecipes() { + autoclave(); + blastFurnace(); + centrifugeRecipes(); + chemicalBathRecipes(); + chemicalReactorRecipes(); + dehydratorRecipes(); + electroMagneticSeperator(); + fluidExtractorRecipes(); + fluidHeater(); + fusionChainRecipes(); + macerator(); + mixerRecipes(); + sifter(); + } + + private static void autoclave() { + + GT_Values.RA.addAutoclaveRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 9), + FluidUtils.getFluidStack("chlorine", 9 * 4 * 144), + ItemUtils.getItemStackOfAmountFromOreDict("pelletZirconium", 9), + 0, + 120 * 20, + 30); + } + + private static void blastFurnace() { + + GT_Values.RA.addBlastRecipe( + FLUORIDES.LITHIUM_FLUORIDE.getDust(2), + FLUORIDES.BERYLLIUM_FLUORIDE.getDust(1), + GT_Values.NF, + GT_Values.NF, + NUCLIDE.Li2BeF4.getDust(3), + null, + 60 * 20, + 2000, + 3000); + + GT_Values.RA.addBlastRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("dustZrCl4", 1), + null, + GT_Values.NF, + GT_Values.NF, + ItemUtils.getItemStackOfAmountFromOreDict("dustCookedZrCl4", 1), + null, + 60 * 20, + 340, + 300); + } + + private static void centrifugeRecipes() { + + // Process Used Fuel Rods for Krypton + + // Uranium + for (ItemStack depletedRod : new ItemStack[] { + ItemUtils.getItemStackFromFQRN("IC2:reactorUraniumSimpledepleted", 8), + ItemUtils.getItemStackFromFQRN("IC2:reactorUraniumDualdepleted", 4), + ItemUtils.getItemStackFromFQRN("IC2:reactorUraniumQuaddepleted", 2) }) { + GT_Values.RA.stdBuilder() + .itemInputs(depletedRod, GT_Utility.getIntegratedCircuit(20)) + .itemOutputs( + ItemList.IC2_Fuel_Rod_Empty.get(8), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Uranium, 2L), + ELEMENT.getInstance().URANIUM232.getSmallDust(1), + ELEMENT.getInstance().URANIUM233.getSmallDust(1), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Uranium235, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Plutonium, 1L)) + .outputChances(10000, 10000, 1000, 1000, 1000, 500) + .fluidOutputs(FluidUtils.getFluidStack("krypton", 60)) + .duration(4 * MINUTES + 10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(centrifugeRecipes); + } + + // Mox + for (ItemStack depletedRod : new ItemStack[] { + ItemUtils.getItemStackFromFQRN("IC2:reactorMOXSimpledepleted", 8), + ItemUtils.getItemStackFromFQRN("IC2:reactorMOXDualdepleted", 4), + ItemUtils.getItemStackFromFQRN("IC2:reactorMOXQuaddepleted", 2) }) { + GT_Values.RA.stdBuilder() + .itemInputs(depletedRod, GT_Utility.getIntegratedCircuit(20)) + .itemOutputs( + ItemList.IC2_Fuel_Rod_Empty.get(8), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Plutonium, 2L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Plutonium241, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Plutonium, 1L), + ELEMENT.getInstance().PLUTONIUM238.getTinyDust(1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Plutonium, 1L)) + .outputChances(10000, 10000, 500, 500, 500, 500) + .fluidOutputs(FluidUtils.getFluidStack("krypton", 90)) + .duration(6 * MINUTES + 15 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(centrifugeRecipes); + } + + // Thorium + for (ItemStack depletedRod : new ItemStack[] { ItemList.Depleted_Thorium_1.get(8), + ItemList.Depleted_Thorium_2.get(4), ItemList.Depleted_Thorium_4.get(2) }) { + GT_Values.RA.stdBuilder() + .itemInputs(depletedRod, GT_Utility.getIntegratedCircuit(20)) + .itemOutputs( + ItemList.IC2_Fuel_Rod_Empty.get(8), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Thorium, 2L), + ELEMENT.getInstance().THORIUM232.getDust(1), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Lutetium, 1L), + ELEMENT.getInstance().POLONIUM.getSmallDust(1), + ELEMENT.getInstance().THALLIUM.getTinyDust(1)) + .outputChances(10000, 10000, 5000, 5000, 5000, 2500) + .fluidOutputs(FluidUtils.getFluidStack("krypton", 30)) + .duration(2 * MINUTES + 5 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(centrifugeRecipes); + } + } + + private static void chemicalBathRecipes() { + + int[] chances = { 9000, 6000, 3000 }; + GT_Values.RA.addChemicalBathRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("dustTin", 12), + FluidUtils.getFluidStack("chlorine", 2400), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 3), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 4), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 5), + chances, + 30 * 20, + 480); + + chances = new int[] { 9000, 3000, 1000 }; + GT_Values.RA.addChemicalBathRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("dustRutile", 5), + FluidUtils.getFluidStack("chlorine", 4000), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 3), + ItemUtils.getItemStackOfAmountFromOreDict("dustTitanium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustHafnium", 1), + chances, + 30 * 20, + 1024); + + GT_Values.RA.addChemicalBathRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumCarbonate", 10), + FluidUtils.getFluidStack("hydrofluoricacid", 10 * 144), + ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumFluoride", 10), + null, + null, + new int[] {}, + 90 * 20, + 500); + } + + private static void chemicalReactorRecipes() { + + ItemStack aGtHydrofluoricAcid = ItemUtils + .getItemStackOfAmountFromOreDictNoBroken("cellHydrofluoricAcid_GT5U", 2); + + GT_Values.RA.addChemicalRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumCarbonate", 5), // Input + ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumHydroxide", 5), // Input + null, // Fluid Input + null, // Fluid Output + ItemUtils.getItemStackOfAmountFromOreDict("dustLi2CO3CaOH2", 10), + 600 * 20); + + GT_Values.RA.addChemicalRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumHydroxide", 5), // Input + null, // Input Stack 2 + FluidUtils.getFluidStack("hydrofluoricacid", 5 * 144), + FluidUtils.getFluidStack("water", 5 * 144), // Fluid Output + ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumFluoride", 5), + 600 * 20); + + GT_Values.RA.addChemicalRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("cellOxygen", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustLithium7", 16), + FluidUtils.getFluidStack("water", 1000), + FluidUtils.getFluidStack("lithiumhydroxide", 2000 + 144 * 4), + CI.emptyCells(1), + 300 * 20); + + // LFTR Fuel Related Compounds + // Hydroxide + GT_Values.RA.addChemicalRecipe( + ItemUtils.getGregtechCircuit(3), + ELEMENT.getInstance().OXYGEN.getCell(1), + ELEMENT.getInstance().HYDROGEN.getFluidStack(1000), + MISC_MATERIALS.HYDROXIDE.getFluidStack(1000), + CI.emptyCells(1), + GT_Values.NI, + 8 * 20, + 30); + // Beryllium Hydroxide + GT_Values.RA.addChemicalRecipe( + ItemUtils.getGregtechCircuit(3), + ELEMENT.getInstance().BERYLLIUM.getDust(7), + MISC_MATERIALS.HYDROXIDE.getFluidStack(1000), + FLUORIDES.BERYLLIUM_HYDROXIDE.getFluidStack(2000), + GT_Values.NI, + 8 * 20, + 30); + // Ammonium Bifluoride + GT_Values.RA.addChemicalRecipe( + ItemUtils.getGregtechCircuit(3), + ItemUtils.getItemStackOfAmountFromOreDict("cellHydrofluoricAcid", 1), + MISC_MATERIALS.AMMONIUM.getFluidStack(1000), + FLUORIDES.AMMONIUM_BIFLUORIDE.getFluidStack(2000), + CI.emptyCells(1), + 20 * 20, + 30); + if (aGtHydrofluoricAcid != null) { + // Ammonium Bifluoride + GT_Values.RA.addChemicalRecipe( + ItemUtils.getGregtechCircuit(3), + aGtHydrofluoricAcid, + MISC_MATERIALS.AMMONIUM.getFluidStack(1000), + FLUORIDES.AMMONIUM_BIFLUORIDE.getFluidStack(2000), + CI.emptyCells(2), + 40 * 20, + 30); + } + // Ammonium + GT_Values.RA.addChemicalRecipe( + ItemUtils.getGregtechCircuit(3), + ELEMENT.getInstance().HYDROGEN.getCell(1), + MISC_MATERIALS.AMMONIA.getFluidStack(1000), + MISC_MATERIALS.AMMONIUM.getFluidStack(2000), + CI.emptyCells(1), + GT_Values.NI, + 20 * 20, + 30); + + // Sodium Hydroxide + GT_Values.RA.addChemicalRecipe( + CI.getNumberedBioCircuit(15), + ItemUtils.getItemStackOfAmountFromOreDict("dustSodiumHydroxide", 1), + FluidUtils.getFluidStack("hydrofluoricacid", 500), + FluidUtils.getWater(1000), + FLUORIDES.SODIUM_FLUORIDE.getDust(1), + 60 * 20); + + if (FluidUtils.doesFluidExist("hydrofluoricacid_gt5u")) { + GT_Values.RA.addChemicalRecipe( + CI.getNumberedBioCircuit(15), + ItemUtils.getItemStackOfAmountFromOreDict("dustSodiumHydroxide", 1), + FluidUtils.getFluidStack("hydrofluoricacid_gt5u", 1000), + FluidUtils.getWater(1000), + FLUORIDES.SODIUM_FLUORIDE.getDust(1), + 60 * 20); + } + } + + private static void dehydratorRecipes() { + + // Makes 7-Lithium + GT_Values.RA.stdBuilder() + .itemInputs(CI.getNumberedAdvancedCircuit(14)) + .fluidInputs(FluidUtils.getFluidStack("sulfuriclithium", 1440)) + .itemOutputs( + ItemUtils.getItemStackOfAmountFromOreDict("dustSulfur", 3), + ItemUtils.getItemStackOfAmountFromOreDict("dustCopper", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustSodium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustCarbon", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustLithium7", 4)) + .duration(30 * SECONDS) + .eut(30) + .addTo(chemicalDehydratorRecipes); + + // Makes Lithium Carbonate + CORE.RA.addDehydratorRecipe( + new ItemStack[] { CI.emptyCells(12), ItemUtils.getItemStackOfAmountFromOreDict("dustLepidolite", 20) }, // Item + // input + // (Array, + // up + // to + // 2) + FluidUtils.getFluidStack("sulfuricacid", 10000), + FluidUtils.getFluidStack("sulfuriclithium", 10000), + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustPotassium", 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Aluminium, 4), + ItemUtils.getItemStackOfAmountFromOreDict("cellOxygen", 10), + ItemUtils.getItemStackOfAmountFromOreDict("cellFluorine", 2), + ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumCarbonate", 3), // LithiumCarbonate + }, // Output Array of Items - Upto 9, + new int[] { 10000, 10000, 10000, 10000, 10000 }, + 75 * 20, // Time in ticks + 1000); // EU + + // Calcium Hydroxide + if (ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDict("dustQuicklime", 1))) { + // CaO + H2O = Ca(OH)2 + CORE.RA.addDehydratorRecipe( + new ItemStack[] { CI.getNumberedBioCircuit(20), + ItemUtils.getItemStackOfAmountFromOreDict("dustQuicklime", 2) }, + FluidUtils.getFluidStack("water", 1000), + null, // Fluid output (slot 2) + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumHydroxide", 5) }, // Output + new int[] { 10000 }, + 12 * 20, // Time in ticks + 120); // EU + } else { + Logger.INFO("[dustCalciumHydroxide] FAILED TO LOAD RECIPE"); + if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDict("dustQuicklime", 1))) { + Logger.INFO("Could not find dustQuicklime, cannot make dustCalciumHydroxide."); + } + } + + // 2 LiOH + CaCO3 + CORE.RA.addDehydratorRecipe( + new ItemStack[] { CI.getNumberedAdvancedCircuit(20), + ItemUtils.getItemStackOfAmountFromOreDict("dustLi2CO3CaOH2", 5) }, // Item + null, // Fluid input (slot 1) + null, // Fluid output (slot 2) + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumHydroxide", 2), + ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumCarbonate", 3) }, // Output + new int[] { 10000, 10000 }, + 120 * 20, // Time in ticks + 1000); // EU + + // LiOH Liquid to Dust + CORE.RA.addDehydratorRecipe( + new ItemStack[] { CI.getNumberedAdvancedCircuit(22) }, + FluidUtils.getFluidStack("lithiumhydroxide", 144), + null, + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumHydroxide", 1) }, + new int[] { 10000 }, + 1 * 20, // Time in ticks + 64); // EU + + // Zirconium Chloride -> TetraFluoride + FluidStack aHydrogenChloride = new FluidStack(GenericChem.HydrochloricAcid, 9000); + CORE.RA.addDehydratorRecipe( + new ItemStack[] { CI.getNumberedAdvancedCircuit(11), + ItemUtils.getItemStackOfAmountFromOreDict("dustCookedZrCl4", 9), }, // Item + FluidUtils.getFluidStack("hydrofluoricacid", 9 * 144), + aHydrogenChloride, + new ItemStack[] { FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getDust(9) }, + new int[] { 10000 }, + 120 * 20, // Time in ticks + 500); // EU + + // Zirconium Chloride -> TetraFluoride + CORE.RA.addDehydratorRecipe( + new ItemStack[] { CI.getNumberedAdvancedCircuit(10), + ItemUtils.getItemStackOfAmountFromOreDict("dustCookedZrCl4", 9) }, + FluidUtils.getFluidStack("hydrofluoricacid_gt5u", 18 * 144), + aHydrogenChloride, + new ItemStack[] { FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getDust(9) }, + new int[] { 10000 }, + 240 * 20, // Time in ticks + 500); // EU + + // Be(OH)2 + 2 (NH4)HF2 → (NH4)2BeF4 + 2 H2O + CORE.RA.addDehydratorRecipe( + new ItemStack[] { CI.getNumberedAdvancedCircuit(6), FLUORIDES.AMMONIUM_BIFLUORIDE.getCell(4) }, + FLUORIDES.BERYLLIUM_HYDROXIDE.getFluidStack(2000), // Fluid input (slot 1) + FLUORIDES.AMMONIUM_TETRAFLUOROBERYLLATE.getFluidStack(6000), + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("cellWater", 4) }, + new int[] { 10000 }, + 32 * 20, // Time in ticks + 64); // EU + + // (NH4)2BeF4 → 2 NH3 + 2 HF + BeF2 + CORE.RA.addDehydratorRecipe( + new ItemStack[] { CI.getNumberedAdvancedCircuit(17), CI.emptyCells(5) }, + FLUORIDES.AMMONIUM_TETRAFLUOROBERYLLATE.getFluidStack(5000), + null, + new ItemStack[] { MISC_MATERIALS.AMMONIA.getCell(2), + ItemUtils.getItemStackOfAmountFromOreDict("cellHydrofluoricAcid", 2), + FLUORIDES.BERYLLIUM_FLUORIDE.getCell(1) }, + new int[] { 10000, 10000, 10000 }, + 5 * 60 * 20, + 120); + } + + private static void electroMagneticSeperator() { + + // Zirconium + GT_Values.RA.addElectromagneticSeparatorRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedBauxite", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustBauxite", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustSmallRutile", 1), + ItemUtils.getItemStackOfAmountFromOreDict("nuggetZirconium", 1), + new int[] { 10000, 2500, 4000 }, + 20 * 20, + 24); + + // Zircon + GT_Values.RA.addElectromagneticSeparatorRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedMagnetite", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustMagnetite", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustSmallZircon", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyZircon", 1), + new int[] { 10000, 1250, 2500 }, + 20 * 20, + 24); + GT_Values.RA.addElectromagneticSeparatorRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedCassiterite", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustCassiterite", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustSmallZircon", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyZircon", 1), + new int[] { 10000, 1250, 2500 }, + 20 * 20, + 24); + } + + private static void fluidExtractorRecipes() { + + // FLiBe fuel + CORE.RA.addFluidExtractionRecipe(NUCLIDE.Li2BeF4.getDust(1), NUCLIDE.Li2BeF4.getFluidStack(144), 100, 500); + // Lithium Fluoride + CORE.RA.addFluidExtractionRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumFluoride", 1), + FLUORIDES.LITHIUM_FLUORIDE.getFluidStack(144), + 100, + 500); + // LFTR Fuel 1 + CORE.RA.addFluidExtractionRecipe( + NUCLIDE.LiFBeF2ZrF4U235.getDust(1), + NUCLIDE.LiFBeF2ZrF4U235.getFluidStack(144), + 250, + 1000); + CORE.RA.addFluidExtractionRecipe( + NUCLIDE.LiFBeF2ZrF4UF4.getDust(1), + NUCLIDE.LiFBeF2ZrF4UF4.getFluidStack(144), + 150, + 1500); + CORE.RA.addFluidExtractionRecipe( + NUCLIDE.LiFBeF2ThF4UF4.getDust(1), + NUCLIDE.LiFBeF2ThF4UF4.getFluidStack(144), + 150, + 2000); + + // ZIRCONIUM_TETRAFLUORIDE + CORE.RA.addFluidExtractionRecipe( + FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getDust(1), + FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getFluidStack(144), + 200, + 512 + 256); + } + + private static void fusionChainRecipes() { + // Mk1 + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.Boron.getPlasma(144), Materials.Calcium.getPlasma(16)) + .fluidOutputs(new FluidStack(ELEMENT.getInstance().NEON.getPlasma(), 1000)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(TierEU.RECIPE_LuV) + .metadata(FUSION_THRESHOLD, 100000000) + .addTo(fusionRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs( + new FluidStack(ELEMENT.getInstance().NEON.getPlasma(), 144), + Materials.Bedrockium.getMolten(144)) + .fluidOutputs(new FluidStack(ELEMENT.STANDALONE.FORCE.getPlasma(), 1000)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(TierEU.RECIPE_LuV) + .metadata(FUSION_THRESHOLD, 100000000) + .addTo(fusionRecipes); + + // Mk2 + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.Niobium.getPlasma(144), Materials.Zinc.getPlasma(144)) + .fluidOutputs(new FluidStack(ELEMENT.getInstance().KRYPTON.getPlasma(), 144)) + .duration(32 * TICKS) + .eut(TierEU.RECIPE_ZPM) + .metadata(FUSION_THRESHOLD, 300000000) + .addTo(fusionRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs( + new FluidStack(ELEMENT.getInstance().KRYPTON.getPlasma(), 144), + new FluidStack(ELEMENT.STANDALONE.FORCE.getPlasma(), 1000)) + .fluidOutputs(new FluidStack(ELEMENT.STANDALONE.ASTRAL_TITANIUM.getPlasma(), 1000)) + .duration(32 * TICKS) + .eut(TierEU.RECIPE_ZPM) + .metadata(FUSION_THRESHOLD, 300000000) + .addTo(fusionRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs( + new FluidStack(ELEMENT.STANDALONE.ASTRAL_TITANIUM.getPlasma(), 144), + new FluidStack(ALLOY.TITANSTEEL.getFluid(), 8)) + .fluidOutputs(new FluidStack(ELEMENT.STANDALONE.RUNITE.getPlasma(), 1000)) + .duration(32 * TICKS) + .eut(TierEU.RECIPE_ZPM) + .metadata(FUSION_THRESHOLD, 300000000) + .addTo(fusionRecipes); + + // Mk3 + GT_Values.RA.stdBuilder() + .fluidInputs(ELEMENT.getInstance().CURIUM.getFluidStack(144), Materials.Americium.getPlasma(144)) + .fluidOutputs(new FluidStack(ELEMENT.getInstance().XENON.getPlasma(), 144)) + .duration(16 * TICKS) + .eut(TierEU.RECIPE_UV) + .metadata(FUSION_THRESHOLD, 500000000) + .addTo(fusionRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs( + new FluidStack(ELEMENT.getInstance().XENON.getPlasma(), 144), + new FluidStack(ELEMENT.STANDALONE.RUNITE.getPlasma(), 1000)) + .fluidOutputs(new FluidStack(ELEMENT.STANDALONE.ADVANCED_NITINOL.getPlasma(), 1000)) + .duration(16 * TICKS) + .eut(TierEU.RECIPE_UV) + .metadata(FUSION_THRESHOLD, 500000000) + .addTo(fusionRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs( + new FluidStack(ELEMENT.STANDALONE.ADVANCED_NITINOL.getPlasma(), 144), + Materials.Tartarite.getMolten(2)) + .fluidOutputs(new FluidStack(ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN.getPlasma(), 1000)) + .duration(16 * TICKS) + .eut(TierEU.RECIPE_UV) + .metadata(FUSION_THRESHOLD, 500000000) + .addTo(fusionRecipes); + } + + private static void macerator() { + + GT_ModHandler.addPulverisationRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("pelletZirconium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZrCl4", 1)); + } + + private static void mixerRecipes() { + + GT_Values.RA.addMixerRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("dustUranium233", 4), + ItemUtils.getItemStackOfAmountFromOreDict("dustUranium235", 1), + null, + null, + FluidUtils.getFluidStack("hydrofluoricacid", 5000), + FLUORIDES.URANIUM_TETRAFLUORIDE.getFluidStack(5000), + null, + 3000, + 500); + } + + private static void sifter() { + + // Zirconium + GT_Values.RA.addSifterRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedIlmenite", 1), + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustIron", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustWroughtIron", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustHafnium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustHafnium", 1) }, + new int[] { 5000, 278, 1000, 1000, 300, 300 }, + 20 * 30, + 500); + GT_Values.RA.addSifterRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedTin", 1), + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustTin", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZinc", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1) }, + new int[] { 10000, 556, 1500, 1000, 500, 500 }, + 20 * 30, + 500); + GT_Values.RA.addSifterRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedCassiterite", 1), + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustCassiterite", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTin", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1) }, + new int[] { 10000, 556, 1500, 1000, 500, 500 }, + 20 * 30, + 500); + + // Radium + GT_Values.RA.addSifterRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedThorium", 1), + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustThorium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustLead", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1) }, + new int[] { 10000, 500, 300, 200, 100, 100 }, + 20 * 30, + 500); + + GT_Values.RA.addSifterRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedUranium", 1), + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustUranium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustLead", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1) }, + new int[] { 10000, 556, 1000, 500, 500, 500 }, + 20 * 30, + 500); + + GT_Values.RA.addSifterRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedUraninite", 1), + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustUraninite", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustUranium", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1) }, + new int[] { 10000, 556, 500, 250, 250, 250 }, + 20 * 30, + 500); + + GT_Values.RA.addSifterRecipe( + ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedPitchblende", 1), + new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("dustPitchblende", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustLead", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1) }, + new int[] { 10000, 556, 500, 250, 250, 250 }, + 20 * 30, + 500); + } + + private static void fluidHeater() { + + CORE.RA.addFluidHeaterRecipe( + FLUORIDES.SODIUM_FLUORIDE.getDust(1), + null, + FLUORIDES.SODIUM_FLUORIDE.getFluidStack(144), + 20 * 30, + 500); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_NuclearFuelProcessing.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_NuclearFuelProcessing.java new file mode 100644 index 0000000000..dec6fd426a --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_NuclearFuelProcessing.java @@ -0,0 +1,258 @@ +package gtPlusPlus.xmod.gregtech.loaders.recipe; + +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.distillationTowerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.TierEU; +import gtPlusPlus.core.item.chemistry.NuclearChem; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.ELEMENT; +import gtPlusPlus.core.material.nuclear.FLUORIDES; +import gtPlusPlus.core.material.nuclear.NUCLIDE; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; + +public class RecipeLoader_NuclearFuelProcessing { + + public static void generate() { + + // Create Fuels + + final FluidStack aLithiumFluoride = FLUORIDES.LITHIUM_FLUORIDE.getFluidStack(100); + final FluidStack aBerylliumFluoride = FLUORIDES.BERYLLIUM_FLUORIDE.getFluidStack(100); + final FluidStack aThoriumFluoride = FLUORIDES.THORIUM_TETRAFLUORIDE.getFluidStack(100); + final FluidStack aZirconiumFluoride = FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getFluidStack(100); + final FluidStack aUraniumTetraFluoride = FLUORIDES.URANIUM_TETRAFLUORIDE.getFluidStack(100); + final FluidStack aUranium235 = ELEMENT.getInstance().URANIUM235.getFluidStack(1000); + final FluidStack aLiFBeF2ZrF4U235 = NUCLIDE.LiFBeF2ZrF4U235.getFluidStack(100); + final FluidStack aLiFBeF2ZrF4UF4 = NUCLIDE.LiFBeF2ZrF4UF4.getFluidStack(100); + final FluidStack aLiFBeF2ThF4UF4 = NUCLIDE.LiFBeF2ThF4UF4.getFluidStack(100); + + // 7LiF - BeF2 - ZrF4 - U235 - 590C + CORE.RA.addFissionFuel( + FluidUtils.getFluidStack(aLithiumFluoride, 550), + FluidUtils.getFluidStack(aBerylliumFluoride, 150), + FluidUtils.getFluidStack(aZirconiumFluoride, 60), + FluidUtils.getFluidStack(aUranium235, 240), + null, + null, + null, + null, + null, // Extra 5 inputs + FluidUtils.getFluidStack(aLiFBeF2ZrF4U235, 1000), + null, + 30 * 60 * 20, // Duration + MaterialUtils.getVoltageForTier(4)); + + // 7LiF - BeF2 - ZrF4 - UF4 - 650C + CORE.RA.addFissionFuel( + FluidUtils.getFluidStack(aLithiumFluoride, 600), + FluidUtils.getFluidStack(aBerylliumFluoride, 250), + FluidUtils.getFluidStack(aZirconiumFluoride, 80), + FluidUtils.getFluidStack(aUraniumTetraFluoride, 70), + null, + null, + null, + null, + null, // Extra 5 inputs + FluidUtils.getFluidStack(aLiFBeF2ZrF4UF4, 1000), + null, + 40 * 60 * 20, + MaterialUtils.getVoltageForTier(5)); + + // 7liF - BeF2 - ThF4 - UF4 - 566C + CORE.RA.addFissionFuel( + FluidUtils.getFluidStack(aLithiumFluoride, 580), + FluidUtils.getFluidStack(aBerylliumFluoride, 270), + FluidUtils.getFluidStack(aThoriumFluoride, 80), + FluidUtils.getFluidStack(aUraniumTetraFluoride, 70), + null, + null, + null, + null, + null, // Extra 5 inputs + FluidUtils.getFluidStack(aLiFBeF2ThF4UF4, 1000), + null, + 50 * 60 * 20, // Duration + MaterialUtils.getVoltageForTier(5)); + + // Reprocess Fuels + + // Reactor Blanket step 1 - Fluorination + CORE.RA.addReactorProcessingUnitRecipe( + CI.getNumberedAdvancedCircuit(17), + ELEMENT.getInstance().FLUORINE.getCell(6), + NUCLIDE.LiFThF4.getFluidStack(10000), + new ItemStack[] { CI.emptyCells(5), FLUORIDES.LITHIUM_FLUORIDE.getCell(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1) }, + new int[] { 10000, 10000, 500, 500, 500, 250, 250, 250 }, + NUCLIDE.UF6F2.getFluidStack(1500), + 20 * 60 * 10, + MaterialUtils.getVoltageForTier(5)); + CORE.RA.addReactorProcessingUnitRecipe( + CI.getNumberedAdvancedCircuit(18), + ELEMENT.getInstance().FLUORINE.getCell(6), + NUCLIDE.LiFBeF2ThF4.getFluidStack(10000), + new ItemStack[] { CI.emptyCells(4), FLUORIDES.LITHIUM_FLUORIDE.getCell(1), + FLUORIDES.BERYLLIUM_FLUORIDE.getCell(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1) }, + new int[] { 10000, 10000, 10000, 1000, 1000, 1000, 500, 500, 500 }, + NUCLIDE.UF6F2.getFluidStack(3000), + 20 * 60 * 10, + MaterialUtils.getVoltageForTier(5)); + + // Reactor Blanket step 1 - Fluorination + CORE.RA.addReactorProcessingUnitRecipe( + CI.getNumberedAdvancedCircuit(7), + ELEMENT.getInstance().FLUORINE.getCell(6), + NUCLIDE.Sparged_LiFThF4.getFluidStack(10000), + new ItemStack[] { CI.emptyCells(4), FLUORIDES.LITHIUM_FLUORIDE.getCell(2), + ELEMENT.getInstance().PROTACTINIUM.getDust(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1) }, + new int[] { 10000, 10000, 1000, 1000, 1000, 1000, 1000, 1000 }, + NUCLIDE.UF6F2.getFluidStack(3000), + 20 * 60 * 5, + MaterialUtils.getVoltageForTier(5)); + CORE.RA.addReactorProcessingUnitRecipe( + CI.getNumberedAdvancedCircuit(8), + ELEMENT.getInstance().FLUORINE.getCell(6), + NUCLIDE.Sparged_LiFBeF2ThF4.getFluidStack(10000), + new ItemStack[] { CI.emptyCells(2), FLUORIDES.LITHIUM_FLUORIDE.getCell(2), + FLUORIDES.BERYLLIUM_FLUORIDE.getCell(2), ELEMENT.getInstance().PROTACTINIUM.getDust(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1), ELEMENT.getInstance().PROTACTINIUM.getDust(1), + ELEMENT.getInstance().PROTACTINIUM.getDust(1) }, + new int[] { 10000, 10000, 10000, 2000, 2000, 2000, 2000, 2000, 2000 }, + NUCLIDE.UF6F2.getFluidStack(6000), + 20 * 60 * 5, + MaterialUtils.getVoltageForTier(5)); + + // Reactor Blanket step 2 - Sorption + Cold Trap + CORE.RA.addColdTrapRecipe( + 8, + FLUORIDES.SODIUM_FLUORIDE.getCell(4), + NUCLIDE.UF6F2.getFluidStack(3000), + new ItemStack[] { ELEMENT.getInstance().FLUORINE.getCell(2), FLUORIDES.URANIUM_HEXAFLUORIDE.getCell(2), + ELEMENT.getInstance().URANIUM233.getDust(1), ELEMENT.getInstance().URANIUM233.getDust(1), + ELEMENT.getInstance().URANIUM233.getDust(1) }, + new int[] { 10000, 10000, 3000, 2000, 1000 }, + FLUORIDES.SODIUM_FLUORIDE.getFluidStack(2000), + 20 * 60 * 10, + MaterialUtils.getVoltageForTier(3)); + + // LiBeF2UF4FP + F2 = LiFBeF2 & UF6F2FP + // Reactor Core step 1 - Process Burnt Salt + CORE.RA.addReactorProcessingUnitRecipe( + CI.getNumberedAdvancedCircuit(1), + ELEMENT.getInstance().FLUORINE.getCell(1), + NUCLIDE.LiFBeF2UF4FP.getFluidStack(1000), + new ItemStack[] { NUCLIDE.UF6F2FP.getCell(1) }, + new int[] { 10000 }, + FluidUtils.getFluidStack(NuclearChem.Impure_LiFBeF2, 1000), + 20 * 60 * 120, + MaterialUtils.getVoltageForTier(3)); + + // LiBeF2UF4FP + F2 = LiFBeF2 & UF6F2FP + // Reactor Core step 1 - Process Burnt Salt + CORE.RA.addReactorProcessingUnitRecipe( + CI.getNumberedAdvancedCircuit(1), + ELEMENT.getInstance().FLUORINE.getCell(3), + NUCLIDE.Sparged_LiFBeF2UF4FP.getFluidStack(1000), + new ItemStack[] { CI.emptyCells(1), NUCLIDE.UF6F2FP.getCell(2) }, + new int[] { 10000 }, + FluidUtils.getFluidStack(NuclearChem.Impure_LiFBeF2, 2000), + 20 * 60 * 60, + MaterialUtils.getVoltageForTier(3)); + + // Reactor Core step 2A - Sorption + Cold Trap + CORE.RA.addColdTrapRecipe( + 8, + FLUORIDES.SODIUM_FLUORIDE.getCell(3), + NUCLIDE.UF6F2FP.getFluidStack(2000), + new ItemStack[] { ELEMENT.getInstance().FLUORINE.getCell(1), FLUORIDES.URANIUM_HEXAFLUORIDE.getCell(2), + ELEMENT.getInstance().PHOSPHORUS.getDust(1), ELEMENT.getInstance().PHOSPHORUS.getDust(1), + ELEMENT.getInstance().PHOSPHORUS.getDust(1), ELEMENT.getInstance().PHOSPHORUS.getDust(1), + ELEMENT.getInstance().PHOSPHORUS.getDust(1), ELEMENT.getInstance().PHOSPHORUS.getDust(1) }, + new int[] { 10000, 10000, 5000, 5000, 5000, 5000, 5000, 5000 }, + FLUORIDES.SODIUM_FLUORIDE.getFluidStack(2000), + 20 * 60 * 10, + MaterialUtils.getVoltageForTier(4)); + + // Reactor Core step 2B - Distillation + GT_Values.RA.stdBuilder() + .fluidInputs(FluidUtils.getFluidStack(NuclearChem.Impure_LiFBeF2, 1000)) + .fluidOutputs(NUCLIDE.LiFBeF2.getFluidStack(250)) + .duration(7 * MINUTES + 30 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(distillationTowerRecipes); + + // UF6 -> UF4 reduction + // UF6 + LiFBeF2 + H2 -> LiFBeF2UF4 + HF + GT_Values.RA.stdBuilder() + .itemInputs(FLUORIDES.URANIUM_HEXAFLUORIDE.getCell(1), NUCLIDE.LiFBeF2.getCell(1)) + .fluidInputs(Materials.Hydrogen.getGas(2000L)) + .itemOutputs(ItemUtils.getItemStackOfAmountFromOreDict("cellHydrofluoricAcid", 2)) + .fluidOutputs(NUCLIDE.LiFBeF2UF4.getFluidStack(3000)) + .duration(2 * MINUTES + 30 * SECONDS) + .eut(TierEU.RECIPE_IV) + .metadata(COIL_HEAT, 5400) + .addTo(blastFurnaceRecipes); + // Alternative recipe to the above, for chemplant, to not use cells + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] {}, + new FluidStack[] { FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(1000), NUCLIDE.LiFBeF2.getFluidStack(1000), + ELEMENT.getInstance().HYDROGEN.getFluidStack(2000) }, + new ItemStack[] {}, + new FluidStack[] { NUCLIDE.LiFBeF2UF4.getFluidStack(3000), + FluidUtils.getFluidStack("hydrofluoricacid", 2000) }, + 300 * 10, + MaterialUtils.getVoltageForTier(5), + 4); + + CORE.RA.addFissionFuel( + FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getFluidStack(100), + NUCLIDE.LiFBeF2UF4.getFluidStack(900), + null, + null, + null, + null, + null, + null, + null, + NUCLIDE.LiFBeF2ZrF4UF4.getFluidStack(1000), + null, + 20 * 60 * 12, // Duration + MaterialUtils.getVoltageForTier(5)); + + CORE.RA.addFissionFuel( + FLUORIDES.THORIUM_TETRAFLUORIDE.getFluidStack(100), + NUCLIDE.LiFBeF2UF4.getFluidStack(900), + null, + null, + null, + null, + null, + null, + null, + NUCLIDE.LiFBeF2ThF4UF4.getFluidStack(1000), + null, + 20 * 60 * 15, // Duration + MaterialUtils.getVoltageForTier(5)); + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_TreeFarm.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_TreeFarm.java new file mode 100644 index 0000000000..28c8b2a337 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_TreeFarm.java @@ -0,0 +1,719 @@ +package gtPlusPlus.xmod.gregtech.loaders.recipe; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +import binnie.extratrees.genetics.ExtraTreeSpecies; +import forestry.api.arboriculture.EnumGermlingType; +import forestry.api.arboriculture.EnumWoodType; +import forestry.api.arboriculture.ITree; +import forestry.api.arboriculture.TreeManager; +import forestry.arboriculture.genetics.TreeDefinition; +import forestry.plugins.PluginArboriculture; +import gregtech.api.enums.Mods; +import gregtech.api.util.GT_ModHandler; +import gtPlusPlus.core.util.reflect.ReflectionUtils; +import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production.GregtechMetaTileEntityTreeFarm; + +public class RecipeLoader_TreeFarm { + + public static void generateRecipes() { + generateVanillaTrees(); + + if (Mods.IndustrialCraft2.isModLoaded()) generateIC2Trees(); + if (Mods.TinkerConstruct.isModLoaded()) generateTinkersTrees(); + if (Mods.GTPlusPlus.isModLoaded()) generateGTPPTrees(); + + if (Mods.TwilightForest.isModLoaded()) generateTwilightForestTrees(); + if (Mods.GalaxySpace.isModLoaded()) generateGalaxySpaceTrees(); + if (Mods.GalacticraftAmunRa.isModLoaded()) generateAmunRaTrees(); + + if (Mods.Thaumcraft.isModLoaded()) generateThaumcraftTrees(); + if (Mods.ThaumicBases.isModLoaded()) generateThaumicBasesTrees(); + if (Mods.TaintedMagic.isModLoaded()) generateTaintedMagicTrees(); + if (Mods.ForbiddenMagic.isModLoaded()) generateForbiddenMagicTrees(); + if (Mods.Witchery.isModLoaded()) generateWitcheryTrees(); + + if (Mods.Natura.isModLoaded()) generateNaturaTrees(); + if (Mods.BiomesOPlenty.isModLoaded()) generateBOPTrees(); + if (Mods.PamsHarvestCraft.isModLoaded()) generatePamsTrees(); + if (Mods.PamsHarvestTheNether.isModLoaded()) generatePamsNetherTrees(); + + if (Mods.Forestry.isModLoaded()) generateForestryTrees(); + if (Mods.ExtraTrees.isModLoaded()) generateExtraTreesTrees(); + } + + private static void generateVanillaTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Oak + new ItemStack(Blocks.sapling, 1, 0), + new ItemStack(Blocks.log, 1, 0), + new ItemStack(Blocks.leaves, 1, 0), + new ItemStack(Items.apple, 1, 0)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Spruce + new ItemStack(Blocks.sapling, 1, 1), + new ItemStack(Blocks.log, 2, 1), + new ItemStack(Blocks.leaves, 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Birch + new ItemStack(Blocks.sapling, 1, 2), + new ItemStack(Blocks.log, 1, 2), + new ItemStack(Blocks.leaves, 1, 2), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Jungle + new ItemStack(Blocks.sapling, 1, 3), + new ItemStack(Blocks.log, 2, 3), + new ItemStack(Blocks.leaves, 1, 3), + new ItemStack(Items.dye, 1, 3)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Acacia + new ItemStack(Blocks.sapling, 1, 4), + new ItemStack(Blocks.log2, 1, 0), + new ItemStack(Blocks.leaves2, 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Dark Oak + new ItemStack(Blocks.sapling, 1, 5), + new ItemStack(Blocks.log2, 1, 1), + new ItemStack(Blocks.leaves2, 1, 1), + new ItemStack(Items.apple, 1, 0)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Brown Mushroom + new ItemStack(Blocks.brown_mushroom, 1, 0), + new ItemStack(Blocks.brown_mushroom_block, 1, 0), + null, + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Red Mushroom + new ItemStack(Blocks.red_mushroom, 1, 0), + new ItemStack(Blocks.red_mushroom_block, 1, 0), + null, + null); + } + + private static void generateIC2Trees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Rubber Tree + GT_ModHandler.getModItem(Mods.IndustrialCraft2.ID, "blockRubSapling", 1, 0), + GT_ModHandler.getModItem(Mods.IndustrialCraft2.ID, "blockRubWood", 1, 0), + GT_ModHandler.getModItem(Mods.IndustrialCraft2.ID, "blockRubLeaves", 1, 0), + GT_ModHandler.getModItem(Mods.IndustrialCraft2.ID, "itemHarz", 1, 0)); + } + + private static void generateTinkersTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Slimy + GT_ModHandler.getModItem(Mods.TinkerConstruct.ID, "slime.sapling", 1, 0), + GT_ModHandler.getModItem(Mods.TinkerConstruct.ID, "slime.gel", 1, 1), + GT_ModHandler.getModItem(Mods.TinkerConstruct.ID, "slime.leaves", 1, 0), + GT_ModHandler.getModItem(Mods.TinkerConstruct.ID, "strangeFood", 1, 0)); + } + + private static void generateGTPPTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Rainforest Oak + GT_ModHandler.getModItem(Mods.GTPlusPlus.ID, "blockRainforestOakSapling", 1, 0), + GT_ModHandler.getModItem(Mods.GTPlusPlus.ID, "blockRainforestOakLog", 3, 0), + GT_ModHandler.getModItem(Mods.GTPlusPlus.ID, "blockRainforestOakLeaves", 1, 0), + new ItemStack(Items.apple, 1, 0)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Pine + GT_ModHandler.getModItem(Mods.GTPlusPlus.ID, "blockPineSapling", 1, 0), + GT_ModHandler.getModItem(Mods.GTPlusPlus.ID, "blockPineLogLog", 1, 0), + GT_ModHandler.getModItem(Mods.GTPlusPlus.ID, "blockPineLeaves", 1, 0), + GT_ModHandler.getModItem(Mods.GTPlusPlus.ID, "item.BasicAgrichemItem", 1, 24)); + } + + private static void generateTwilightForestTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Sickly Twilight Oak + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFSapling", 1, 0), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLog", 1, 0), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLeaves", 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Canopy Tree + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFSapling", 1, 1), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLog", 1, 1), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLeaves", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Twilight Mangrove + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFSapling", 1, 2), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLog", 1, 2), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLeaves", 1, 2), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Darkwood + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFSapling", 1, 3), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLog", 1, 3), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.DarkLeaves", 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Robust Twilight Oak + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFSapling", 1, 4), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLog", 4, 0), + // Does not drop more robust saplings normally: + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFSapling", 1, 0), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLeaves", 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Tree of Time + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFSapling", 1, 5), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFMagicLog", 1, 0), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFMagicLeaves", 1, 0), + // No I am not making this drop clocks. + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Tree of Transformation + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFSapling", 1, 6), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFMagicLog", 1, 1), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFMagicLeaves", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Sorting Tree + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFSapling", 1, 8), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFMagicLog", 1, 3), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFMagicLeaves", 1, 3), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Rainbow Oak + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFSapling", 1, 9), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLog", 1, 0), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLeaves", 1, 3), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Thorns + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFThorns", 1, 0), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFThorns", 1, 0), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFThorns", 1, 1), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLeaves3", 1, 0), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFThornRose", 1, 0)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Magic Beans + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "item.magicBeans", 1, 0), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.HugeStalk", 5, 0), + GT_ModHandler.getModItem(Mods.TwilightForest.ID, "tile.TFLeaves3", 1, 1), + null); + } + + private static void generateGalaxySpaceTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Barnarda C + GT_ModHandler.getModItem(Mods.GalaxySpace.ID, "barnardaCsapling", 1, 1), + GT_ModHandler.getModItem(Mods.GalaxySpace.ID, "barnardaClog", 1, 0), + GT_ModHandler.getModItem(Mods.GalaxySpace.ID, "barnardaCleaves", 1, 0), + null); + } + + private static void generateAmunRaTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Virilig + GT_ModHandler.getModItem(Mods.GalacticraftAmunRa.ID, "tile.saplings", 1, 0), + GT_ModHandler.getModItem(Mods.GalacticraftAmunRa.ID, "tile.log1", 1, 0), + GT_ModHandler.getModItem(Mods.GalacticraftAmunRa.ID, "tile.null", 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Lumipod + GT_ModHandler.getModItem(Mods.GalacticraftAmunRa.ID, "tile.saplings", 1, 1), + GT_ModHandler.getModItem(Mods.GalacticraftAmunRa.ID, "tile.wood1", 1, 0), + null, + GT_ModHandler.getModItem(Mods.GalacticraftAmunRa.ID, "tile.wood1", 1, 1)); + } + + private static void generateNaturaTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Redwood + GT_ModHandler.getModItem(Mods.Natura.ID, "florasapling", 1, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "redwood", 5, 1), + GT_ModHandler.getModItem(Mods.Natura.ID, "florasapling", 2, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "floraleaves", 2, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "redwood", 2, 0)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Eucalyptus + GT_ModHandler.getModItem(Mods.Natura.ID, "florasapling", 1, 1), + GT_ModHandler.getModItem(Mods.Natura.ID, "tree", 1, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "floraleaves", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Hopseed + GT_ModHandler.getModItem(Mods.Natura.ID, "florasapling", 1, 2), + GT_ModHandler.getModItem(Mods.Natura.ID, "tree", 1, 3), + GT_ModHandler.getModItem(Mods.Natura.ID, "floraleaves", 1, 2), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Sakura + GT_ModHandler.getModItem(Mods.Natura.ID, "florasapling", 1, 3), + GT_ModHandler.getModItem(Mods.Natura.ID, "tree", 1, 1), + GT_ModHandler.getModItem(Mods.Natura.ID, "floraleavesnocolor", 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Ghostwood + GT_ModHandler.getModItem(Mods.Natura.ID, "florasapling", 1, 4), + GT_ModHandler.getModItem(Mods.Natura.ID, "tree", 1, 2), + GT_ModHandler.getModItem(Mods.Natura.ID, "floraleavesnocolor", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Blood + GT_ModHandler.getModItem(Mods.Natura.ID, "florasapling", 1, 5), + GT_ModHandler.getModItem(Mods.Natura.ID, "bloodwood", 1, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "floraleavesnocolor", 1, 2), + new ItemStack(Items.redstone, 1, 0)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Darkwood + GT_ModHandler.getModItem(Mods.Natura.ID, "florasapling", 1, 6), + GT_ModHandler.getModItem(Mods.Natura.ID, "Dark Tree", 1, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "Dark Leaves", 1, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "Natura.netherfood", 1, 0)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Fusewood + GT_ModHandler.getModItem(Mods.Natura.ID, "florasapling", 1, 7), + GT_ModHandler.getModItem(Mods.Natura.ID, "Dark Tree", 1, 1), + GT_ModHandler.getModItem(Mods.Natura.ID, "Dark Leaves", 1, 3), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Maple + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Sapling", 1, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Tree", 1, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Leaves", 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Silverbell + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Sapling", 1, 1), + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Tree", 1, 1), + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Leaves", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Amaranth + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Sapling", 1, 2), + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Tree", 1, 2), + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Leaves", 1, 2), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Tigerwood + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Sapling", 1, 3), + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Tree", 1, 3), + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Leaves", 1, 3), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Willow + GT_ModHandler.getModItem(Mods.Natura.ID, "Rare Sapling", 1, 4), + GT_ModHandler.getModItem(Mods.Natura.ID, "willow", 1, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "floraleavesnocolor", 1, 3), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Green Glowshroom + GT_ModHandler.getModItem(Mods.Natura.ID, "Glowshroom", 1, 0), + GT_ModHandler.getModItem(Mods.Natura.ID, "greenGlowshroom", 1, 0), + null, + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Purple Glowshroom + GT_ModHandler.getModItem(Mods.Natura.ID, "Glowshroom", 1, 1), + GT_ModHandler.getModItem(Mods.Natura.ID, "purpleGlowshroom", 1, 0), + null, + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Blue Glowshroom + GT_ModHandler.getModItem(Mods.Natura.ID, "Glowshroom", 1, 2), + GT_ModHandler.getModItem(Mods.Natura.ID, "blueGlowshroom", 1, 0), + null, + null); + } + + private static void generateBOPTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Apple + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 0), + new ItemStack(Blocks.log, 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "appleLeaves", 1, 0), + new ItemStack(Items.apple, 2, 0)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Yellow Autumn + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 1), + new ItemStack(Blocks.log, 1, 2), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves1", 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "food", 1, 8)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Bamboo + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 2), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "bamboo", 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves1", 1, 9), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Magic + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 3), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs2", 1, 1), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves1", 1, 2), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Dark + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 4), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs1", 1, 2), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves1", 1, 3), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Dying + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 5), + new ItemStack(Blocks.log, 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves2", 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "food", 1, 8)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Fir + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 6), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs1", 1, 3), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves2", 1, 1), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "misc", 1, 13)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Ethereal + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 7), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs2", 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves2", 1, 2), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Orange Autumn + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 8), + new ItemStack(Blocks.log2, 1, 1), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves2", 1, 3), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Origin + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 9), + new ItemStack(Blocks.log, 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves3", 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "food", 1, 8)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Pink Cherry + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 10), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs1", 1, 1), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves3", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Maple + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 11), + new ItemStack(Blocks.log, 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves3", 1, 2), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // White Cherry + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 12), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs1", 1, 1), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves3", 1, 3), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Hellbark + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 13), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs4", 1, 1), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves4", 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "food", 1, 8)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Jacaranda + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 14), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs4", 1, 2), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "leaves4", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Persimmon + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "saplings", 1, 15), + new ItemStack(Blocks.log, 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "persimmonLeaves", 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "food", 2, 8)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Sacred Oak + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedSaplings", 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs1", 4, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedSaplings", 2, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedLeaves1", 2, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Mangrove + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedSaplings", 1, 1), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs2", 1, 2), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedLeaves1", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Palm + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedSaplings", 1, 2), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs2", 1, 3), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedLeaves1", 1, 2), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Redwood + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedSaplings", 1, 3), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs3", 2, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedLeaves1", 1, 3), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Willow + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedSaplings", 1, 4), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs3", 1, 1), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedLeaves2", 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Pine + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedSaplings", 1, 5), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs4", 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedLeaves2", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Mahogany + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedSaplings", 1, 6), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs4", 1, 3), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedLeaves2", 1, 2), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Flowering Oak + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedSaplings", 1, 7), + new ItemStack(Blocks.log, 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "colorizedLeaves2", 1, 3), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Red Flower Stem + new ItemStack(Blocks.red_flower, 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs3", 1, 3), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "petals", 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Yellow Flower Stem + new ItemStack(Blocks.yellow_flower, 1, 0), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "logs3", 1, 3), + GT_ModHandler.getModItem(Mods.BiomesOPlenty.ID, "petals", 1, 1), + null); + } + + private static void addPamTree(String name, int meta) { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, "pam" + name + "Sapling", 1, 0), + new ItemStack(Blocks.log, 1, meta), + new ItemStack(Blocks.leaves, 1, meta), + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, name + "Item", 2, 0)); + } + + private static void generatePamsTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Cinnamon + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, "pamappleSapling", 1, 0), + new ItemStack(Blocks.log, 1, 0), + new ItemStack(Blocks.leaves, 1, 0), + new ItemStack(Items.apple, 2, 0)); + + addPamTree("almond", 3); + addPamTree("apricot", 3); + addPamTree("avocado", 0); + addPamTree("banana", 3); + addPamTree("cashew", 3); + addPamTree("cherry", 0); + addPamTree("chestnut", 0); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Cinnamon + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, "pamcinnamonSapling", 1, 0), + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, "pamCinnamon", 1, 0), + new ItemStack(Blocks.leaves, 1, 3), + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, "cinnamonItem", 2, 0)); + + addPamTree("coconut", 3); + addPamTree("date", 3); + addPamTree("dragonfruit", 3); + addPamTree("durian", 3); + addPamTree("fig", 3); + addPamTree("grapefruit", 3); + addPamTree("lemon", 3); + addPamTree("lime", 3); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Maple + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, "pammapleSapling", 1, 0), + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, "pamMaple", 1, 0), + new ItemStack(Blocks.leaves, 1, 1), + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, "maplesyrupItem", 2, 0)); + + addPamTree("mango", 3); + addPamTree("nutmeg", 0); + addPamTree("olive", 0); + addPamTree("orange", 3); + addPamTree("papaya", 3); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Paperbark + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, "pampaperbarkSapling", 1, 0), + GT_ModHandler.getModItem(Mods.PamsHarvestCraft.ID, "pamPaperbark", 1, 0), + new ItemStack(Blocks.leaves, 1, 3), + new ItemStack(Items.paper, 1, 0)); + + addPamTree("peach", 3); + addPamTree("pear", 0); + addPamTree("pecan", 3); + addPamTree("peppercorn", 3); + addPamTree("persimmon", 3); + addPamTree("pistachio", 3); + addPamTree("plum", 0); + addPamTree("pomegranate", 3); + addPamTree("starfruit", 3); + addPamTree("vanillabean", 3); + addPamTree("walnut", 0); + addPamTree("gooseberry", 0); + } + + private static void generatePamsNetherTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Ignis Fruit + GT_ModHandler.getModItem(Mods.PamsHarvestTheNether.ID, "netherSapling", 1, 0), + GT_ModHandler.getModItem(Mods.PamsHarvestTheNether.ID, "netherLog", 1, 0), + GT_ModHandler.getModItem(Mods.PamsHarvestTheNether.ID, "netherLeaves", 1, 0), + GT_ModHandler.getModItem(Mods.PamsHarvestTheNether.ID, "ignisfruitItem", 2, 0)); + } + + private static void generateThaumcraftTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Greatwood + GT_ModHandler.getModItem(Mods.Thaumcraft.ID, "blockCustomPlant", 1, 0), + GT_ModHandler.getModItem(Mods.Thaumcraft.ID, "blockMagicalLog", 2, 0), + GT_ModHandler.getModItem(Mods.Thaumcraft.ID, "blockMagicalLeaves", 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Silverwood + GT_ModHandler.getModItem(Mods.Thaumcraft.ID, "blockCustomPlant", 1, 1), + GT_ModHandler.getModItem(Mods.Thaumcraft.ID, "blockMagicalLog", 1, 1), + GT_ModHandler.getModItem(Mods.Thaumcraft.ID, "blockMagicalLeaves", 1, 1), + null); + } + + private static void generateThaumicBasesTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Golden Oak + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "goldenOakSapling", 1, 0), + new ItemStack(Blocks.log, 1, 0), + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "genLeaves", 1, 0), + GT_ModHandler.getModItem(Mods.Thaumcraft.ID, "blockMagicalLeaves", 1, 0), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Peaceful + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "goldenOakSapling", 1, 1), + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "genLogs", 1, 0), + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "genLeaves", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Nether + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "goldenOakSapling", 1, 2), + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "genLogs", 1, 1), + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "genLeaves", 1, 2), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Ender + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "goldenOakSapling", 1, 3), + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "genLogs", 1, 2), + GT_ModHandler.getModItem(Mods.ThaumicBases.ID, "genLeaves", 1, 3), + null); + } + + private static void generateTaintedMagicTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Warpwood + GT_ModHandler.getModItem(Mods.TaintedMagic.ID, "BlockWarpwoodSapling", 1, 0), + GT_ModHandler.getModItem(Mods.TaintedMagic.ID, "BlockWarpwoodLog", 1, 0), + GT_ModHandler.getModItem(Mods.TaintedMagic.ID, "BlockWarpwoodLeaves", 1, 0), + null); + } + + private static void generateForbiddenMagicTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Warpwood + GT_ModHandler.getModItem(Mods.ForbiddenMagic.ID, "TaintSapling", 1, 0), + GT_ModHandler.getModItem(Mods.ForbiddenMagic.ID, "TaintLog", 1, 0), + GT_ModHandler.getModItem(Mods.ForbiddenMagic.ID, "TaintLeaves", 1, 0), + GT_ModHandler.getModItem(Mods.ForbiddenMagic.ID, "TaintFruit", 1, 0)); + } + + private static void generateWitcheryTrees() { + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Rowan + GT_ModHandler.getModItem(Mods.Witchery.ID, "witchsapling", 1, 0), + GT_ModHandler.getModItem(Mods.Witchery.ID, "witchlog", 1, 0), + GT_ModHandler.getModItem(Mods.Witchery.ID, "witchleaves", 1, 0), + GT_ModHandler.getModItem(Mods.Witchery.ID, "ingredient", 1, 63)); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Alder + GT_ModHandler.getModItem(Mods.Witchery.ID, "witchsapling", 1, 1), + GT_ModHandler.getModItem(Mods.Witchery.ID, "witchlog", 1, 1), + GT_ModHandler.getModItem(Mods.Witchery.ID, "witchleaves", 1, 1), + null); + + GregtechMetaTileEntityTreeFarm.registerTreeProducts( // Hawthorn + GT_ModHandler.getModItem(Mods.Witchery.ID, "witchsapling", 1, 2), + GT_ModHandler.getModItem(Mods.Witchery.ID, "witchlog", 1, 2), + GT_ModHandler.getModItem(Mods.Witchery.ID, "witchleaves", 1, 2), + null); + } + + /* + * Abdiel Kavash: I do not claim the code in the following two methods to be ideal, or to even completely understand + * all the details. Much of it has been copied from the previous version, available at + * https://github.com/GTNewHorizons/GTplusplus/blob/dca836fee368878cf64ca59e4c7ffc5875a3f489/src/main/java/ + * gtPlusPlus/xmod/forestry/HANDLER_FR.java#L60. If anybody understands Forestry and/or Extra Trees internals better + * than I do, and knows a more straightforward way to retrieve the relevant ItemStacks here, please update this. + */ + + private static void generateForestryTrees() { + for (TreeDefinition tree : TreeDefinition.values()) { + String speciesUID = tree.getUID(); + + ItemStack sapling = tree.getMemberStack(EnumGermlingType.SAPLING); + + ItemStack log; + EnumWoodType woodType = ReflectionUtils.getField(tree, "woodType"); + if (woodType != null) { + log = TreeManager.woodItemAccess.getLog(woodType, false); + } else { + log = ReflectionUtils.getField(tree, "vanillaWood"); + } + + ItemStack leaves = new ItemStack(PluginArboriculture.blocks.leaves, 1, 0); + if (speciesUID != null) { + NBTTagCompound nbtTagCompound = new NBTTagCompound(); + nbtTagCompound.setString("species", speciesUID); + leaves.setTagCompound(nbtTagCompound); + } + + ItemStack fruit = null; + ITree individual = tree.getIndividual(); + if (individual.canBearFruit()) { + ItemStack[] produceList = individual.getProduceList(); + if (produceList != null && produceList.length > 0) { + fruit = individual.getProduceList()[0]; + } + } + + GregtechMetaTileEntityTreeFarm.registerForestryTree( + speciesUID, + sapling == null ? null : sapling.copy(), + log == null ? null : log.copy(), + leaves == null ? null : leaves.copy(), + fruit == null ? null : fruit.copy()); + } + } + + private static void generateExtraTreesTrees() { + for (ExtraTreeSpecies species : ExtraTreeSpecies.values()) { + + String speciesUID = species.getUID(); + + ITree individual = TreeManager.treeRoot.templateAsIndividual(species.getTemplate()); + ItemStack sapling = TreeManager.treeRoot.getMemberStack(individual, 0); + + ItemStack log = null; + if (species.getLog() != null) { + log = species.getLog() + .getItemStack(); + } + + ItemStack leaves = new ItemStack(PluginArboriculture.blocks.leaves, 1, 0); + if (speciesUID != null) { + NBTTagCompound nbtTagCompound = new NBTTagCompound(); + nbtTagCompound.setString("species", speciesUID); + leaves.setTagCompound(nbtTagCompound); + } + + ItemStack fruit = null; + if (individual.canBearFruit()) { + ItemStack[] produceList = individual.getProduceList(); + if (produceList != null && produceList.length > 0) { + fruit = individual.getProduceList()[0]; + } + } + + GregtechMetaTileEntityTreeFarm.registerForestryTree( + speciesUID, + sapling == null ? null : sapling.copy(), + log == null ? null : log.copy(), + leaves == null ? null : leaves.copy(), + fruit == null ? null : fruit.copy()); + } + } +} |