diff options
Diffstat (limited to 'src/main/java/gregtech/loaders/oreprocessing')
52 files changed, 9945 insertions, 0 deletions
diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingAll.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingAll.java new file mode 100644 index 0000000000..2f390b25e8 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingAll.java @@ -0,0 +1,24 @@ +package gregtech.loaders.oreprocessing; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; + +public class ProcessingAll implements gregtech.api.interfaces.IOreRecipeRegistrator { // TODO ACTUALLY COMPARE ALL THE + // PROCESSING CLASSES + + public ProcessingAll() { + for (OrePrefixes tPrefix : OrePrefixes.values()) tPrefix.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (((aStack.getItem() instanceof net.minecraft.item.ItemBlock)) + && (aPrefix.mDefaultStackSize < aStack.getItem() + .getItemStackLimit(aStack))) + aStack.getItem() + .setMaxStackSize(aPrefix.mDefaultStackSize); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingArrows.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingArrows.java new file mode 100644 index 0000000000..11d1b1e1b8 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingArrows.java @@ -0,0 +1,135 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.enchantment.Enchantment; +import net.minecraft.enchantment.EnchantmentHelper; +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OreDictNames; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingArrows implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingArrows() { + OrePrefixes.arrowGtWood.add(this); + OrePrefixes.arrowGtPlastic.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + ItemStack tOutput = GT_Utility.copyAmount(1, aStack); + GT_Utility.updateItemStack(tOutput); + GT_Utility.ItemNBT.addEnchantment( + tOutput, + Enchantment.smite, + EnchantmentHelper.getEnchantmentLevel(Enchantment.smite.effectId, tOutput) + 3); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(tOutput) + .fluidInputs(Materials.HolyWater.getFluid(25L)) + .duration(5 * SECONDS) + .eut(2) + .addTo(chemicalBathRecipes); + + tOutput = GT_Utility.copyAmount(1, aStack); + GT_Utility.updateItemStack(tOutput); + GT_Utility.ItemNBT.addEnchantment( + tOutput, + Enchantment.fireAspect, + EnchantmentHelper.getEnchantmentLevel(Enchantment.fireAspect.effectId, tOutput) + 3); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(tOutput) + .fluidInputs(Materials.FierySteel.getFluid(25L)) + .duration(5 * SECONDS) + .eut(2) + .addTo(chemicalBathRecipes); + + tOutput = GT_Utility.copyAmount(1, aStack); + GT_Utility.updateItemStack(tOutput); + GT_Utility.ItemNBT.addEnchantment( + tOutput, + Enchantment.fireAspect, + EnchantmentHelper.getEnchantmentLevel(Enchantment.fireAspect.effectId, tOutput) + 1); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(tOutput) + .fluidInputs(Materials.Blaze.getMolten(18L)) + .duration(5 * SECONDS) + .eut(2) + .addTo(chemicalBathRecipes); + + tOutput = GT_Utility.copyAmount(1, aStack); + GT_Utility.updateItemStack(tOutput); + GT_Utility.ItemNBT.addEnchantment( + tOutput, + Enchantment.knockback, + EnchantmentHelper.getEnchantmentLevel(Enchantment.knockback.effectId, tOutput) + 1); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(tOutput) + .fluidInputs(Materials.Rubber.getMolten(18L)) + .duration(5 * SECONDS) + .eut(2) + .addTo(chemicalBathRecipes); + + tOutput = GT_Utility.copyAmount(1, aStack); + GT_Utility.updateItemStack(tOutput); + GT_Utility.ItemNBT.addEnchantment( + tOutput, + gregtech.api.enchants.Enchantment_EnderDamage.INSTANCE, + EnchantmentHelper + .getEnchantmentLevel(gregtech.api.enchants.Enchantment_EnderDamage.INSTANCE.effectId, tOutput) + 1); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(tOutput) + .fluidInputs(Materials.Mercury.getFluid(25L)) + .duration(5 * SECONDS) + .eut(2) + .addTo(chemicalBathRecipes); + + if (!aMaterial.mUnificatable) { + return; + } + if (aMaterial.mMaterialInto != aMaterial) { + return; + } + + if (aMaterial.contains(SubTag.NO_WORKING)) { + return; + } + + switch (aPrefix) { + case arrowGtWood: + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.arrowGtWood, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { " A", " S ", "F ", 'S', OrePrefixes.stick.get(Materials.Wood), 'F', + OreDictNames.craftingFeather, 'A', OrePrefixes.toolHeadArrow.get(aMaterial) }); + case arrowGtPlastic: + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.arrowGtPlastic, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { " A", " S ", "F ", 'S', OrePrefixes.stick.get(Materials.Plastic), 'F', + OreDictNames.craftingFeather, 'A', OrePrefixes.toolHeadArrow.get(aMaterial) }); + default: + break; + } + + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java new file mode 100644 index 0000000000..2fb200216e --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java @@ -0,0 +1,35 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingBeans implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingBeans() { + OrePrefixes.beans.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + + if (!aOreDictName.equals("beansCocoa")) { + return; + } + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cocoa, 1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java new file mode 100644 index 0000000000..b9926b188b --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java @@ -0,0 +1,187 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.compressorRecipes; +import static gregtech.api.recipe.RecipeMaps.cutterRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +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.MaterialsBotania; +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; + +public class ProcessingBlock implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingBlock() { + OrePrefixes.block.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + + if (aMaterial == Materials.Ichorium) { + return; + } + + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV + && GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) { + + if (aMaterial == MaterialsBotania.Livingrock || aMaterial == MaterialsBotania.Livingwood + || aMaterial == MaterialsBotania.Dreamwood) { + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 9L)) + .fluidInputs( + Materials.Water.getFluid( + Math.max( + 4, + Math.min(1000, ((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS * 30 / 320)))) + .duration(2 * ((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 9L)) + .fluidInputs( + GT_ModHandler.getDistilledWater( + Math.max( + 3, + Math.min(750, ((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS * 30 / 426)))) + .duration(2 * ((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 9L)) + .fluidInputs( + Materials.Lubricant.getFluid( + Math.max( + 1, + Math.min(250, ((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS * 30 / 1280)))) + .duration(((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + } + + else if (aMaterial != Materials.Clay && aMaterial != Materials.Basalt) { + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 9L)) + .fluidInputs( + Materials.Water.getFluid( + Math.max( + 4, + Math.min(1000, ((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS * 30 / 320)))) + .duration(2 * ((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 9L)) + .fluidInputs( + GT_ModHandler.getDistilledWater( + Math.max( + 3, + Math.min(750, ((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS * 30 / 426)))) + .duration(2 * ((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 9L)) + .fluidInputs( + Materials.Lubricant.getFluid( + Math.max( + 1, + Math.min(250, ((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS * 30 / 1280)))) + .duration(((int) Math.max(aMaterial.getMass() * 10L, 1L)) * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + } + } + + ItemStack tStack1 = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L); + ItemStack tStack2 = GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L); + ItemStack tStack3 = GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L); + + GT_ModHandler.removeRecipeDelayed(GT_Utility.copyAmount(1, aStack)); + + if (tStack1 != null) GT_ModHandler + .removeRecipeDelayed(tStack1, tStack1, tStack1, tStack1, tStack1, tStack1, tStack1, tStack1, tStack1); + if (tStack2 != null) GT_ModHandler + .removeRecipeDelayed(tStack2, tStack2, tStack2, tStack2, tStack2, tStack2, tStack2, tStack2, tStack2); + if (tStack3 != null) { + GT_ModHandler + .removeRecipeDelayed(tStack3, tStack3, tStack3, tStack3, tStack3, tStack3, tStack3, tStack3, tStack3); + } + + if (aMaterial.mStandardMoltenFluid != null) { + if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Block.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(1296L)) + .duration(14 * SECONDS + 8 * TICKS) + .eut(8) + .addTo(fluidSolidifierRecipes); + } + } + } + + if (tStack1 != null) tStack1.stackSize = 9; + if (tStack2 != null) tStack2.stackSize = 9; + if (tStack3 != null) tStack3.stackSize = 9; + + if (tStack2 != null) { + GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .itemOutputs(tStack2) + .duration(5 * SECONDS) + .eut(24) + .addTo(hammerRecipes); + } + + if (tStack2 != null && aMaterial != Materials.NetherQuartz) { + if (tStack3 != null) + GT_ModHandler.addShapelessCraftingRecipe(tStack3, new Object[] { OrePrefixes.block.get(aMaterial) }); + GT_ModHandler.addShapelessCraftingRecipe(tStack2, new Object[] { OrePrefixes.block.get(aMaterial) }); + if (tStack1 != null) + GT_ModHandler.addShapelessCraftingRecipe(tStack1, new Object[] { OrePrefixes.block.get(aMaterial) }); + } + + if (!OrePrefixes.block.isIgnored(aMaterial) && tStack1 != null) { + // 9 ingots -> 1 block + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 9L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)) + .duration(15 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 2)) + .addTo(compressorRecipes); + } + + switch (aMaterial.mName) { + case "Mercury" -> System.err.println( + "'blockQuickSilver'?, In which Ice Desert can you actually place this as a solid Block? On Pluto Greg :)"); + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java new file mode 100644 index 0000000000..0d28c417a8 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java @@ -0,0 +1,44 @@ +package gregtech.loaders.oreprocessing; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingBolt implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingBolt() { + OrePrefixes.bolt.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (aMaterial.getProcessingMaterialTierEU() >= TierEU.IV) { + return; + } + + if (!aMaterial.mUnificatable) { + return; + } + + if ((aMaterial.mMaterialInto != aMaterial)) { + return; + } + + if (aMaterial.contains(SubTag.NO_WORKING)) { + return; + } + + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(2, aStack), + GT_Proxy.tBits, + new Object[] { "s ", " X", 'X', OrePrefixes.stick.get(aMaterial) }); + + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java new file mode 100644 index 0000000000..5a6bdfcf13 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java @@ -0,0 +1,441 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.electrolyzerRecipes; +import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.FUEL_TYPE; +import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE; + +import java.util.ArrayList; + +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.TierEU; +import gregtech.api.interfaces.IOreRecipeRegistrator; +import gregtech.api.objects.MaterialStack; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeBuilder; +import gregtech.api.util.GT_RecipeConstants; +import gregtech.api.util.GT_Utility; + +public class ProcessingCell implements IOreRecipeRegistrator { + + public ProcessingCell() { + OrePrefixes.cell.add(this); + OrePrefixes.cellPlasma.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + switch (aPrefix) { + case cell -> { + if (aMaterial == Materials.Empty) { + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + if (aModName.equalsIgnoreCase("AtomicScience")) { + GT_ModHandler.addExtractionRecipe(ItemList.Cell_Empty.get(1L), aStack); + } + } else { + if (aMaterial.mFuelPower > 0) { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + recipeBuilder.itemInputs(GT_Utility.copyAmount(1, aStack)); + if (GT_Utility.getFluidForFilledItem(aStack, true) == null + && GT_Utility.getContainerItem(aStack, true) != null) { + recipeBuilder.itemOutputs(GT_Utility.getContainerItem(aStack, true)); + } + recipeBuilder.metadata(FUEL_VALUE, aMaterial.mFuelPower) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .addTo(GT_RecipeConstants.Fuel); + } + if (!((aMaterial.mMaterialList.size() > 0) && ((aMaterial.mExtraData & 0x3) != 0))) { + break; + } + + int tAllAmount = 0; + for (MaterialStack tMat2 : aMaterial.mMaterialList) { + tAllAmount = (int) (tAllAmount + tMat2.mAmount); + } + long tItemAmount = 0L; + long tCapsuleCount = (long) GT_ModHandler + .getCapsuleCellContainerCountMultipliedWithStackSize(aStack) * -tAllAmount; + long tDensityMultiplier = aMaterial.getDensity() > 3628800L ? aMaterial.getDensity() / 3628800L + : 1L; + ArrayList<ItemStack> tList = new ArrayList<>(); + for (MaterialStack tMat : aMaterial.mMaterialList) { + if (tMat.mAmount <= 0) { + continue; + } + + ItemStack tStack; + if (tMat.mMaterial == Materials.Air) { + tStack = ItemList.Cell_Air.get(tMat.mAmount * tDensityMultiplier / 2L); + } else { + tStack = GT_OreDictUnificator.get(OrePrefixes.dust, tMat.mMaterial, tMat.mAmount); + if (tStack == null) { + tStack = GT_OreDictUnificator.get(OrePrefixes.cell, tMat.mMaterial, tMat.mAmount); + } + } + if (tItemAmount + tMat.mAmount * 3628800L > aStack.getMaxStackSize() * aMaterial.getDensity()) { + continue; + } + + tItemAmount += tMat.mAmount * 3628800L; + + if (tStack == null) { + continue; + } + + tStack.stackSize = ((int) (tStack.stackSize * tDensityMultiplier)); + while ((tStack.stackSize > 64) + && (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCount(tStack) * 64L < 0L + ? tList.size() < 5 + : tList.size() < 6) + && (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCount(tStack) * 64L <= 64L)) { + tCapsuleCount += GT_ModHandler.getCapsuleCellContainerCount(tStack) * 64L; + tList.add(GT_Utility.copyAmount(64, tStack)); + tStack.stackSize -= 64; + } + int tThisCapsuleCount = GT_ModHandler + .getCapsuleCellContainerCountMultipliedWithStackSize(tStack); + if (tStack.stackSize > 0 && tCapsuleCount + tThisCapsuleCount <= 64L) { + if (tCapsuleCount + tThisCapsuleCount < 0L ? tList.size() < 5 : tList.size() < 6) { + tCapsuleCount += tThisCapsuleCount; + tList.add(tStack); + } + } + } + + tItemAmount = GT_Utility.ceilDiv(tItemAmount * tDensityMultiplier, aMaterial.getDensity()); + + if (tList.size() <= 0) { + break; + } + + if ((aMaterial.mExtraData & 0x1) != 0) { + + // Electrolyzer recipe + if (GT_Utility.getFluidForFilledItem(aStack, true) == null) { + // dust stuffed cell e.g. Phosphate, Phosphorous Pentoxide + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + if (tCapsuleCount > 0L) { + recipeBuilder.itemInputs( + GT_Utility.copyAmount(tItemAmount, aStack), + ItemList.Cell_Empty.get(tCapsuleCount)); + } else { + recipeBuilder.itemInputs(GT_Utility.copyAmount(tItemAmount, aStack)); + } + if (tCapsuleCount < 0L) { + tList.add(ItemList.Cell_Empty.get(-tCapsuleCount)); + } + ItemStack[] outputsArray = tList.toArray(new ItemStack[Math.min(tList.size(), 6)]); + recipeBuilder.itemOutputs(outputsArray) + .duration(Math.max(1L, Math.abs(aMaterial.getProtons() * 2L * tItemAmount))) + .eut(Math.min(4, tList.size()) * 30) + .addTo(electrolyzerRecipes); + } else { + long tCellBalance = tCapsuleCount + tItemAmount - 1; + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + if (tCellBalance > 0L) { + recipeBuilder.itemInputs(aStack, ItemList.Cell_Empty.get(tCellBalance)); + } else { + recipeBuilder.itemInputs(aStack); + } + if (tCellBalance < 0L) { + tList.add(ItemList.Cell_Empty.get(-tCellBalance)); + } + ItemStack[] outputsArray = tList.toArray(new ItemStack[Math.min(tList.size(), 6)]); + recipeBuilder.itemOutputs(outputsArray) + .duration(Math.max(1L, Math.abs(aMaterial.getProtons() * 8L * tItemAmount))) + .eut(Math.min(4, tList.size()) * 30) + .addTo(electrolyzerRecipes); + } + } + if ((aMaterial.mExtraData & 0x2) != 0) { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + if (tCapsuleCount > 0L) { + recipeBuilder.itemInputs( + GT_Utility.copyAmount(tItemAmount, aStack), + ItemList.Cell_Empty.get(tCapsuleCount)); + } else { + recipeBuilder.itemInputs(GT_Utility.copyAmount(tItemAmount, aStack)); + } + if (tCapsuleCount < 0L) { + tList.add(ItemList.Cell_Empty.get(-tCapsuleCount)); + } + ItemStack[] outputsArray = tList.toArray(new ItemStack[Math.min(tList.size(), 6)]); + recipeBuilder.itemOutputs(outputsArray) + .duration(Math.max(1L, Math.abs(aMaterial.getMass() * 2L * tItemAmount))) + .eut(5) + .addTo(centrifugeRecipes); + } + } + } + case cellPlasma -> { + if (aMaterial == Materials.Empty) { + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + } else { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + recipeBuilder.itemInputs(GT_Utility.copyAmount(1, aStack)); + if (GT_Utility.getFluidForFilledItem(aStack, true) == null + && GT_Utility.getContainerItem(aStack, true) != null) { + recipeBuilder.itemOutputs(GT_Utility.getContainerItem(aStack, true)); + } + // Switch case to set manual values for specific plasmas and escape the formula based on mass + // when it doesn't make sense for powergen balance. + switch (aMaterial.mName) { + case "Aluminium" -> recipeBuilder.metadata(FUEL_VALUE, 159_744) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Americium" -> recipeBuilder.metadata(FUEL_VALUE, 501_760) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Antimony" -> recipeBuilder.metadata(FUEL_VALUE, 309_760) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Argon" -> recipeBuilder.metadata(FUEL_VALUE, 188_416) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Arsenic" -> recipeBuilder.metadata(FUEL_VALUE, 230_400) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Barium" -> recipeBuilder.metadata(FUEL_VALUE, 342_302) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Beryllium" -> recipeBuilder.metadata(FUEL_VALUE, 110_592) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Bismuth" -> recipeBuilder.metadata(FUEL_VALUE, 425_984) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Boron" -> recipeBuilder.metadata(FUEL_VALUE, 112_640) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Cadmium" -> recipeBuilder.metadata(FUEL_VALUE, 293_601) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Caesium" -> recipeBuilder.metadata(FUEL_VALUE, 332_513) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Calcium" -> recipeBuilder.metadata(FUEL_VALUE, 188_416) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Cerium" -> recipeBuilder.metadata(FUEL_VALUE, 346_931) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Chlorine" -> recipeBuilder.metadata(FUEL_VALUE, 172_032) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Chrome" -> recipeBuilder.metadata(FUEL_VALUE, 202_342) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Cobalt" -> recipeBuilder.metadata(FUEL_VALUE, 217_497) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Copper" -> recipeBuilder.metadata(FUEL_VALUE, 219_340) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Deuterium" -> recipeBuilder.metadata(FUEL_VALUE, 40_960) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Erbium" -> recipeBuilder.metadata(FUEL_VALUE, 376_217) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Europium" -> recipeBuilder.metadata(FUEL_VALUE, 355_635) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Fluorine" -> recipeBuilder.metadata(FUEL_VALUE, 147_456) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Force" -> recipeBuilder.metadata(FUEL_VALUE, 150_000) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Gadolinium" -> recipeBuilder.metadata(FUEL_VALUE, 366_551) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Gallium" -> recipeBuilder.metadata(FUEL_VALUE, 229_376) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Gold" -> recipeBuilder.metadata(FUEL_VALUE, 401_408) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Helium_3" -> recipeBuilder.metadata(FUEL_VALUE, 61_440) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Helium" -> recipeBuilder.metadata(FUEL_VALUE, 81_920) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Holmium" -> recipeBuilder.metadata(FUEL_VALUE, 376_176) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Hydrogen" -> recipeBuilder.metadata(FUEL_VALUE, 20_480) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Indium" -> recipeBuilder.metadata(FUEL_VALUE, 296_509) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Iridium" -> recipeBuilder.metadata(FUEL_VALUE, 397_148) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Iron" -> recipeBuilder.metadata(FUEL_VALUE, 206_438) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Lanthanum" -> recipeBuilder.metadata(FUEL_VALUE, 344_801) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Lead" -> recipeBuilder.metadata(FUEL_VALUE, 423_936) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Lithium" -> recipeBuilder.metadata(FUEL_VALUE, 100_352) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Lutetium" -> recipeBuilder.metadata(FUEL_VALUE, 381_296) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Magnesium" -> recipeBuilder.metadata(FUEL_VALUE, 152_371) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Manganese" -> recipeBuilder.metadata(FUEL_VALUE, 202_752) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Mercury" -> recipeBuilder.metadata(FUEL_VALUE, 409_600) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Molybdenum" -> recipeBuilder.metadata(FUEL_VALUE, 272_384) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Neodymium" -> recipeBuilder.metadata(FUEL_VALUE, 347_996) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Nickel" -> recipeBuilder.metadata(FUEL_VALUE, 213_811) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Niobium" -> recipeBuilder.metadata(FUEL_VALUE, 269_516) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Nitrogen" -> recipeBuilder.metadata(FUEL_VALUE, 129_024) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Osmium" -> recipeBuilder.metadata(FUEL_VALUE, 393_659) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Oxygen" -> recipeBuilder.metadata(FUEL_VALUE, 131_072) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Palladium" -> recipeBuilder.metadata(FUEL_VALUE, 282_214) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Phosphor" -> recipeBuilder.metadata(FUEL_VALUE, 165_888) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Platinum" -> recipeBuilder.metadata(FUEL_VALUE, 399_360) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Plutonium241" -> recipeBuilder.metadata(FUEL_VALUE, 497_664) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Plutonium" -> recipeBuilder.metadata(FUEL_VALUE, 503_808) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Potassium" -> recipeBuilder.metadata(FUEL_VALUE, 183_705) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Praseodymium" -> recipeBuilder.metadata(FUEL_VALUE, 346_931) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Promethium" -> recipeBuilder.metadata(FUEL_VALUE, 347_996) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Radon" -> recipeBuilder.metadata(FUEL_VALUE, 450_560) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Rubidium" -> recipeBuilder.metadata(FUEL_VALUE, 243_712) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Samarium" -> recipeBuilder.metadata(FUEL_VALUE, 353_280) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Scandium" -> recipeBuilder.metadata(FUEL_VALUE, 193_536) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Silicon" -> recipeBuilder.metadata(FUEL_VALUE, 160_563) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Silver" -> recipeBuilder.metadata(FUEL_VALUE, 282_685) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Sodium" -> recipeBuilder.metadata(FUEL_VALUE, 148_684) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Strontium" -> recipeBuilder.metadata(FUEL_VALUE, 249_446) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Sulfur" -> recipeBuilder.metadata(FUEL_VALUE, 170_393) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Tantalum" -> recipeBuilder.metadata(FUEL_VALUE, 384_000) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Terbium" -> recipeBuilder.metadata(FUEL_VALUE, 368_885) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Thorium" -> recipeBuilder.metadata(FUEL_VALUE, 471_040) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Thulium" -> recipeBuilder.metadata(FUEL_VALUE, 378_470) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Tin" -> recipeBuilder.metadata(FUEL_VALUE, 150_000) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Titanium" -> recipeBuilder.metadata(FUEL_VALUE, 196_608) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Tritium" -> recipeBuilder.metadata(FUEL_VALUE, 61_440) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Tungsten" -> recipeBuilder.metadata(FUEL_VALUE, 384_778) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Uranium235" -> recipeBuilder.metadata(FUEL_VALUE, 481_280) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Uranium" -> recipeBuilder.metadata(FUEL_VALUE, 487_424) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Vanadium" -> recipeBuilder.metadata(FUEL_VALUE, 198_451) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Ytterbium" -> recipeBuilder.metadata(FUEL_VALUE, 379_695) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Yttrium" -> recipeBuilder.metadata(FUEL_VALUE, 255_180) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + case "Zinc" -> recipeBuilder.metadata(FUEL_VALUE, 226_304) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + default -> recipeBuilder + .metadata(FUEL_VALUE, (int) Math.max(1024L, 1024L * aMaterial.getMass())) + .metadata(FUEL_TYPE, 4) + .addTo(GT_RecipeConstants.Fuel); + } + if (GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L)) + .duration(((int) Math.max(aMaterial.getMass() * 2L, 1L)) * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(vacuumFreezerRecipes); + } + } + } + default -> {} + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCircuit.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCircuit.java new file mode 100644 index 0000000000..c5e0e9ce0d --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCircuit.java @@ -0,0 +1,44 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.enums.Mods.GregTech; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; + +public class ProcessingCircuit implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingCircuit() { + OrePrefixes.circuit.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (gregtech.api.util.GT_OreDictUnificator.isBlacklisted(aStack) && aModName.equals(GregTech.ID)) return; + switch (aMaterial.mName) { + case "Good", "Data", "Elite", "Master", "Ultimate", "Superconductor", "Infinite", "Bio" -> { + if (!GT_OreDictUnificator.isBlacklisted(aStack) && !aModName.equals(GregTech.ID)) + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + } + case "Primitive", "Advanced" -> GT_ModHandler.removeRecipeByOutputDelayed(aStack); + case "Basic" -> { + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + GT_ModHandler.addCraftingRecipe( + aStack, + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "RIR", "VBV", "CCC", 'R', ItemList.Circuit_Parts_Resistor.get(1), 'C', + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.RedAlloy, 1), 'V', + ItemList.Circuit_Parts_Vacuum_Tube.get(1), 'B', ItemList.Circuit_Board_Coated_Basic.get(1), 'I', + ItemList.IC2_Item_Casing_Steel.get(1) }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_ModHandler.getIC2Item("electronicCircuit", 1L), + new Object[] { ItemList.Circuit_Integrated.getWildcard(1L) }); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCompressed.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCompressed.java new file mode 100644 index 0000000000..4ef818df5b --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCompressed.java @@ -0,0 +1,25 @@ +package gregtech.loaders.oreprocessing; + +import net.minecraft.item.ItemStack; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.IOreRecipeRegistrator; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_ModHandler; + +public class ProcessingCompressed implements IOreRecipeRegistrator { + + public ProcessingCompressed() { + OrePrefixes.compressed.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + GregTech_API + .registerCover(aStack, TextureFactory.of(aMaterial.mIconSet.mTextures[72], aMaterial.mRGBa, false), null); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java new file mode 100644 index 0000000000..438da254a2 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java @@ -0,0 +1,464 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.enums.Mods.AppliedEnergistics2; +import static gregtech.api.enums.Mods.BuildCraftSilicon; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.laserEngraverRecipes; +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 net.minecraft.init.Blocks; +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.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +@SuppressWarnings("RedundantLabeledSwitchRuleCodeBlock") +public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingCrafting() { + OrePrefixes.crafting.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + switch (aOreDictName) { + case "craftingQuartz" -> { + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.redstone_torch, 3, 32767), GT_Utility.copyAmount(1, aStack)) + .itemOutputs(new ItemStack(net.minecraft.init.Items.comparator, 1, 0)) + .fluidInputs(Materials.Concrete.getMolten(144L)) + .duration(2 * SECONDS) + .eut(20) + .addTo(assemblerRecipes); + } + case "craftingLensBlue" -> { + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.block, Materials.Iron, 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 13)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.block, Materials.WroughtIron, 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 13)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.IC2_LapotronCrystal.getWildcard(1L), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Parts_Crystal_Chip_Master.get(3L)) + .requiresCleanRoom() + .duration(45 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Chip_CrystalCPU.get(1L), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Chip_CrystalSoC.get(1)) + .requiresCleanRoom() + .duration(30 * SECONDS) + .eut(40000) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_PIC.get(1)) + .requiresCleanRoom() + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_PIC.get(4)) + .requiresCleanRoom() + .duration(40 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_QPIC.get(1)) + .requiresCleanRoom() + .duration(2 * MINUTES) + .eut(TierEU.RECIPE_UV) + .addTo(laserEngraverRecipes); + + } + case "craftingLensYellow" -> { + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.block, Materials.Iron, 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 14)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.block, Materials.WroughtIron, 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 14)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_LPIC.get(1)) + .duration(40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_LPIC.get(4)) + .requiresCleanRoom() + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_SoC.get(1)) + .requiresCleanRoom() + .duration(45 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_SoC.get(4)) + .requiresCleanRoom() + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_SoC.get(8)) + .requiresCleanRoom() + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(laserEngraverRecipes); + } + case "craftingLensOrange" -> { + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_Simple_SoC.get(1)) + .duration(15 * SECONDS) + .eut(64) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_Simple_SoC.get(4)) + .duration(15 * SECONDS) + .eut(256) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_Simple_SoC.get(16)) + .duration(15 * SECONDS) + .eut(1024) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_Simple_SoC.get(64)) + .duration(15 * SECONDS) + .eut(4096) + .addTo(laserEngraverRecipes); + + } + case "craftingLensCyan" -> { + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.block, Materials.Iron, 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 15)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.block, Materials.WroughtIron, 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 15)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_Ram.get(1)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_Ram.get(4)) + .requiresCleanRoom() + .duration(45 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_Ram.get(8)) + .requiresCleanRoom() + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_Ram.get(16)) + .requiresCleanRoom() + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_Ram.get(32)) + .requiresCleanRoom() + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LuV) + .addTo(laserEngraverRecipes); + + } + case "craftingLensRed" -> { + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Redstone, 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(BuildCraftSilicon.ID, "redstoneChipset", 1L, 0)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.RedAlloy, 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EtchedLowVoltageWiring", 1L, 0)) + .duration(10 * SECONDS) + .eut(16) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_ILC.get(1)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_ILC.get(4)) + .requiresCleanRoom() + .duration(45 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_ILC.get(8)) + .requiresCleanRoom() + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_NPIC.get(1)) + .requiresCleanRoom() + .duration(1 * MINUTES + 30 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_NPIC.get(4)) + .requiresCleanRoom() + .duration(1 * MINUTES + 15 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(laserEngraverRecipes); + + } + case "craftingLensGreen" -> { + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Parts_Crystal_Chip_Elite.get(1L), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Chip_CrystalCPU.get(1)) + .requiresCleanRoom() + .duration(30 * SECONDS) + .eut(10000) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Chip_CrystalSoC.get(1L), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Chip_CrystalSoC2.get(1)) + .requiresCleanRoom() + .duration(60 * SECONDS) + .eut(80000) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_ULPIC.get(2)) + .duration(30 * SECONDS) + .eut(30) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_ULPIC.get(8)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_SoC2.get(1)) + .requiresCleanRoom() + .duration(1 * MINUTES + 30 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_SoC2.get(2)) + .requiresCleanRoom() + .duration(1 * MINUTES + 15 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_SoC2.get(4)) + .requiresCleanRoom() + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(laserEngraverRecipes); + } + case "craftingLensWhite" -> { + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.block, Materials.Iron, 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 19)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.block, Materials.WroughtIron, 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 19)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.sandstone, 1, 2), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(new ItemStack(Blocks.sandstone, 1, 1)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(16) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.stone, 1, 0), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(new ItemStack(Blocks.stonebrick, 1, 3)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(16) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.quartz_block, 1, 0), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(new ItemStack(Blocks.quartz_block, 1, 1)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(16) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "tile.BlockQuartz", 1L), + GT_Utility.copyAmount(0, aStack)) + .itemOutputs(GT_ModHandler.getModItem(AppliedEnergistics2.ID, "tile.BlockQuartzChiseled", 1L)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(16) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_CPU.get(1)) + .requiresCleanRoom() + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_CPU.get(4)) + .requiresCleanRoom() + .duration(45 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_CPU.get(8)) + .requiresCleanRoom() + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_CPU.get(16)) + .requiresCleanRoom() + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(laserEngraverRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) + .itemOutputs(ItemList.Circuit_Wafer_CPU.get(32)) + .requiresCleanRoom() + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LuV) + .addTo(laserEngraverRecipes); + + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrate.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrate.java new file mode 100644 index 0000000000..105b5c8f13 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrate.java @@ -0,0 +1,132 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.packagerRecipes; +import static gregtech.api.recipe.RecipeMaps.unpackagerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +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_OreDictUnificator; +import gregtech.common.GT_Proxy; + +public class ProcessingCrate implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingCrate() { + OrePrefixes.crateGtDust.add(this); + OrePrefixes.crateGtIngot.add(this); + OrePrefixes.crateGtGem.add(this); + OrePrefixes.crateGtPlate.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + boolean aSpecialRecipeReq2 = aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_WORKING); + switch (aPrefix) { + case crateGtDust -> { + if (GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 16L), + ItemList.Crate_Empty.get(1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.crateGtDust, aMaterial, 1L)) + .duration(5 * SECONDS) + .eut(8) + .addTo(packagerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crateGtDust, aMaterial, 1L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 16L), + ItemList.Crate_Empty.get(1L)) + .duration(40 * SECONDS) + .eut(1) + .addTo(unpackagerRecipes); + } + if (aSpecialRecipeReq2) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 16L), + GT_Proxy.tBits, + new Object[] { "Xc", 'X', OrePrefixes.crateGtDust.get(aMaterial) }); + } + case crateGtIngot -> { + if (GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 16L), + ItemList.Crate_Empty.get(1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.crateGtIngot, aMaterial, 1L)) + .duration(5 * SECONDS) + .eut(8) + .addTo(packagerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crateGtIngot, aMaterial, 1L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 16L), + ItemList.Crate_Empty.get(1L)) + .duration(40 * SECONDS) + .eut(1) + .addTo(unpackagerRecipes); + } + if (aSpecialRecipeReq2) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 16L), + GT_Proxy.tBits, + new Object[] { "Xc", 'X', OrePrefixes.crateGtIngot.get(aMaterial) }); + } + case crateGtGem -> { + if (GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 16L), + ItemList.Crate_Empty.get(1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.crateGtGem, aMaterial, 1L)) + .duration(5 * SECONDS) + .eut(8) + .addTo(packagerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crateGtGem, aMaterial, 1L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 16L), + ItemList.Crate_Empty.get(1L)) + .duration(40 * SECONDS) + .eut(1) + .addTo(unpackagerRecipes); + } + if (aSpecialRecipeReq2) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 16L), + GT_Proxy.tBits, + new Object[] { "Xc", 'X', OrePrefixes.crateGtGem.get(aMaterial) }); + } + case crateGtPlate -> { + if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 16L), + ItemList.Crate_Empty.get(1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.crateGtPlate, aMaterial, 1L)) + .duration(5 * SECONDS) + .eut(8) + .addTo(packagerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crateGtPlate, aMaterial, 1L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 16L), + ItemList.Crate_Empty.get(1L)) + .duration(40 * SECONDS) + .eut(1) + .addTo(unpackagerRecipes); + } + if (aSpecialRecipeReq2) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 16L), + GT_Proxy.tBits, + new Object[] { "Xc", 'X', OrePrefixes.crateGtPlate.get(aMaterial) }); + } + default -> {} + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrop.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrop.java new file mode 100644 index 0000000000..92b5ae9cda --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrop.java @@ -0,0 +1,154 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.enums.Mods.IndustrialCraft2; +import static gregtech.api.recipe.RecipeMaps.brewingRecipes; +import static gregtech.api.recipe.RecipeMaps.compressorRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.recipe.RecipeMaps.slicerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import net.minecraftforge.fluids.Fluid; +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 gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; + +public class ProcessingCrop implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingCrop() { + OrePrefixes.crop.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + net.minecraft.item.ItemStack aStack) { + // Compressor recipes + GT_Values.RA.stdBuilder() + .itemInputs(gregtech.api.util.GT_Utility.copyAmount(8, aStack)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + Fluid[] waterArray; + + if (IndustrialCraft2.isModLoaded()) { + waterArray = new Fluid[] { FluidRegistry.WATER, GT_ModHandler.getDistilledWater(1L) + .getFluid() }; + } else { + waterArray = new Fluid[] { FluidRegistry.WATER }; + } + + switch (aOreDictName) { + case "cropTea" -> { + for (Fluid tFluid : waterArray) { + GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .fluidInputs(new FluidStack(tFluid, 750)) + .fluidOutputs(new FluidStack(FluidRegistry.getFluid("potion.tea"), 750)) + .duration(6 * SECONDS + 8 * TICKS) + .eut(4) + .addTo(brewingRecipes); + } + } + case "cropGrape" -> { + for (Fluid tFluid : waterArray) { + GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .fluidInputs(new FluidStack(tFluid, 750)) + .fluidOutputs(new FluidStack(FluidRegistry.getFluid("potion.grapejuice"), 750)) + .duration(6 * SECONDS + 8 * TICKS) + .eut(4) + .addTo(brewingRecipes); + } + } + case "cropChilipepper" -> GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Chili, 1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + case "cropCoffee" -> GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coffee, 1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + case "cropPotato" -> { + GT_Values.RA.stdBuilder() + .itemInputs(aStack, ItemList.Shape_Slicer_Flat.get(0)) + .itemOutputs(ItemList.Food_Raw_PotatoChips.get(1L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(4) + .addTo(slicerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(aStack, ItemList.Shape_Slicer_Stripes.get(0L)) + .itemOutputs(ItemList.Food_Raw_Fries.get(1L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(4) + .addTo(slicerRecipes); + + for (Fluid tFluid : waterArray) { + GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .fluidInputs(new FluidStack(tFluid, 750)) + .fluidOutputs(new FluidStack(FluidRegistry.getFluid("potion.potatojuice"), 750)) + .duration(6 * SECONDS + 8 * TICKS) + .eut(4) + .addTo(brewingRecipes); + } + } + case "cropLemon" -> { + GT_Values.RA.stdBuilder() + .itemInputs(aStack, ItemList.Shape_Slicer_Flat.get(0)) + .itemOutputs(ItemList.Food_Sliced_Lemon.get(4L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(4) + .addTo(slicerRecipes); + + for (Fluid tFluid : waterArray) { + GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .fluidInputs(new FluidStack(tFluid, 750)) + .fluidOutputs(new FluidStack(FluidRegistry.getFluid("potion.lemonjuice"), 750)) + .duration(6 * SECONDS + 8 * TICKS) + .eut(4) + .addTo(brewingRecipes); + } + + GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .fluidInputs(new FluidStack(FluidRegistry.getFluid("potion.vodka"), 750)) + .fluidOutputs(new FluidStack(FluidRegistry.getFluid("potion.leninade"), 750)) + .duration(6 * SECONDS + 8 * TICKS) + .eut(4) + .addTo(brewingRecipes); + } + case "cropTomato" -> GT_Values.RA.stdBuilder() + .itemInputs(aStack, ItemList.Shape_Slicer_Flat.get(0)) + .itemOutputs(ItemList.Food_Sliced_Tomato.get(4L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(4) + .addTo(slicerRecipes); + case "cropCucumber" -> GT_Values.RA.stdBuilder() + .itemInputs(aStack, ItemList.Shape_Slicer_Flat.get(0)) + .itemOutputs(ItemList.Food_Sliced_Cucumber.get(4L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(4) + .addTo(slicerRecipes); + case "cropOnion" -> GT_Values.RA.stdBuilder() + .itemInputs(aStack, ItemList.Shape_Slicer_Flat.get(0)) + .itemOutputs(ItemList.Food_Sliced_Onion.get(4L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(4) + .addTo(slicerRecipes); + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedOre.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedOre.java new file mode 100644 index 0000000000..a730a1849b --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedOre.java @@ -0,0 +1,107 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.recipe.RecipeMaps.sifterRecipes; +import static gregtech.api.recipe.RecipeMaps.thermalCentrifugeRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingCrushedOre implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingCrushedOre() { + OrePrefixes.crushedCentrifuged.add(this); + OrePrefixes.crushedPurified.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + switch (aPrefix) { + case crushedCentrifuged -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L)) + .duration(10 * TICKS) + .eut(16) + .addTo(hammerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), + GT_OreDictUnificator.get( + OrePrefixes.dust, + GT_Utility.selectItemInList(2, aMaterial.mMacerateInto, aMaterial.mOreByProducts), + 1L)) + .outputChances(10000, 1000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + } + case crushedPurified -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get( + OrePrefixes.crushedCentrifuged, + aMaterial.mMacerateInto, + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), + 1L), + GT_OreDictUnificator.get( + OrePrefixes.dust, + GT_Utility.selectItemInList(1, aMaterial.mMacerateInto, aMaterial.mOreByProducts), + 1L)) + .outputChances(10000, 1111) + .duration(25 * SECONDS) + .eut(48) + .addTo(thermalCentrifugeRecipes); + + ItemStack tGem = GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L); + if (tGem == null) { + break; + } + + switch (aMaterial.mName) { + case "Tanzanite", "Sapphire", "Olivine", "GreenSapphire", "Opal", "Amethyst", "Emerald", "Ruby", "Amber", "Diamond", "FoolsRuby", "BlueTopaz", "GarnetRed", "Topaz", "Jasper", "GarnetYellow" -> GT_Values.RA + .stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, tGem, 1L), + GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, tGem, 1L), + tGem, + GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, tGem, 1L), + GT_OreDictUnificator.get(OrePrefixes.gemChipped, aMaterial, tGem, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, tGem, 1L)) + .outputChances(300, 1200, 4500, 1400, 2800, 3500) + .duration(40 * SECONDS) + .eut(16) + .addTo(sifterRecipes); + default -> GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, tGem, 1L), + GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, tGem, 1L), + tGem, + GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, tGem, 1L), + GT_OreDictUnificator.get(OrePrefixes.gemChipped, aMaterial, tGem, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, tGem, 1L)) + .outputChances(100, 400, 1500, 2000, 4000, 5000) + .duration(40 * SECONDS) + .eut(16) + .addTo(sifterRecipes); + } + + } + default -> {} + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java new file mode 100644 index 0000000000..ec8fd12a74 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java @@ -0,0 +1,49 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingCrystallized implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingCrystallized() { + OrePrefixes.crystal.add(this); + OrePrefixes.crystalline.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (aMaterial.mMacerateInto == null) { + return; + } + + if (GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1) == null) { + return; + } + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L)) + .duration(10 * TICKS) + .eut(16) + .addTo(hammerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java new file mode 100644 index 0000000000..b3aad4e25c --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java @@ -0,0 +1,136 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes; +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.recipe.RecipeMaps.thermalCentrifugeRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +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_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingDirty implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingDirty() { + OrePrefixes.clump.add(this); + OrePrefixes.shard.add(this); + OrePrefixes.crushed.add(this); + OrePrefixes.dirtyGravel.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + net.minecraft.item.ItemStack aStack) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial.mMacerateInto, 1L)) + .duration(10) + .eut(16) + .addTo(hammerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get( + OrePrefixes.dustImpure, + aMaterial.mMacerateInto, + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), + 1L), + GT_OreDictUnificator.get( + OrePrefixes.dust, + GT_Utility.selectItemInList(0, aMaterial.mMacerateInto, aMaterial.mOreByProducts), + 1L)) + .outputChances(10000, 1000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_ModHandler.addOreWasherRecipe( + GT_Utility.copyAmount(1, aStack), + new int[] { 10000, 1111, 10000 }, + 1000, + GT_OreDictUnificator.get( + aPrefix == OrePrefixes.crushed ? OrePrefixes.crushedPurified : OrePrefixes.dustPure, + aMaterial, + 1L), + GT_OreDictUnificator.get( + OrePrefixes.dust, + GT_Utility.selectItemInList(0, aMaterial.mMacerateInto, aMaterial.mOreByProducts), + 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L)); + + OrePrefixes prefix = aPrefix == OrePrefixes.crushed ? OrePrefixes.crushedCentrifuged : OrePrefixes.dust; + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(prefix, aMaterial, 1L), + GT_OreDictUnificator.get( + OrePrefixes.dust, + GT_Utility.selectItemInList(1, aMaterial.mMacerateInto, aMaterial.mOreByProducts), + 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L)) + .outputChances(10000, 1111, 10000) + .duration(25 * SECONDS) + .eut(48) + .addTo(thermalCentrifugeRecipes); + + addChemicalBathRecipes(aMaterial, aMaterial, aStack, aPrefix); + + for (Materials tMaterial : aMaterial.mOreByProducts) { + addChemicalBathRecipes(aMaterial, tMaterial, aStack, aPrefix); + } + } + + private void addChemicalBathRecipes(Materials material, Materials byproduct, ItemStack stack, OrePrefixes prefix) { + OrePrefixes chemicalBathPrefix = prefix == OrePrefixes.crushed ? OrePrefixes.crushedPurified + : OrePrefixes.dustPure; + + if (byproduct.contains(SubTag.WASHING_MERCURY)) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, stack)) + .itemOutputs( + GT_OreDictUnificator.get(chemicalBathPrefix, material, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, byproduct.mMacerateInto, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L)) + .outputChances(10000, 7000, 4000) + .fluidInputs(Materials.Mercury.getFluid(1000L)) + .duration(40 * SECONDS) + .eut(8) + .addTo(chemicalBathRecipes); + } + if (byproduct.contains(SubTag.WASHING_MERCURY_99_PERCENT)) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, stack)) + .itemOutputs( + GT_OreDictUnificator.get(chemicalBathPrefix, material, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, byproduct.mMacerateInto, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L)) + .outputChances(10000, 9900, 4000) + .fluidInputs(Materials.Mercury.getFluid(1000L)) + .duration(40 * SECONDS) + .eut(8) + .addTo(chemicalBathRecipes); + } + if (byproduct.contains(SubTag.WASHING_SODIUMPERSULFATE)) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, stack)) + .itemOutputs( + GT_OreDictUnificator.get(chemicalBathPrefix, material, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, byproduct.mMacerateInto, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L)) + .outputChances(10000, 7000, 4000) + .fluidInputs(Materials.SodiumPersulfate.getFluid(100L)) + .duration(40 * SECONDS) + .eut(8) + .addTo(chemicalBathRecipes); + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java new file mode 100644 index 0000000000..7cb26f7c36 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java @@ -0,0 +1,630 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.autoclaveRecipes; +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.cannerRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.compressorRecipes; +import static gregtech.api.recipe.RecipeMaps.electroMagneticSeparatorRecipes; +import static gregtech.api.recipe.RecipeMaps.electrolyzerRecipes; +import static gregtech.api.recipe.RecipeMaps.implosionRecipes; +import static gregtech.api.recipe.RecipeMaps.packagerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; +import static gregtech.api.util.GT_RecipeConstants.FUEL_TYPE; +import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE; + +import java.util.ArrayList; + +import net.minecraft.init.Blocks; +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.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.objects.MaterialStack; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeBuilder; +import gregtech.api.util.GT_RecipeConstants; +import gregtech.api.util.GT_RecipeRegistrator; +import gregtech.api.util.GT_Utility; + +public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingDust() { + OrePrefixes.dust.add(this); + OrePrefixes.dustPure.add(this); + OrePrefixes.dustImpure.add(this); + OrePrefixes.dustRefined.add(this); + OrePrefixes.dustSmall.add(this); + OrePrefixes.dustTiny.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + switch (aPrefix) { + case dust -> { + if (aMaterial.mFuelPower > 0) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .metadata(FUEL_VALUE, aMaterial.mFuelPower) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .addTo(GT_RecipeConstants.Fuel); + } + if ((GT_Utility.getFluidForFilledItem(GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L), true) + == null) && (GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L) != null)) { + GT_Values.RA.stdBuilder() + .itemInputs(aStack, ItemList.Cell_Empty.get(1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L)) + .duration(5 * SECONDS) + .eut(1) + .addTo(cannerRecipes); + } + if (!aMaterial.mBlastFurnaceRequired) { + GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); + if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) { + GT_RecipeRegistrator.registerReverseArcSmelting( + GT_Utility.copyAmount(1, aStack), + aMaterial, + aPrefix.mMaterialAmount, + null, + null, + null); + } + } + ItemStack tDustStack; + if ((null != (tDustStack = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L))) + && (!aMaterial.contains(SubTag.NO_SMELTING))) { + if (aMaterial.mBlastFurnaceRequired) { + GT_ModHandler.removeFurnaceSmelting(aStack); + if (aMaterial.mAutoGenerateBlastFurnaceRecipes) { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + recipeBuilder + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)); + if (aMaterial.mBlastFurnaceTemp > 1750) { + recipeBuilder.itemOutputs( + GT_OreDictUnificator + .get(OrePrefixes.ingotHot, aMaterial.mSmeltInto, tDustStack, 1L)); + } else { + recipeBuilder.itemOutputs(GT_Utility.copyAmount(1, tDustStack)); + } + recipeBuilder + .duration( + (Math.max(aMaterial.getMass() / 40L, 1L) * aMaterial.mBlastFurnaceTemp) * TICKS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, (int) aMaterial.mBlastFurnaceTemp) + .addTo(blastFurnaceRecipes); + } + } else { + GT_ModHandler.addSmeltingRecipe(aStack, tDustStack); + } + } else if (!aMaterial.contains(SubTag.NO_WORKING)) { + if ((!OrePrefixes.block.isIgnored(aMaterial)) + && (null == GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + && GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L) != null) { + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + } + // This is so disgustingly bad. + if (((OrePrefixes.block.isIgnored(aMaterial)) + || (null == GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L))) + && (aMaterial != Materials.GraniteRed) + && (aMaterial != Materials.GraniteBlack) + && (aMaterial != Materials.Basalt) + && (aMaterial != Materials.Marble) + && (aMaterial != Materials.Glass) + && (aMaterial != Materials.Obsidian) + && (aMaterial != Materials.Glowstone) + && (aMaterial != Materials.Paper) + && (aMaterial != MaterialsUEVplus.TranscendentMetal) + && (aMaterial != Materials.Clay)) { + // compressor recipe + { + if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + } + } + } + } + if ((aMaterial.mMaterialList.size() > 0) && ((aMaterial.mExtraData & 0x3) != 0)) { + long tItemAmount = 0L; + long tCapsuleCount = 0L; + long tDensityMultiplier = aMaterial.getDensity() > 3628800L ? aMaterial.getDensity() / 3628800L + : 1L; + ArrayList<ItemStack> tList = new ArrayList<>(); + for (MaterialStack tMat : aMaterial.mMaterialList) if (tMat.mAmount > 0L) { + if (tMat.mMaterial == Materials.Air) { + tDustStack = ItemList.Cell_Air.get(tMat.mAmount / 2L); + } else { + tDustStack = GT_OreDictUnificator.get(OrePrefixes.dust, tMat.mMaterial, tMat.mAmount); + if (tDustStack == null) + tDustStack = GT_OreDictUnificator.get(OrePrefixes.cell, tMat.mMaterial, tMat.mAmount); + } + if (tItemAmount + tMat.mAmount * 3628800L + <= aStack.getMaxStackSize() * aMaterial.getDensity()) { + tItemAmount += tMat.mAmount * 3628800L; + if (tDustStack != null) { + tDustStack.stackSize = ((int) (tDustStack.stackSize * tDensityMultiplier)); + while ((tDustStack.stackSize > 64) && (tList.size() < 6) + && (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCount(tDustStack) * 64L + <= 64L)) { + tCapsuleCount += GT_ModHandler.getCapsuleCellContainerCount(tDustStack) * 64L; + tList.add(GT_Utility.copyAmount(64, tDustStack)); + tDustStack.stackSize -= 64; + } + if ((tDustStack.stackSize > 0) && (tList.size() < 6) + && (tCapsuleCount + + GT_ModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(tDustStack) + <= 64L)) { + tCapsuleCount += GT_ModHandler + .getCapsuleCellContainerCountMultipliedWithStackSize(tDustStack); + tList.add(tDustStack); + } + } + } + } + tItemAmount = (tItemAmount * tDensityMultiplier % aMaterial.getDensity() > 0L ? 1 : 0) + + tItemAmount * tDensityMultiplier / aMaterial.getDensity(); + if (tList.size() > 0) { + FluidStack tFluid = null; + int tList_sS = tList.size(); + for (int i = 0; i < tList_sS; i++) { + if ((!ItemList.Cell_Air.isStackEqual(tList.get(i))) + && ((tFluid = GT_Utility.getFluidForFilledItem(tList.get(i), true)) != null)) { + tFluid.amount *= tList.get(i).stackSize; + tCapsuleCount -= GT_ModHandler + .getCapsuleCellContainerCountMultipliedWithStackSize(tList.get(i)); + tList.remove(i); + break; + } + } + if ((aMaterial.mExtraData & 0x1) != 0) { + if (tList.size() > 0 || tFluid != null) { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + if (tCapsuleCount > 0L) { + recipeBuilder.itemInputs( + GT_Utility.copyAmount(tItemAmount, aStack), + ItemList.Cell_Empty.get(tCapsuleCount)); + } else { + recipeBuilder.itemInputs(GT_Utility.copyAmount(tItemAmount, aStack)); + } + if (tList.size() > 0) { + ItemStack[] outputsArray = tList.toArray(new ItemStack[Math.min(tList.size(), 6)]); + recipeBuilder.itemOutputs(outputsArray); + } + if (tFluid != null) { + recipeBuilder.fluidOutputs(tFluid); + } + recipeBuilder + .duration(Math.max(1L, Math.abs(aMaterial.getProtons() * 2L * tItemAmount))) + .eut(Math.min(4, tList.size()) * 30) + .addTo(electrolyzerRecipes); + } + } + if ((aMaterial.mExtraData & 0x2) != 0) { + if (tList.size() > 0 || tFluid != null) { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + if (tCapsuleCount > 0L) { + recipeBuilder.itemInputs( + GT_Utility.copyAmount(tItemAmount, aStack), + ItemList.Cell_Empty.get(tCapsuleCount)); + } else { + recipeBuilder.itemInputs(GT_Utility.copyAmount(tItemAmount, aStack)); + } + if (tList.size() > 0) { + ItemStack[] outputsArray = tList.toArray(new ItemStack[Math.min(tList.size(), 6)]); + recipeBuilder.itemOutputs(outputsArray); + } + if (tFluid != null) { + recipeBuilder.fluidOutputs(tFluid); + } + recipeBuilder.duration(Math.max(1L, Math.abs(aMaterial.getMass() * 4L * tItemAmount))) + .eut(Math.min(4, tList.size()) * 5) + .addTo(centrifugeRecipes); + } + } + } + } + if (aMaterial.contains(SubTag.CRYSTALLISABLE) + && GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(7000) + .fluidInputs(Materials.Water.getFluid(200L)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(24) + .addTo(autoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(9000) + .fluidInputs(GT_ModHandler.getDistilledWater(100L)) + .duration(1 * MINUTES + 15 * SECONDS) + .eut(24) + .addTo(autoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(10000) + .fluidInputs(Materials.Void.getMolten(36L)) + .duration(1 * MINUTES) + .eut(24) + .addTo(autoclaveRecipes); + } + switch (aMaterial.mName) { + case "NULL", "Mercury", "Coal": + break; + case "Glass": + GT_ModHandler.addSmeltingRecipe( + GT_Utility.copyAmount(1, aStack), + new ItemStack(net.minecraft.init.Blocks.glass)); + break; + case "NetherQuartz": + case "Quartz": + case "CertusQuartz": + GT_ModHandler.removeFurnaceSmelting(aStack); + break; + case "MeatRaw": + GT_ModHandler.addSmeltingRecipe( + GT_Utility.copyAmount(1, aStack), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.MeatCooked, 1L)); + break; + case "Oilsands": + centrifugeRecipes.addRecipe( + true, + new ItemStack[] { GT_Utility.copyAmount(1, aStack) }, + null, + null, + null, + new FluidStack[] { Materials.OilHeavy.getFluid(1000) }, + 660, + 8, + 0); + break; + case "HydratedCoal": + GT_ModHandler.addSmeltingRecipe( + GT_Utility.copyAmount(1, aStack), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 1L)); + break; + case "Diamond": { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), ItemList.Block_Powderbarrel.get(64)) + .itemOutputs( + ItemList.IC2_Industrial_Diamond.get(3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(4, aStack), + GT_ModHandler.getIC2Item("dynamite", 16, null)) + .itemOutputs( + ItemList.IC2_Industrial_Diamond.get(3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), new ItemStack(Blocks.tnt, 32)) + .itemOutputs( + ItemList.IC2_Industrial_Diamond.get(3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), GT_ModHandler.getIC2Item("industrialTnt", 8)) + .itemOutputs( + ItemList.IC2_Industrial_Diamond.get(3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + } + break; + case "Opal": + case "Olivine": + case "Emerald": + case "Ruby": + case "Sapphire": + case "GreenSapphire": + case "Topaz": + case "BlueTopaz": + case "Tanzanite": + case "Amethyst": { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), ItemList.Block_Powderbarrel.get(48)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(4, aStack), + GT_ModHandler.getIC2Item("dynamite", 12, null)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), new ItemStack(Blocks.tnt, 24)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), GT_ModHandler.getIC2Item("industrialTnt", 6)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + } + break; + case "FoolsRuby": + case "GarnetRed": + case "GarnetYellow": + case "Jasper": + case "Amber": + case "Monazite": + case "Forcicium": + case "Forcillium": + case "Force": { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), ItemList.Block_Powderbarrel.get(32)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), GT_ModHandler.getIC2Item("dynamite", 8, null)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), new ItemStack(Blocks.tnt, 16)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), GT_ModHandler.getIC2Item("industrialTnt", 4)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + } + } + } + case dustPure, dustImpure, dustRefined -> { + Materials tByProduct = GT_Utility.selectItemInList( + aPrefix == OrePrefixes.dustRefined ? 2 : aPrefix == OrePrefixes.dustPure ? 1 : 0, + aMaterial, + aMaterial.mOreByProducts); + if (aPrefix == OrePrefixes.dustPure) { + if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_GOLD)) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Gold, 1L), + GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Gold, 1L)) + .outputChances(10000, 4000, 2000) + .duration(20 * SECONDS) + .eut(24) + .addTo(electroMagneticSeparatorRecipes); + } + if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_IRON)) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Iron, 1L), + GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Iron, 1L)) + .outputChances(10000, 4000, 2000) + .duration(20 * SECONDS) + .eut(24) + .addTo(electroMagneticSeparatorRecipes); + } + if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_NEODYMIUM)) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Neodymium, 1L), + GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Neodymium, 1L)) + .outputChances(10000, 4000, 2000) + .duration(20 * SECONDS) + .eut(24) + .addTo(electroMagneticSeparatorRecipes); + } + } + if (aMaterial.contains(SubTag.CRYSTALLISABLE) + && GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(9000) + .fluidInputs(Materials.Water.getFluid(200L)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(24) + .addTo(autoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(9500) + .fluidInputs(GT_ModHandler.getDistilledWater(100L)) + .duration(1 * MINUTES + 15 * SECONDS) + .eut(24) + .addTo(autoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(10000) + .fluidInputs(Materials.Void.getMolten(36L)) + .duration(1 * MINUTES) + .eut(24) + .addTo(autoclaveRecipes); + } + ItemStack tImpureStack = GT_OreDictUnificator.get( + OrePrefixes.dustTiny, + tByProduct, + GT_OreDictUnificator.get(OrePrefixes.nugget, tByProduct, 1L), + 1L); + if (tImpureStack == null) { + tImpureStack = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tByProduct, 1L); + if (tImpureStack == null) { + tImpureStack = GT_OreDictUnificator.get( + OrePrefixes.dust, + tByProduct, + GT_OreDictUnificator.get(OrePrefixes.gem, tByProduct, 1L), + 1L); + if (tImpureStack == null) { + tImpureStack = GT_OreDictUnificator.get(OrePrefixes.cell, tByProduct, 1L); + if (tImpureStack == null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L)) + .duration(Math.max(1L, aMaterial.getMass())) + .eut(5) + .addTo(centrifugeRecipes); + } else { + FluidStack tFluid = GT_Utility.getFluidForFilledItem(tImpureStack, true); + if (tFluid == null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack), ItemList.Cell_Empty.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 9L), + tImpureStack) + .duration(Math.max(1L, aMaterial.getMass() * 72L)) + .eut(5) + .addTo(centrifugeRecipes); + } else { + tFluid.amount /= 10; + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L)) + .fluidOutputs(tFluid) + .duration(Math.max(1L, aMaterial.getMass() * 8L)) + .eut(5) + .addTo(centrifugeRecipes); + } + } + } else { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 9L), tImpureStack) + .duration(Math.max(1L, aMaterial.getMass() * 72L)) + .eut(5) + .addTo(centrifugeRecipes); + } + } else { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 2L), tImpureStack) + .duration(Math.max(1L, aMaterial.getMass() * 16L)) + .eut(5) + .addTo(centrifugeRecipes); + } + } else { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), + GT_OreDictUnificator.get( + OrePrefixes.dust, + tByProduct, + GT_OreDictUnificator.get(OrePrefixes.nugget, tByProduct, 1L), + 1L)) + .outputChances(10000, 1111) + .duration(Math.max(1L, aMaterial.getMass() * 8L)) + .eut(5) + .addTo(centrifugeRecipes); + } + } + case dustSmall -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), ItemList.Schematic_Dust.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L)) + .duration(1 * SECONDS) + .eut(4) + .addTo(packagerRecipes); + if (!aMaterial.mBlastFurnaceRequired) { + GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); + if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) { + GT_RecipeRegistrator.registerReverseArcSmelting( + GT_Utility.copyAmount(1, aStack), + aMaterial, + aPrefix.mMaterialAmount, + null, + null, + null); + } + } + } + case dustTiny -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack), ItemList.Schematic_Dust.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L)) + .duration(1 * SECONDS) + .eut(4) + .addTo(packagerRecipes); + if (!aMaterial.mBlastFurnaceRequired) { + GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); + if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) { + GT_RecipeRegistrator.registerReverseArcSmelting( + GT_Utility.copyAmount(1, aStack), + aMaterial, + aPrefix.mMaterialAmount, + null, + null, + null); + } + } + if (!aMaterial.contains(SubTag.NO_SMELTING)) { + if (aMaterial.mBlastFurnaceRequired) { + GT_ModHandler.removeFurnaceSmelting(aStack); + } + } + } + default -> {} + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDye.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDye.java new file mode 100644 index 0000000000..f3e82c0b0e --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDye.java @@ -0,0 +1,91 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; + +import java.util.Locale; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; + +import gregtech.api.enums.Dyes; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.IOreRecipeRegistrator; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingDye implements IOreRecipeRegistrator { + + public ProcessingDye() { + OrePrefixes.dye.add(this); + } + + @Override + public void registerOre(OrePrefixes prefix, Materials material, String oreDictName, String modName, + ItemStack stack) { + Dyes aDye = Dyes.get(oreDictName); + if ((aDye.mIndex >= 0) && (aDye.mIndex < 16) && (GT_Utility.getContainerItem(stack, true) == null)) { + registerAlloySmelter(stack, aDye); + registerMixer(stack, aDye); + registerChemicalReactor(stack, aDye); + } + } + + public void registerMixer(ItemStack stack, Dyes dye) { + String fluidName = "dye.watermixed." + dye.name() + .toLowerCase(Locale.ENGLISH); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, stack), GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Water.getFluid(216L)) + .fluidOutputs(FluidRegistry.getFluidStack(fluidName, 192)) + .duration(16 * TICKS) + .eut(4) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, stack), GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(GT_ModHandler.getDistilledWater(288L)) + .fluidOutputs(FluidRegistry.getFluidStack(fluidName, 216)) + .duration(16 * TICKS) + .eut(4) + .addTo(mixerRecipes); + } + + public void registerAlloySmelter(ItemStack stack, Dyes dye) { + GT_ModHandler.addAlloySmelterRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Glass, 8L), + GT_Utility.copyAmount(1, stack), + new ItemStack(Blocks.stained_glass, 8, 15 - dye.mIndex), + 200, + 8, + false); + + GT_ModHandler.addAlloySmelterRecipe( + new ItemStack(Blocks.glass, 8, 32767), + GT_Utility.copyAmount(1, stack), + new ItemStack(Blocks.stained_glass, 8, 15 - dye.mIndex), + 200, + 8, + false); + } + + public void registerChemicalReactor(ItemStack stack, Dyes dye) { + String fluidName = "dye.chemical." + dye.name() + .toLowerCase(Locale.ENGLISH); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, stack), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Salt, 2)) + .fluidInputs(Materials.SulfuricAcid.getFluid(432)) + .fluidOutputs(FluidRegistry.getFluidStack(fluidName, 288)) + .duration(30 * SECONDS) + .eut(48) + .addTo(UniversalChemical); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingFineWire.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingFineWire.java new file mode 100644 index 0000000000..cfd33f1ace --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingFineWire.java @@ -0,0 +1,33 @@ +package gregtech.loaders.oreprocessing; + +import net.minecraft.item.ItemStack; + +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_RecipeRegistrator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingFineWire implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingFineWire() { + OrePrefixes.wireFine.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (!aMaterial.contains(gregtech.api.enums.SubTag.NO_SMASHING)) { + GT_RecipeRegistrator.registerWiremillRecipes(aMaterial, 100, 4); + } + if ((aMaterial.mUnificatable) && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_WORKING)) { + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + GT_Proxy.tBits, + new Object[] { "Xx", 'X', OrePrefixes.foil.get(aMaterial) }); + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java new file mode 100644 index 0000000000..9b46710b71 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java @@ -0,0 +1,45 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +import net.minecraft.item.ItemStack; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.IOreRecipeRegistrator; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingFoil implements IOreRecipeRegistrator { + + public ProcessingFoil() { + OrePrefixes.foil.add(this); + } + + @Override + public void registerOre(OrePrefixes prefix, Materials material, String oreDictName, String modName, + ItemStack stack) { + registerBenderRecipe(material); + registerCover(stack, material); + } + + private void registerBenderRecipe(Materials material) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(1, GT_OreDictUnificator.get(OrePrefixes.plate, material, 4L)), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.foil, material, 4L)) + .duration((int) Math.max(material.getMass(), 1L)) + .eut(calculateRecipeEU(material, 24)) + .addTo(benderRecipes); + } + + private void registerCover(ItemStack stack, Materials material) { + GregTech_API + .registerCover(stack, TextureFactory.of(material.mIconSet.mTextures[70], material.mRGBa, false), null); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingFood.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingFood.java new file mode 100644 index 0000000000..e7fc25038f --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingFood.java @@ -0,0 +1,107 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.recipe.RecipeMaps.formingPressRecipes; +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; +import static gregtech.api.recipe.RecipeMaps.slicerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +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.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingFood implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingFood() { + OrePrefixes.food.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + switch (aOreDictName) { + case "foodCheese" -> { + registerSlicerRecipes(aStack); + GT_OreDictUnificator.addItemData(aStack, new gregtech.api.objects.ItemData(Materials.Cheese, 3628800L)); + } + case "foodDough" -> { + GT_ModHandler.removeFurnaceSmelting(aStack); + registerBenderRecipes(aStack); + registerMixerRecipes(aStack); + registerFormingPressRecipes(aStack); + } + } + } + + private void registerSlicerRecipes(ItemStack stack) { + GT_Values.RA.stdBuilder() + .itemInputs(stack, ItemList.Shape_Slicer_Flat.get(0L)) + .itemOutputs(ItemList.Food_Sliced_Cheese.get(4L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(4) + .addTo(slicerRecipes); + } + + private void registerBenderRecipes(ItemStack stack) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, stack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Food_Flat_Dough.get(1L)) + .duration(16 * TICKS) + .eut(4) + .addTo(benderRecipes); + } + + private void registerMixerRecipes(ItemStack stack) { + GT_Values.RA.stdBuilder() + .itemInputs(stack, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sugar, 1L)) + .itemOutputs(ItemList.Food_Dough_Sugar.get(2L)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(8) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(stack, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cocoa, 1L)) + .itemOutputs(ItemList.Food_Dough_Chocolate.get(2L)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(8) + .addTo(mixerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(stack, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Chocolate, 1L)) + .itemOutputs(ItemList.Food_Dough_Chocolate.get(2L)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(8) + .addTo(mixerRecipes); + } + + private void registerFormingPressRecipes(ItemStack stack) { + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, stack), ItemList.Shape_Mold_Bun.get(0L)) + .itemOutputs(ItemList.Food_Raw_Bun.get(1L)) + .duration(6 * SECONDS + 8 * TICKS) + .eut(4) + .addTo(formingPressRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, stack), ItemList.Shape_Mold_Bread.get(0L)) + .itemOutputs(ItemList.Food_Raw_Bread.get(1L)) + .duration(12 * SECONDS + 16 * TICKS) + .eut(4) + .addTo(formingPressRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, stack), ItemList.Shape_Mold_Baguette.get(0L)) + .itemOutputs(ItemList.Food_Raw_Baguette.get(1L)) + .duration(19 * SECONDS + 4 * TICKS) + .eut(4) + .addTo(formingPressRecipes); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingGear.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGear.java new file mode 100644 index 0000000000..aa973cddfe --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGear.java @@ -0,0 +1,109 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +import net.minecraft.init.Blocks; +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.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingGear implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingGear() { + OrePrefixes.gearGt.add(this); + OrePrefixes.gearGtSmall.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + switch (aPrefix) { + case gearGt -> { + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + if (aMaterial.mStandardMoltenFluid != null) { + if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Gear.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(576L)) + .duration(6 * SECONDS + 8 * TICKS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(fluidSolidifierRecipes); + } + } + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_WORKING)) { + switch (aMaterial.mName) { + case "Wood" -> GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "SPS", "PsP", "SPS", 'P', OrePrefixes.plank.get(aMaterial), 'S', + OrePrefixes.stick.get(aMaterial) }); + case "Stone" -> GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "SPS", "PfP", "SPS", 'P', OrePrefixes.stoneSmooth, 'S', + new ItemStack(Blocks.stone_button, 1, 32767) }); + default -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "SPS", "PwP", "SPS", 'P', OrePrefixes.plate.get(aMaterial), 'S', + OrePrefixes.stick.get(aMaterial) }); + } + } + } + } + } + case gearGtSmall -> { + if (aMaterial.mStandardMoltenFluid != null) { + if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Gear_Small.get(0L)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .fluidInputs(aMaterial.getMolten(144L)) + .duration(16 * TICKS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(fluidSolidifierRecipes); + } + } + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_WORKING)) { + switch (aMaterial.mName) { + case "Wood" -> GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "P ", " s", 'P', OrePrefixes.plank.get(aMaterial) }); + case "Stone" -> GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "P ", " f", 'P', OrePrefixes.stoneSmooth }); + default -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { " S ", "hPx", " S ", 'S', OrePrefixes.stick.get(aMaterial), 'P', + OrePrefixes.plate.get(aMaterial) }); + } + } + } + } + } + default -> {} + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java new file mode 100644 index 0000000000..35bd3b8cfd --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java @@ -0,0 +1,612 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.recipe.RecipeMaps.compressorRecipes; +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.implosionRecipes; +import static gregtech.api.recipe.RecipeMaps.laserEngraverRecipes; +import static gregtech.api.recipe.RecipeMaps.latheRecipes; +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.FUEL_TYPE; +import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +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.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeConstants; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingGem implements gregtech.api.interfaces.IOreRecipeRegistrator { // TODO COMPARE WITH GEM??? + // generators + + public ProcessingGem() { + OrePrefixes.gem.add(this); + OrePrefixes.gemChipped.add(this); + OrePrefixes.gemExquisite.add(this); + OrePrefixes.gemFlawed.add(this); + OrePrefixes.gemFlawless.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + long aMaterialMass = aMaterial.getMass(); + boolean aNoSmashing = aMaterial.contains(SubTag.NO_SMASHING); + boolean aNoWorking = aMaterial.contains(SubTag.NO_WORKING); + boolean aNoSmelting = aMaterial.contains(SubTag.NO_SMELTING); + boolean aSpecialRecipeReq = aMaterial.contains(SubTag.MORTAR_GRINDABLE); + boolean aFuelPower = aMaterial.mFuelPower > 0; + + switch (aPrefix) { + case gem -> { + // fuel recipes + if (aFuelPower) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .metadata(FUEL_VALUE, aMaterial.mFuelPower * 2) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .addTo(GT_RecipeConstants.Fuel); + } + + if (!OrePrefixes.block.isIgnored(aMaterial) + && GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L) != null) { + // Compressor recipes + // need to avoid iridium exploit + if (aMaterial != Materials.Iridium) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + } + } + + // Smelting recipe + if (!aNoSmelting) { + GT_ModHandler.addSmeltingRecipe( + GT_Utility.copyAmount(1, aStack), + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L)); + } + + if (aNoSmashing) { + // Forge hammer recipes + { + if (GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 2L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(16) + .addTo(hammerRecipes); + } + } + } else { + // Forge hammer recipes + { + // need to avoid iridium exploit + if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null + && aMaterial != Materials.Iridium) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .duration(Math.max(aMaterialMass, 1L)) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(hammerRecipes); + } + } + + // Bender recipes + if (aMaterial != Materials.Iridium) { + if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) { + // Plate + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .duration((int) Math.max(aMaterialMass * 2L, 1L)) + .eut(calculateRecipeEU(aMaterial, 24)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L) != null) { + // Double plates + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 2L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L) != null) { + // Triple plate + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 3L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L) != null) { + // Quadruple plate + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 4L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L) != null) { + // Quintuple plate + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(5, aStack), GT_Utility.getIntegratedCircuit(5)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 5L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L) != null) { + // dense plate + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack), GT_Utility.getIntegratedCircuit(9)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 9L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + } + } + if (aNoWorking) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + // Lathe recipes + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L) != null + && GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 2L)) + .duration(((int) Math.max(aMaterialMass, 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(latheRecipes); + } + } + } else { + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) { + // Implosion compressor recipes + { + if (GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 1) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), ItemList.Block_Powderbarrel.get(16)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(3, aStack), + GT_ModHandler.getIC2Item("dynamite", 4, null)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), new ItemStack(Blocks.tnt, 8)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(3, aStack), + GT_ModHandler.getIC2Item("industrialTnt", 2)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + } + } + + // Crafting recipes + { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 2L), + GT_Proxy.tBits, + new Object[] { "h", "X", 'X', OrePrefixes.gemFlawless.get(aMaterial) }); + + if (aMaterial.contains(SubTag.SMELTING_TO_GEM)) { + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + GT_Proxy.tBits, + new Object[] { "XXX", "XXX", "XXX", 'X', OrePrefixes.nugget.get(aMaterial) }); + } + + if (aSpecialRecipeReq) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "X", "m", 'X', OrePrefixes.gem.get(aMaterial) }); + } + } + } + } + + for (ItemStack is : OreDictionary.getOres("craftingLens" + aMaterial.mColor.mName.replace(" ", ""))) { // Engraver + // Laser engraver recipes + { + + if (GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 1L) != null) { + is.stackSize = 0; + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), is) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 1L)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(laserEngraverRecipes); + } + + } + } + } + case gemChipped -> { + // Fuel recipes + if (aFuelPower) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .metadata(FUEL_VALUE, aMaterial.mFuelPower / 2) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .addTo(GT_RecipeConstants.Fuel); + } + + if (!aNoWorking) { + // Lathe recipes + if (GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L) != null + && GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 1L)) + .duration(((int) Math.max(aMaterialMass, 1L)) * TICKS) + .eut(8) + .addTo(latheRecipes); + } + + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) { + // Implosion compressor recipes + { + if (GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 1) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), ItemList.Block_Powderbarrel.get(16)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(3, aStack), + GT_ModHandler.getIC2Item("dynamite", 4, null)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), new ItemStack(Blocks.tnt, 8)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(3, aStack), + GT_ModHandler.getIC2Item("industrialTnt", 2)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + } + } + + // Crafting recipes + { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gemChipped, aMaterial, 2L), + GT_Proxy.tBits, + new Object[] { "h", "X", 'X', OrePrefixes.gemFlawed.get(aMaterial) }); + if (aSpecialRecipeReq) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "X", "m", 'X', OrePrefixes.gemChipped.get(aMaterial) }); + } + } + } + } + for (ItemStack is : OreDictionary.getOres("craftingLens" + aMaterial.mColor.mName.replace(" ", ""))) { // Engraver + is.stackSize = 0; + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), is) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 1L)) + .duration(30 * SECONDS) + .eut(30) + .addTo(laserEngraverRecipes); + + } + } + case gemExquisite -> { + // Fuel recipes + if (aFuelPower) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .metadata(FUEL_VALUE, aMaterial.mFuelPower * 8) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .addTo(GT_RecipeConstants.Fuel); + } + + if (!aNoWorking) { + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) { + // Crafting recipes + { + if (aSpecialRecipeReq) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 4L), + GT_Proxy.tBits, + new Object[] { "X", "m", 'X', OrePrefixes.gemExquisite.get(aMaterial) }); + } + } + } + } + + // Forge hammer recipes + { + GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 2L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(16) + .addTo(hammerRecipes); + } + } + case gemFlawed -> { + // fuel recipes + if (aFuelPower) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .metadata(FUEL_VALUE, aMaterial.mFuelPower) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .addTo(GT_RecipeConstants.Fuel); + } + + if (!aNoWorking) { + // Lathe recipes + if (GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L) != null + && GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 2L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L)) + .duration(((int) Math.max(aMaterialMass, 1L)) * TICKS) + .eut(12) + .addTo(latheRecipes); + } + + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) { + // Implosion compressor recipes + { + if (GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), ItemList.Block_Powderbarrel.get(16)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(3, aStack), + GT_ModHandler.getIC2Item("dynamite", 4, null)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), new ItemStack(Blocks.tnt, 8)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(3, aStack), + GT_ModHandler.getIC2Item("industrialTnt", 2)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + } + } + + // Crafting recipes + { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 2L), + GT_Proxy.tBits, + new Object[] { "h", "X", 'X', OrePrefixes.gem.get(aMaterial) }); + if (aSpecialRecipeReq) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 2L), + GT_Proxy.tBits, + new Object[] { "X", "m", 'X', OrePrefixes.gemFlawed.get(aMaterial) }); + } + } + } + } + GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gemChipped, aMaterial, 2L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(16) + .addTo(hammerRecipes); + + for (ItemStack is : OreDictionary.getOres("craftingLens" + aMaterial.mColor.mName.replace(" ", ""))) { // Engraver + + is.stackSize = 0; + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), is) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(laserEngraverRecipes); + + } + } + case gemFlawless -> { + + // Fuel recipes + if (aFuelPower) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .metadata(FUEL_VALUE, aMaterial.mFuelPower * 4) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .addTo(GT_RecipeConstants.Fuel); + } + + if (!aNoWorking) { + // Lathe recipes + if (GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L) != null + && GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L), + GT_OreDictUnificator.getDust( + aMaterial, + aPrefix.mMaterialAmount - OrePrefixes.stickLong.mMaterialAmount)) + .duration(((int) Math.max(aMaterialMass * 5L, 1L)) * TICKS) + .eut(16) + .addTo(latheRecipes); + } + + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) { + // Implosion compressor recipes + { + if (GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), ItemList.Block_Powderbarrel.get(16)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(3, aStack), + GT_ModHandler.getIC2Item("dynamite", 4, null)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), new ItemStack(Blocks.tnt, 8)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(3, aStack), + GT_ModHandler.getIC2Item("industrialTnt", 2)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + } + } + + // Crafting recipes + { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 2L), + GT_Proxy.tBits, + new Object[] { "h", "X", 'X', OrePrefixes.gemExquisite.get(aMaterial) }); + if (aSpecialRecipeReq) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 2L), + GT_Proxy.tBits, + new Object[] { "X", "m", 'X', OrePrefixes.gemFlawless.get(aMaterial) }); + } + } + } + } + GT_Values.RA.stdBuilder() + .itemInputs(aStack) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 2L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(16) + .addTo(hammerRecipes); + + for (ItemStack is : OreDictionary.getOres("craftingLens" + aMaterial.mColor.mName.replace(" ", ""))) { // Engraver + + is.stackSize = 0; + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), is) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1L)) + .duration(2 * MINUTES) + .eut(2000) + .addTo(laserEngraverRecipes); + } + } + default -> {} + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java new file mode 100644 index 0000000000..0be31a7e1d --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java @@ -0,0 +1,296 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.FUEL_TYPE; +import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +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.enums.TierEU; +import gregtech.api.enums.ToolDictNames; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeConstants; +import gregtech.api.util.GT_RecipeRegistrator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingIngot() { + OrePrefixes.ingot.add(this); + OrePrefixes.ingotDouble.add(this); + OrePrefixes.ingotTriple.add(this); + OrePrefixes.ingotQuadruple.add(this); + OrePrefixes.ingotQuintuple.add(this); + OrePrefixes.ingotHot.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + boolean aNoSmashing = aMaterial.contains(SubTag.NO_SMASHING); + boolean aStretchy = aMaterial.contains(SubTag.STRETCHY); + boolean aNoSmelting = aMaterial.contains(SubTag.NO_SMELTING); + long aMaterialMass = aMaterial.getMass(); + boolean aSpecialRecipeReq = aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_SMASHING); + + switch (aPrefix) { + case ingot -> { + // Fuel recipe + if (aMaterial.mFuelPower > 0) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .metadata(FUEL_VALUE, aMaterial.mFuelPower) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .addTo(GT_RecipeConstants.Fuel); + } + if (aMaterial.mStandardMoltenFluid != null + && !(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { + // Fluid solidifier recipes + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Ingot.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(144L)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(fluidSolidifierRecipes); + } + // Reverse recipes + { + GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); + GT_RecipeRegistrator + .registerReverseMacerating(aStack, aMaterial, aPrefix.mMaterialAmount, null, null, null, false); + if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) { + GT_RecipeRegistrator.registerReverseArcSmelting( + GT_Utility.copyAmount(1, aStack), + aMaterial, + aPrefix.mMaterialAmount, + null, + null, + null); + } + } + ItemStack tStack = GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L); + if ((tStack != null) && ((aMaterial.mBlastFurnaceRequired) || aNoSmelting)) { + GT_ModHandler.removeFurnaceSmelting(tStack); + } + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_WORKING) + && !aMaterial.contains(SubTag.SMELTING_TO_GEM) + && aMaterial.contains(SubTag.MORTAR_GRINDABLE)) { + GT_ModHandler.addShapelessCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { ToolDictNames.craftingToolMortar, OrePrefixes.ingot.get(aMaterial) }); + } + if (!aNoSmashing) { + // Forge hammer recipes + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV + && GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 2L)) + .duration(Math.max(aMaterialMass, 1L)) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(hammerRecipes); + } + } + if (!aNoSmashing || aStretchy) { + + // Bender recipes + { + if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .duration(Math.max(aMaterialMass, 1L)) + .eut(calculateRecipeEU(aMaterial, 24)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 2L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 3L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 4L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(5, aStack), GT_Utility.getIntegratedCircuit(5)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 5L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack), GT_Utility.getIntegratedCircuit(9)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 9L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(10)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, 4L)) + .duration(Math.max(aMaterialMass * 2L, 1L)) + .eut(calculateRecipeEU(aMaterial, 24)) + .addTo(benderRecipes); + } + } + } + } + case ingotDouble -> { + if (!aNoSmashing || aStretchy) { + // bender recipes + { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L)) + .duration(Math.max(aMaterialMass, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 2L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + // Enable crafting with hammer if tier is < IV. + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.ingotDouble, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "I", "I", "h", 'I', OrePrefixes.ingot.get(aMaterial) }); + } + } + } + case ingotTriple -> { + if (!aNoSmashing || aStretchy) { + // Bender recipes + { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 3L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.ingotTriple, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "I", "B", "h", 'I', OrePrefixes.ingotDouble.get(aMaterial), 'B', + OrePrefixes.ingot.get(aMaterial) }); + } + } + } + case ingotQuadruple -> { + if (!aNoSmashing || aStretchy) { + // Bender recipes + { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + // If tier < IV add manual crafting. + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.ingotQuadruple, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "I", "B", "h", 'I', OrePrefixes.ingotTriple.get(aMaterial), 'B', + OrePrefixes.ingot.get(aMaterial) }); + } + } + } + case ingotQuintuple -> { + if (!aNoSmashing || aStretchy) { + // Bender recipes + { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + // Crafting recipes + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV && aSpecialRecipeReq) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.ingotQuintuple, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "I", "B", "h", 'I', OrePrefixes.ingotQuadruple.get(aMaterial), 'B', + OrePrefixes.ingot.get(aMaterial) }); + } + } + } + case ingotHot -> { + if (aMaterial.mAutoGenerateVacuumFreezerRecipes + && GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null) { + // Vacuum freezer recipes + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L)) + .duration(((int) Math.max(aMaterialMass * 3L, 1L)) * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(vacuumFreezerRecipes); + } + } + default -> {} + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingItem.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingItem.java new file mode 100644 index 0000000000..6a132e2dba --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingItem.java @@ -0,0 +1,45 @@ +package gregtech.loaders.oreprocessing; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.objects.ItemData; +import gregtech.api.util.GT_OreDictUnificator; + +public class ProcessingItem implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingItem() { + OrePrefixes.item.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (GT_OreDictUnificator.getItemData(aStack) == null && !aOreDictName.equals("itemCertusQuartz") + && !aOreDictName.equals("itemNetherQuartz")) { + switch (aOreDictName) { + case "itemSilicon": + GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Silicon, 3628800L)); + case "itemWheat": + GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Wheat, 3628800L)); + case "itemManganese": + GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Manganese, 3628800L)); + case "itemSalt": + GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Salt, 3628800L)); + case "itemMagnesium": + GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Magnesium, 3628800L)); + case "itemPhosphorite": + GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.TricalciumPhosphate, 3628800L)); + case "itemSulfur": + GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Sulfur, 3628800L)); + case "itemAluminum": + GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Aluminium, 3628800L)); + case "itemSaltpeter": + GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Saltpeter, 3628800L)); + case "itemUranium": + GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Uranium, 3628800L)); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingLens.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingLens.java new file mode 100644 index 0000000000..c3f73f7966 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingLens.java @@ -0,0 +1,96 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.compressorRecipes; +import static gregtech.api.recipe.RecipeMaps.latheRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; + +import net.minecraft.item.ItemStack; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.Textures; +import gregtech.api.enums.TierEU; +import gregtech.api.interfaces.ITexture; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeBuilder; + +@SuppressWarnings("RedundantLabeledSwitchRuleCodeBlock") +public class ProcessingLens implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingLens() { + OrePrefixes.lens.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + switch (aMaterial.mName) { + case "Diamond", "Glass" -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L)) + .duration(1 * MINUTES) + .eut(TierEU.RECIPE_LV) + .addTo(latheRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L)) + .duration(2 * MINUTES) + .eut(16) + .addTo(latheRecipes); + } + case "ChromaticGlass" -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 16L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L)) + .duration(10 * MINUTES) + .eut(TierEU.RECIPE_UHV) + .addTo(compressorRecipes); + } + default -> { + if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + recipeBuilder.itemInputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)); + if (GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L) == null) { + recipeBuilder.itemOutputs(GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L)); + } else { + recipeBuilder.itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L)); + } + recipeBuilder.duration(1 * MINUTES) + .eut(TierEU.RECIPE_MV) + .addTo(latheRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1L) != null) { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + recipeBuilder.itemInputs(GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1L)); + if (GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L) == null) { + recipeBuilder.itemOutputs(GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L)); + } else { + recipeBuilder.itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 2L)); + } + recipeBuilder.duration(2 * MINUTES) + .eut(TierEU.RECIPE_LV) + .addTo(latheRecipes); + } + final ITexture lensCoverTexture = TextureFactory + .of(Textures.BlockIcons.OVERLAY_LENS, aMaterial.mRGBa, false); + GregTech_API.registerCover( + aStack, + TextureFactory.of(Textures.BlockIcons.MACHINE_CASINGS[2][0], lensCoverTexture), + new gregtech.common.covers.GT_Cover_Lens(aMaterial.mColor.mIndex, lensCoverTexture)); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingLog.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingLog.java new file mode 100644 index 0000000000..737ef4682a --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingLog.java @@ -0,0 +1,384 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.enums.Mods.Railcraft; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes; +import static gregtech.api.recipe.RecipeMaps.cutterRecipes; +import static gregtech.api.recipe.RecipeMaps.extractorRecipes; +import static gregtech.api.recipe.RecipeMaps.latheRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.recipe.RecipeMaps.pyrolyseRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import gregtech.GT_Mod; +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; + +public class ProcessingLog implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingLog() { + OrePrefixes.log.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (aOreDictName.equals("logRubber")) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs( + ItemList.IC2_Resin.get(1L), + GT_ModHandler.getIC2Item("plantBall", 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Carbon, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L)) + .outputChances(5000, 3750, 2500, 2500) + .fluidOutputs(Materials.Methane.getGas(60L)) + .duration(10 * SECONDS) + .eut(20) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.RawRubber, 1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 6L), ItemList.IC2_Resin.get(1L)) + .outputChances(10000, 3300) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + } else { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .fluidOutputs(Materials.Methane.getGas(60L)) + .duration(10 * SECONDS) + .eut(20) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 6L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L)) + .outputChances(10000, 8000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + } + + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Wood, 2L), + gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "sLf", 'L', GT_Utility.copyAmount(1, aStack) }); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Wood, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L)) + .duration(8 * SECONDS) + .eut(7) + .addTo(latheRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemList.FR_Stick.get(1L)) + .fluidInputs(Materials.SeedOil.getFluid(50L)) + .duration(16 * TICKS) + .eut(7) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(8, aStack), GT_Utility.getIntegratedCircuit(8)) + .itemOutputs(ItemList.FR_Casing_Impregnated.get(1L)) + .fluidInputs(Materials.SeedOil.getFluid(250L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(16) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_ModHandler.getModItem(Railcraft.ID, "cube", 1L, 8)) + .fluidInputs(Materials.Creosote.getFluid(750L)) + .duration(16 * TICKS) + .eut(TierEU.ULV) + .addTo(chemicalBathRecipes); + + short aMeta = (short) aStack.getItemDamage(); + + if (aMeta == Short.MAX_VALUE) { + if ((GT_Utility.areStacksEqual( + GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(1, aStack), false, null), + new ItemStack(Items.coal, 1, 1)))) { + addPyrolyeOvenRecipes(aStack); + GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1, aStack)); + } + for (int i = 0; i < 32767; i++) { + if ((GT_Utility.areStacksEqual( + GT_ModHandler.getSmeltingOutput(new ItemStack(aStack.getItem(), 1, i), false, null), + new ItemStack(Items.coal, 1, 1)))) { + addPyrolyeOvenRecipes(aStack); + GT_ModHandler.removeFurnaceSmelting(new ItemStack(aStack.getItem(), 1, i)); + } + ItemStack tStack = GT_ModHandler.getRecipeOutput(new ItemStack(aStack.getItem(), 1, i)); + if (tStack == null) { + if (i >= 16) { + break; + } + } else { + ItemStack tPlanks = GT_Utility.copyOrNull(tStack); + if (tPlanks != null) { + tPlanks.stackSize = (tPlanks.stackSize * 3 / 2); + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(aStack.getItem(), 1, i)) + .itemOutputs( + GT_Utility.copyOrNull(tPlanks), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L)) + .fluidInputs(Materials.Lubricant.getFluid(1L)) + .duration(10 * SECONDS) + .eut(8) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(aStack.getItem(), 1, i)) + .itemOutputs( + GT_Utility.copyAmount( + GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, + tStack), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L)) + .fluidInputs(Materials.Water.getFluid(Math.min(1000, 200 * 8 / 320))) + .duration(20 * SECONDS) + .eut(8) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(aStack.getItem(), 1, i)) + .itemOutputs( + GT_Utility.copyAmount( + GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, + tStack), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L)) + .fluidInputs(GT_ModHandler.getDistilledWater(3)) + .duration(20 * SECONDS) + .eut(8) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(aStack.getItem(), 1, i)) + .itemOutputs( + GT_Utility.copyAmount( + GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, + tStack), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L)) + .fluidInputs(Materials.Lubricant.getFluid(1)) + .duration(10 * SECONDS) + .eut(8) + .addTo(cutterRecipes); + GT_ModHandler.addSawmillRecipe( + new ItemStack(aStack.getItem(), 1, i), + tPlanks, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L)); + GT_ModHandler.removeRecipeDelayed(new ItemStack(aStack.getItem(), 1, i)); + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount( + GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, + tStack), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "s", "L", 'L', new ItemStack(aStack.getItem(), 1, i) }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility + .copyAmount(tStack.stackSize / (GT_Mod.gregtechproxy.mNerfedWoodPlank ? 2 : 1), tStack), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { new ItemStack(aStack.getItem(), 1, i) }); + } + } + } + } else { + if ((GT_Utility.areStacksEqual( + GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(1, aStack), false, null), + new ItemStack(Items.coal, 1, 1)))) { + addPyrolyeOvenRecipes(aStack); + GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1, aStack)); + } + ItemStack tStack = GT_ModHandler.getRecipeOutput(GT_Utility.copyAmount(1, aStack)); + if (tStack != null) { + ItemStack tPlanks = GT_Utility.copyOrNull(tStack); + if (tPlanks != null) { + tPlanks.stackSize = (tPlanks.stackSize * 3 / 2); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_Utility.copyOrNull(tPlanks), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L)) + .fluidInputs(Materials.Lubricant.getFluid(1L)) + .duration(10 * SECONDS) + .eut(8) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_Utility.copyAmount( + GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, + tStack), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L)) + .fluidInputs(Materials.Water.getFluid(Math.min(1000, 200 * 8 / 320))) + .duration(20 * SECONDS) + .eut(8) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_Utility.copyAmount( + GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, + tStack), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L)) + .fluidInputs(GT_ModHandler.getDistilledWater(3)) + .duration(20 * SECONDS) + .eut(8) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_Utility.copyAmount( + GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, + tStack), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L)) + .fluidInputs(Materials.Lubricant.getFluid(1)) + .duration(10 * SECONDS) + .eut(8) + .addTo(cutterRecipes); + GT_ModHandler.addSawmillRecipe( + GT_Utility.copyAmount(1, aStack), + tPlanks, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L)); + GT_ModHandler.removeRecipeDelayed(GT_Utility.copyAmount(1, aStack)); + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount( + GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, + tStack), + new Object[] { "s", "L", 'L', GT_Utility.copyAmount(1, aStack) }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility + .copyAmount(tStack.stackSize / (GT_Mod.gregtechproxy.mNerfedWoodPlank ? 2 : 1), tStack), + new Object[] { GT_Utility.copyAmount(1, aStack) }); + } + } + } + + if ((GT_Utility.areStacksEqual( + GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(1, aStack), false, null), + new ItemStack(Items.coal, 1, 1)))) { + addPyrolyeOvenRecipes(aStack); + GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1, aStack)); + } + } + + public static void addPyrolyeOvenRecipes(ItemStack logStack) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(Materials.Charcoal.getGems(20)) + .fluidOutputs(Materials.Creosote.getFluid(4000)) + .duration(32 * SECONDS) + .eut(64) + .noOptimize() + .addTo(pyrolyseRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(Materials.Charcoal.getGems(20)) + .fluidInputs(Materials.Nitrogen.getGas(1000)) + .fluidOutputs(Materials.Creosote.getFluid(4000)) + .duration(16 * SECONDS) + .eut(96) + .noOptimize() + .addTo(pyrolyseRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(Materials.Charcoal.getGems(20)) + .fluidOutputs(Materials.CharcoalByproducts.getGas(4000)) + .duration(32 * SECONDS) + .eut(64) + .noOptimize() + .addTo(pyrolyseRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(Materials.Charcoal.getGems(20)) + .fluidInputs(Materials.Nitrogen.getGas(1000)) + .fluidOutputs(Materials.CharcoalByproducts.getGas(4000)) + .duration(16 * SECONDS) + .eut(96) + .noOptimize() + .addTo(pyrolyseRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(5)) + .itemOutputs(Materials.Charcoal.getGems(20)) + .fluidOutputs(Materials.WoodGas.getGas(1500)) + .duration(32 * SECONDS) + .eut(64) + .noOptimize() + .addTo(pyrolyseRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(Materials.Charcoal.getGems(20)) + .fluidInputs(Materials.Nitrogen.getGas(1000)) + .fluidOutputs(Materials.WoodGas.getGas(1500)) + .duration(16 * SECONDS) + .eut(96) + .noOptimize() + .addTo(pyrolyseRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(7)) + .itemOutputs(Materials.Charcoal.getGems(20)) + .fluidOutputs(Materials.WoodVinegar.getFluid(3000)) + .duration(32 * SECONDS) + .eut(64) + .noOptimize() + .addTo(pyrolyseRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(8)) + .itemOutputs(Materials.Charcoal.getGems(20)) + .fluidInputs(Materials.Nitrogen.getGas(1000)) + .fluidOutputs(Materials.WoodVinegar.getFluid(3000)) + .duration(16 * SECONDS) + .eut(96) + .noOptimize() + .addTo(pyrolyseRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(9)) + .itemOutputs(Materials.Charcoal.getGems(20)) + .fluidOutputs(Materials.WoodTar.getFluid(1500)) + .duration(32 * SECONDS) + .eut(64) + .noOptimize() + .addTo(pyrolyseRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(10)) + .itemOutputs(Materials.Charcoal.getGems(20)) + .fluidInputs(Materials.Nitrogen.getGas(1000)) + .fluidOutputs(Materials.WoodTar.getFluid(1500)) + .duration(16 * SECONDS) + .eut(96) + .noOptimize() + .addTo(pyrolyseRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, logStack), GT_Utility.getIntegratedCircuit(11)) + .itemOutputs(Materials.Ash.getDust(4)) + .fluidOutputs(Materials.OilHeavy.getFluid(200)) + .duration(16 * SECONDS) + .eut(192) + .noOptimize() + .addTo(pyrolyseRecipes); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java new file mode 100644 index 0000000000..8d7ca9e518 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java @@ -0,0 +1,89 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.alloySmelterRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +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.enums.TierEU; +import gregtech.api.recipe.RecipeCategories; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeRegistrator; +import gregtech.api.util.GT_Utility; + +public class ProcessingNugget implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingNugget() { + OrePrefixes.nugget.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + + if (aMaterial.contains(SubTag.SMELTING_TO_GEM) + && GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack), ItemList.Shape_Mold_Ball.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial.mSmeltInto, 1L)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 2)) + .addTo(alloySmelterRecipes); + } + + if ((!aMaterial.contains(SubTag.SMELTING_TO_GEM)) + && GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L) != null + && aMaterial != Materials.Aluminium) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack), ItemList.Shape_Mold_Ingot.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 2)) + .recipeCategory(RecipeCategories.alloySmelterMolding) + .addTo(alloySmelterRecipes); + } + + if (aMaterial.mStandardMoltenFluid != null) { + if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Nugget.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(16L)) + .duration(16 * TICKS) + .eut(calculateRecipeEU(aMaterial, 4)) + .addTo(fluidSolidifierRecipes); + } + } + + GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); + GT_RecipeRegistrator + .registerReverseMacerating(aStack, aMaterial, aPrefix.mMaterialAmount, null, null, null, false); + if (!aMaterial.contains(SubTag.NO_SMELTING) + && GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), + ItemList.Shape_Mold_Nugget.get(0L)) + .itemOutputs(GT_Utility.copyAmount(9, aStack)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 1)) + .recipeCategory(RecipeCategories.alloySmelterMolding) + .addTo(alloySmelterRecipes); + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial, 8L), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "sI ", 'I', OrePrefixes.ingot.get(aMaterial) }); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java new file mode 100644 index 0000000000..945ffae386 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java @@ -0,0 +1,245 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; + +import java.util.ArrayList; + +import net.minecraft.item.ItemStack; + +import gregtech.GT_Mod; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingOre implements gregtech.api.interfaces.IOreRecipeRegistrator { + + private final ArrayList<Materials> mAlreadyListedOres = new ArrayList<>(1000); + + public ProcessingOre() { + for (OrePrefixes tPrefix : OrePrefixes.values()) if ((tPrefix.name() + .startsWith("ore")) && (tPrefix != OrePrefixes.orePoor) + && (tPrefix != OrePrefixes.oreSmall) + && (tPrefix != OrePrefixes.oreRich) + && (tPrefix != OrePrefixes.oreNormal)) tPrefix.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + boolean tIsRich = false; + + // For Sake of god of balance! + + // Dense ore + if (GT_Mod.gregtechproxy.mRichOreYieldMultiplier) { + tIsRich = (aPrefix == OrePrefixes.oreRich) || (aPrefix == OrePrefixes.oreDense); + } + // NetherOre + if (GT_Mod.gregtechproxy.mNetherOreYieldMultiplier && !tIsRich) { + tIsRich = (aPrefix == OrePrefixes.oreNetherrack) || (aPrefix == OrePrefixes.oreNether); + } + // EndOre + if (GT_Mod.gregtechproxy.mEndOreYieldMultiplier && !tIsRich) { + tIsRich = (aPrefix == OrePrefixes.oreEndstone) || (aPrefix == OrePrefixes.oreEnd); + } + + if (aMaterial == Materials.Oilsands) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(new ItemStack(net.minecraft.init.Blocks.sand, 1, 0)) + .outputChances(tIsRich ? 2000 : 4000) + .fluidOutputs(Materials.OilHeavy.getFluid(tIsRich ? 4000L : 2000L)) + .duration(tIsRich ? 30 * SECONDS : 15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(centrifugeRecipes); + } else { + registerStandardOreRecipes( + aPrefix, + aMaterial, + GT_Utility.copyAmount(1, aStack), + Math.max( + 1, + gregtech.api.GregTech_API.sOPStuff.get( + gregtech.api.enums.ConfigCategories.Materials.oreprocessingoutputmultiplier, + aMaterial.toString(), + 1)) + * (tIsRich ? 2 : 1)); + } + } + + private boolean registerStandardOreRecipes(OrePrefixes aPrefix, Materials aMaterial, ItemStack aOreStack, + int aMultiplier) { + if ((aOreStack == null) || (aMaterial == null)) return false; + GT_ModHandler + .addValuableOre(GT_Utility.getBlockFromStack(aOreStack), aOreStack.getItemDamage(), aMaterial.mOreValue); + Materials tMaterial = aMaterial.mOreReplacement; + Materials tPrimaryByMaterial = null; + aMultiplier = Math.max(1, aMultiplier); + aOreStack = GT_Utility.copyAmount(1, aOreStack); + aOreStack.stackSize = 1; + + ItemStack tIngot = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L); + ItemStack tGem = GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial, 1L); + ItemStack tSmeltInto = tIngot + == null + ? null + : aMaterial.contains(SubTag.SMELTING_TO_GEM) + ? GT_OreDictUnificator.get( + OrePrefixes.gem, + tMaterial.mDirectSmelting, + GT_OreDictUnificator.get( + OrePrefixes.crystal, + tMaterial.mDirectSmelting, + GT_OreDictUnificator.get( + OrePrefixes.gem, + tMaterial, + GT_OreDictUnificator.get(OrePrefixes.crystal, tMaterial, 1L), + 1L), + 1L), + 1L) + : tIngot; + + ItemStack tDust = GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial, tGem, 1L); + ItemStack tCleaned = GT_OreDictUnificator.get(OrePrefixes.crushedPurified, tMaterial, tDust, 1L); + ItemStack tCrushed = GT_OreDictUnificator + .get(OrePrefixes.crushed, tMaterial, (long) aMaterial.mOreMultiplier * aMultiplier); + ItemStack tPrimaryByProduct = null; + + if (tCrushed == null) { + tCrushed = GT_OreDictUnificator.get( + OrePrefixes.dustImpure, + tMaterial, + GT_Utility.copyAmount(aMaterial.mOreMultiplier * aMultiplier, tCleaned, tDust, tGem), + (long) aMaterial.mOreMultiplier * aMultiplier); + } + + for (Materials tMat : aMaterial.mOreByProducts) { + GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); + if (tPrimaryByProduct == null) { + tPrimaryByMaterial = tMat; + tPrimaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); + if (GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L) == null) GT_OreDictUnificator + .get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L); + } + GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); + if (GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L) == null) GT_OreDictUnificator + .get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L); + } + + if (tPrimaryByMaterial == null) tPrimaryByMaterial = tMaterial; + if (tPrimaryByProduct == null) tPrimaryByProduct = tDust; + boolean tHasSmelting = false; + + if (tSmeltInto != null) { + if ((aMaterial.mBlastFurnaceRequired) || (aMaterial.mDirectSmelting.mBlastFurnaceRequired)) { + GT_ModHandler.removeFurnaceSmelting(aOreStack); + } else { + tHasSmelting = GT_ModHandler.addSmeltingRecipe( + aOreStack, + GT_Utility.copyAmount(aMultiplier * aMaterial.mSmeltingMultiplier, tSmeltInto)); + } + + if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_TRIPLE)) { + if (aMaterial.mAutoGenerateBlastFurnaceRecipes) { + GT_Values.RA.stdBuilder() + .itemInputs( + aOreStack, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcite, aMultiplier)) + .itemOutputs( + GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, tSmeltInto), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)) + .duration(tSmeltInto.stackSize * 25 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1500) + .addTo(blastFurnaceRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + aOreStack, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, aMultiplier)) + .itemOutputs( + GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, tSmeltInto), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)) + .duration(tSmeltInto.stackSize * 25 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1500) + .addTo(blastFurnaceRecipes); + } + } else if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_DOUBLE)) { + if (aMaterial.mAutoGenerateBlastFurnaceRecipes) { + GT_Values.RA.stdBuilder() + .itemInputs( + aOreStack, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcite, aMultiplier)) + .itemOutputs( + GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, tSmeltInto), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)) + .duration(tSmeltInto.stackSize * 25 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1500) + .addTo(blastFurnaceRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + aOreStack, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, aMultiplier)) + .itemOutputs( + GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, tSmeltInto), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)) + .duration(tSmeltInto.stackSize * 25 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1500) + .addTo(blastFurnaceRecipes); + } + } + } + + if (!tHasSmelting) { + GT_ModHandler.addSmeltingRecipe( + aOreStack, + GT_OreDictUnificator.get( + OrePrefixes.gem, + tMaterial.mDirectSmelting, + Math.max(1, aMultiplier * aMaterial.mSmeltingMultiplier / 2))); + } + + if (tCrushed != null) { + GT_Values.RA.stdBuilder() + .itemInputs(aOreStack) + .itemOutputs(GT_Utility.copy(GT_Utility.copyAmount(tCrushed.stackSize, tGem), tCrushed)) + .duration(10) + .eut(16) + .addTo(hammerRecipes); + + int chanceOre2 = tPrimaryByProduct == null ? 0 + : tPrimaryByProduct.stackSize * 10 * aMultiplier * aMaterial.mByProductMultiplier; + chanceOre2 = 100 * chanceOre2; // converting to the GT format, 100% is 10000 + GT_Values.RA.stdBuilder() + .itemInputs(aOreStack) + .itemOutputs( + GT_Utility.mul(2, tCrushed), + tMaterial.contains(SubTag.PULVERIZING_CINNABAR) ? GT_OreDictUnificator.get( + OrePrefixes.crystal, + Materials.Cinnabar, + GT_OreDictUnificator + .get(OrePrefixes.gem, tPrimaryByMaterial, GT_Utility.copyAmount(1, tPrimaryByProduct), 1L), + 1L) + : GT_OreDictUnificator + .get(OrePrefixes.gem, tPrimaryByMaterial, GT_Utility.copyAmount(1, tPrimaryByProduct), 1L), + GT_OreDictUnificator.getDust(aPrefix.mSecondaryMaterial)) + .outputChances(10000, chanceOre2, 5000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + } + return true; + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java new file mode 100644 index 0000000000..ac9106d31b --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java @@ -0,0 +1,72 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +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_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingOrePoor implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingOrePoor() { + OrePrefixes.orePoor.add(this); + OrePrefixes.oreSmall.add(this); + OrePrefixes.oreNormal.add(this); + OrePrefixes.oreRich.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + int aMultiplier = 1; + switch (aPrefix) { + case oreSmall: + aMultiplier = 1; + break; + case orePoor: + aMultiplier = 2; + break; + case oreNormal: + aMultiplier = 3; + break; + case oreRich: + aMultiplier = 4; + default: + break; + } + if (aMaterial != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, aMultiplier)) + .duration(10) + .eut(16) + .addTo(hammerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 2 * aMultiplier), + GT_OreDictUnificator.get( + OrePrefixes.dustTiny, + GT_Utility.selectItemInList(0, aMaterial, aMaterial.mOreByProducts), + 1L), + GT_OreDictUnificator.getDust(aPrefix.mSecondaryMaterial)) + .outputChances(10000, 100 * 5 * aMultiplier, 10000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + if (aMaterial.contains(SubTag.NO_SMELTING)) GT_ModHandler.addSmeltingRecipe( + GT_Utility.copyAmount(1, aStack), + GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial.mDirectSmelting, aMultiplier)); + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOreSmelting.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOreSmelting.java new file mode 100644 index 0000000000..93458ee467 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOreSmelting.java @@ -0,0 +1,194 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.primitiveBlastRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.ADDITIVE_AMOUNT; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; + +import gregtech.GT_Mod; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeBuilder; +import gregtech.api.util.GT_Utility; + +public class ProcessingOreSmelting implements gregtech.api.interfaces.IOreRecipeRegistrator { + + private final OrePrefixes[] mSmeltingPrefixes = { OrePrefixes.crushed, OrePrefixes.crushedPurified, + OrePrefixes.crushedCentrifuged, OrePrefixes.dust, OrePrefixes.dustImpure, OrePrefixes.dustPure, + OrePrefixes.dustRefined }; + + public ProcessingOreSmelting() { + for (OrePrefixes tPrefix : this.mSmeltingPrefixes) tPrefix.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + GT_ModHandler.removeFurnaceSmelting(aStack); + if (!aMaterial.contains(SubTag.NO_SMELTING)) { + if ((aMaterial.mBlastFurnaceRequired) || (aMaterial.mDirectSmelting.mBlastFurnaceRequired)) { + if (aMaterial.mBlastFurnaceTemp < 1000 && aMaterial.mDirectSmelting.mBlastFurnaceTemp < 1000) + if (aMaterial.mAutoGenerateBlastFurnaceRecipes + && GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null) { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + recipeBuilder + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)); + if (aMaterial.mBlastFurnaceTemp > 1750) { + recipeBuilder.itemOutputs( + GT_OreDictUnificator.get( + OrePrefixes.ingotHot, + aMaterial, + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), + 1L)); + } else { + recipeBuilder.itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L)); + } + recipeBuilder + .duration(Math.max(aMaterial.getMass() / 4L, 1L) * aMaterial.mBlastFurnaceTemp * TICKS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, (int) aMaterial.mBlastFurnaceTemp) + .addTo(blastFurnaceRecipes); + } + } else { + OrePrefixes outputPrefix; + int outputSize; + switch (aPrefix) { + case crushed: + case crushedPurified: + case crushedCentrifuged: + if (aMaterial.mDirectSmelting == aMaterial) { + outputSize = 10; + outputPrefix = OrePrefixes.nugget; + } else { + if (GT_Mod.gregtechproxy.mMixedOreOnlyYieldsTwoThirdsOfPureOre) { + outputSize = 6; + outputPrefix = OrePrefixes.nugget; + } else { + outputSize = 1; + outputPrefix = OrePrefixes.ingot; + } + } + break; + case dust: + int outputAmount = GT_Mod.gregtechproxy.mMixedOreOnlyYieldsTwoThirdsOfPureOre ? 2 : 3; + if (aMaterial.mDirectSmelting != aMaterial) { + if (!aMaterial.contains(SubTag.DONT_ADD_DEFAULT_BBF_RECIPE) + && aMaterial.mDirectSmelting.getIngots(1) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack)) + .itemOutputs(aMaterial.mDirectSmelting.getIngots(outputAmount)) + .duration(2 * MINUTES) + .metadata(ADDITIVE_AMOUNT, 2) + .addTo(primitiveBlastRecipes); + } else if (aMaterial == Materials.Chalcopyrite) { + GT_Values.RA.stdBuilder() + .itemInputs(aMaterial.getDust(2), new ItemStack(Blocks.sand, 2)) + .itemOutputs( + aMaterial.mDirectSmelting.getIngots(outputAmount), + Materials.Ferrosilite.getDustSmall(2 * outputAmount)) + .duration(2 * MINUTES) + .metadata(ADDITIVE_AMOUNT, 2) + .addTo(primitiveBlastRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(aMaterial.getDust(2), Materials.Glass.getDust(2)) + .itemOutputs( + aMaterial.mDirectSmelting.getIngots(outputAmount), + Materials.Ferrosilite.getDustSmall(7 * outputAmount)) + .duration(2 * MINUTES) + .metadata(ADDITIVE_AMOUNT, 2) + .addTo(primitiveBlastRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(aMaterial.getDust(2), Materials.SiliconDioxide.getDust(2)) + .itemOutputs( + aMaterial.mDirectSmelting.getIngots(outputAmount), + Materials.Ferrosilite.getDustSmall(outputAmount)) + .duration(2 * MINUTES) + .metadata(ADDITIVE_AMOUNT, 2) + .addTo(primitiveBlastRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(aMaterial.getDust(2), Materials.Quartzite.getDust(4)) + .itemOutputs( + aMaterial.mDirectSmelting.getIngots(outputAmount), + Materials.Ferrosilite.getDustSmall(outputAmount)) + .duration(2 * MINUTES) + .metadata(ADDITIVE_AMOUNT, 2) + .addTo(primitiveBlastRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(aMaterial.getDust(2), Materials.NetherQuartz.getDust(2)) + .itemOutputs( + aMaterial.mDirectSmelting.getIngots(outputAmount), + Materials.Ferrosilite.getDustSmall(outputAmount)) + .duration(2 * MINUTES) + .metadata(ADDITIVE_AMOUNT, 2) + .addTo(primitiveBlastRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(aMaterial.getDust(2), Materials.CertusQuartz.getDust(2)) + .itemOutputs( + aMaterial.mDirectSmelting.getIngots(outputAmount), + Materials.Ferrosilite.getDustSmall(outputAmount)) + .duration(2 * MINUTES) + .metadata(ADDITIVE_AMOUNT, 2) + .addTo(primitiveBlastRecipes); + } else if (aMaterial == Materials.Tetrahedrite) { + GT_Values.RA.stdBuilder() + .itemInputs(aMaterial.getDust(2)) + .itemOutputs( + aMaterial.mDirectSmelting.getIngots(outputAmount), + Materials.Antimony.getNuggets(3 * outputAmount)) + .duration(2 * MINUTES) + .metadata(ADDITIVE_AMOUNT, 2) + .addTo(primitiveBlastRecipes); + } else if (aMaterial == Materials.Galena) { + GT_Values.RA.stdBuilder() + .itemInputs(aMaterial.getDust(2)) + .itemOutputs( + aMaterial.mDirectSmelting.getIngots(outputAmount), + Materials.Silver.getNuggets(3 * outputAmount)) + .duration(2 * MINUTES) + .metadata(ADDITIVE_AMOUNT, 2) + .addTo(primitiveBlastRecipes); + } + } + case dustImpure: + case dustPure: + case dustRefined: + if (aMaterial.mDirectSmelting == aMaterial) { + outputPrefix = OrePrefixes.ingot; + outputSize = 1; + } else { + if (GT_Mod.gregtechproxy.mMixedOreOnlyYieldsTwoThirdsOfPureOre) { + outputSize = 6; + outputPrefix = OrePrefixes.nugget; + } else { + outputSize = 1; + outputPrefix = OrePrefixes.ingot; + } + } + break; + default: + outputPrefix = OrePrefixes.ingot; + outputSize = 1; + break; + } + ItemStack tStack = GT_OreDictUnificator.get(outputPrefix, aMaterial.mDirectSmelting, outputSize); + if (tStack == null) tStack = GT_OreDictUnificator.get( + aMaterial.contains(SubTag.SMELTING_TO_GEM) ? OrePrefixes.gem : OrePrefixes.ingot, + aMaterial.mDirectSmelting, + 1L); + if ((tStack == null) && (!aMaterial.contains(SubTag.SMELTING_TO_GEM))) + tStack = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L); + GT_ModHandler.addSmeltingRecipe(aStack, tStack); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPipe.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPipe.java new file mode 100644 index 0000000000..1f97e1e32a --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPipe.java @@ -0,0 +1,141 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.enums.ToolDictNames; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +@SuppressWarnings("RedundantLabeledSwitchRuleCodeBlock") +public class ProcessingPipe implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingPipe() { + OrePrefixes.pipeHuge.add(this); + OrePrefixes.pipeLarge.add(this); + OrePrefixes.pipeMedium.add(this); + OrePrefixes.pipeSmall.add(this); + OrePrefixes.pipeTiny.add(this); + OrePrefixes.pipeRestrictiveHuge.add(this); + OrePrefixes.pipeRestrictiveLarge.add(this); + OrePrefixes.pipeRestrictiveMedium.add(this); + OrePrefixes.pipeRestrictiveSmall.add(this); + OrePrefixes.pipeRestrictiveTiny.add(this); + OrePrefixes.pipeQuadruple.add(this); + OrePrefixes.pipeNonuple.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + switch (aPrefix) { + case pipeHuge, pipeLarge, pipeMedium, pipeSmall, pipeTiny -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.pipeTiny, aMaterial, 8L), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PPP", "h w", "PPP", 'P', OrePrefixes.plate.get(aMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.pipeSmall, aMaterial, 6L), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PWP", "P P", "PHP", 'P', + aMaterial == Materials.Wood ? OrePrefixes.plank.get(aMaterial) + : OrePrefixes.plate.get(aMaterial), + 'H', + aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSoftHammer + : ToolDictNames.craftingToolHardHammer, + 'W', aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSaw + : ToolDictNames.craftingToolWrench }); + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, aMaterial, 2L), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PPP", "W H", "PPP", 'P', + aMaterial == Materials.Wood ? OrePrefixes.plank.get(aMaterial) + : OrePrefixes.plate.get(aMaterial), + 'H', + aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSoftHammer + : ToolDictNames.craftingToolHardHammer, + 'W', aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSaw + : ToolDictNames.craftingToolWrench }); + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.pipeLarge, aMaterial, 1L), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PHP", "P P", "PWP", 'P', + aMaterial == Materials.Wood ? OrePrefixes.plank.get(aMaterial) + : OrePrefixes.plate.get(aMaterial), + 'H', + aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSoftHammer + : ToolDictNames.craftingToolHardHammer, + 'W', aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSaw + : ToolDictNames.craftingToolWrench }); + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.pipeHuge, aMaterial, 1L), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "DhD", "D D", "DwD", 'D', OrePrefixes.plateDouble.get(aMaterial) }); + } + } + case pipeRestrictiveHuge, pipeRestrictiveLarge, pipeRestrictiveMedium, pipeRestrictiveSmall, pipeRestrictiveTiny -> { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get( + OrePrefixes.ring, + Materials.Steel, + aPrefix.mSecondaryMaterial.mAmount / OrePrefixes.ring.mMaterialAmount), + GT_OreDictUnificator.get(aOreDictName.replaceFirst("Restrictive", ""), null, 1L, false, true)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .duration( + ((int) (aPrefix.mSecondaryMaterial.mAmount * 400L / OrePrefixes.ring.mMaterialAmount)) * TICKS) + .eut(4) + .addTo(assemblerRecipes); + } + case pipeQuadruple -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.pipeQuadruple, aMaterial, 1), + GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "MM ", "MM ", " ", 'M', + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, aMaterial, 1) }); + } + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, aMaterial, 4), + GT_Utility.getIntegratedCircuit(9)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeQuadruple, aMaterial, 1)) + .duration(3 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 4)) + .addTo(assemblerRecipes); + } + case pipeNonuple -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PPP", "PPP", "PPP", 'P', GT_OreDictUnificator + .get(aOreDictName.replaceFirst("Nonuple", "Small"), null, 1L, false, true) }); + } + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.pipeSmall, aMaterial, 9), + GT_Utility.getIntegratedCircuit(9)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, aMaterial, 1)) + .duration(3 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + } + default -> {} + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java new file mode 100644 index 0000000000..3b06babee6 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java @@ -0,0 +1,137 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.cutterRecipes; +import static gregtech.api.recipe.RecipeMaps.latheRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import net.minecraft.init.Blocks; +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.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingPlank implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingPlank() { + OrePrefixes.plank.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (aOreDictName.startsWith("plankWood")) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stick, Materials.Wood, 2L)) + .duration(10 * TICKS) + .eut(8) + .addTo(latheRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(1, aStack), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Iron, 1L)) + .itemOutputs(ItemList.Crate_Empty.get(1L)) + .duration(10 * SECONDS) + .eut(1) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(1, aStack), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.WroughtIron, 1L)) + .itemOutputs(ItemList.Crate_Empty.get(1L)) + .duration(10 * SECONDS) + .eut(1) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(1, aStack), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Steel, 1L)) + .itemOutputs(ItemList.Crate_Empty.get(1L)) + .duration(10 * SECONDS) + .eut(1) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(8, aStack), GT_Utility.getIntegratedCircuit(8)) + .itemOutputs(new ItemStack(Blocks.chest, 1)) + .duration(40 * SECONDS) + .eut(4) + .addTo(assemblerRecipes); + + if (aStack.getItemDamage() == 32767) { + for (byte i = 0; i < 64; i = (byte) (i + 1)) { + ItemStack tStack = GT_Utility.copyMetaData(i, aStack); + // Get Recipe and Output, add recipe to delayed removal + ItemStack tOutput = GT_ModHandler.getRecipeOutput(tStack, tStack, tStack); + if ((tOutput != null) && (tOutput.stackSize >= 3)) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, tStack)) + .itemOutputs(GT_Utility.copyAmount(tOutput.stackSize / 3, tOutput)) + .fluidInputs(Materials.Water.getFluid(4)) + .duration(2 * 25 * TICKS) + .eut(4) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, tStack)) + .itemOutputs(GT_Utility.copyAmount(tOutput.stackSize / 3, tOutput)) + .fluidInputs(GT_ModHandler.getDistilledWater(3)) + .duration(2 * 25 * TICKS) + .eut(4) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, tStack)) + .itemOutputs(GT_Utility.copyAmount(tOutput.stackSize / 3, tOutput)) + .fluidInputs(Materials.Lubricant.getFluid(1)) + .duration(25 * TICKS) + .eut(4) + .addTo(cutterRecipes); + GT_ModHandler.removeRecipeDelayed(tStack, tStack, tStack); + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(tOutput.stackSize / 3, tOutput), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "sP", 'P', tStack }); + } + if ((tStack == null) && (i >= 16)) break; + } + } else { + ItemStack tOutput = !aModName.equalsIgnoreCase("thaumcraft") + ? GT_ModHandler.getRecipeOutput(aStack, aStack, aStack) + : GT_ModHandler.getRecipeOutputNoOreDict(aStack, aStack, aStack); + if ((tOutput != null) && (tOutput.stackSize >= 3)) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_Utility.copyAmount(tOutput.stackSize / 3, tOutput)) + .fluidInputs(Materials.Water.getFluid(4)) + .duration(2 * 25) + .eut(4) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_Utility.copyAmount(tOutput.stackSize / 3, tOutput)) + .fluidInputs(GT_ModHandler.getDistilledWater(3)) + .duration(2 * 25) + .eut(4) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_Utility.copyAmount(tOutput.stackSize / 3, tOutput)) + .fluidInputs(Materials.Lubricant.getFluid(1)) + .duration(25) + .eut(4) + .addTo(cutterRecipes); + GT_ModHandler.removeRecipeDelayed(aStack, aStack, aStack); + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(tOutput.stackSize / 3, tOutput), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "sP", 'P', aStack }); + } + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java new file mode 100644 index 0000000000..be8322f30c --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java @@ -0,0 +1,604 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.enums.GT_Values.L; +import static gregtech.api.enums.GT_Values.NI; +import static gregtech.api.enums.GT_Values.W; +import static gregtech.api.recipe.RecipeMaps.alloySmelterRecipes; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.recipe.RecipeMaps.cutterRecipes; +import static gregtech.api.recipe.RecipeMaps.extruderRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.recipe.RecipeMaps.implosionRecipes; +import static gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED; +import static gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS; +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.FUEL_TYPE; +import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; +import static gregtech.common.GT_Proxy.tBits; + +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import gregtech.api.GregTech_API; +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.enums.TextureSet; +import gregtech.api.enums.TierEU; +import gregtech.api.enums.ToolDictNames; +import gregtech.api.recipe.RecipeCategories; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeConstants; +import gregtech.api.util.GT_RecipeRegistrator; +import gregtech.api.util.GT_Utility; + +public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingPlate() { + OrePrefixes.plate.add(this); + OrePrefixes.plateDouble.add(this); + OrePrefixes.plateTriple.add(this); + OrePrefixes.plateQuadruple.add(this); + OrePrefixes.plateQuintuple.add(this); + OrePrefixes.plateDense.add(this); + OrePrefixes.plateAlloy.add(this); + OrePrefixes.itemCasing.add(this); + } + + /** + * Register processes for the {@link ItemStack} with Ore Dictionary Name Prefix "plate" + * + * @param aPrefix always != null, the {@link OrePrefixes} of the {@link ItemStack} + * @param aMaterial always != null, and can be == _NULL if the Prefix is Self Referencing or not Material based! + * the {@link Materials} of the {@link ItemStack} + * @param aOreDictName the Ore Dictionary Name {@link String} of the {@link ItemStack} + * @param aModName the ModID {@link String} of the mod providing this {@link ItemStack} + * @param aStack always != null, the {@link ItemStack} to register + */ + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + + final boolean aNoSmashing = aMaterial.contains(SubTag.NO_SMASHING); + final boolean aNoWorking = aMaterial.contains(SubTag.NO_WORKING); + final long aMaterialMass = aMaterial.getMass(); + + switch (aPrefix) { + case plate -> registerPlate(aMaterial, aStack, aNoSmashing); + case plateDouble -> registerPlateDouble(aMaterial, aStack, aNoSmashing, aMaterialMass); + case plateTriple -> registerPlateTriple(aMaterial, aStack, aNoSmashing, aMaterialMass); + case plateQuadruple -> registerPlateQuadruple(aMaterial, aStack, aNoSmashing, aMaterialMass, aNoWorking); + case plateQuintuple -> registerPlateQuintuple(aMaterial, aStack, aNoSmashing, aMaterialMass); + case plateDense -> registerPlateDense(aMaterial, aStack, aNoSmashing, aMaterialMass); + case itemCasing -> registerItemCasing(aPrefix, aMaterial, aStack, aNoSmashing); + case plateAlloy -> registerPlateAlloy(aOreDictName, aStack); + default -> {} + } + } + + private void registerPlate(final Materials aMaterial, final ItemStack aStack, final boolean aNoSmashing) { + + registerCover(aMaterial, aStack); + + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + GT_ModHandler.removeRecipeDelayed(aStack); + + GT_Utility.removeSimpleIC2MachineRecipe( + GT_Utility.copyAmount(9, aStack), + GT_ModHandler.getCompressorRecipeList(), + GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L)); + + if (aMaterial.mFuelPower > 0) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .metadata(FUEL_VALUE, aMaterial.mFuelPower) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .addTo(GT_RecipeConstants.Fuel); + } + + if (aMaterial.mStandardMoltenFluid != null + && !(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Plate.get(0L)) + .itemOutputs(aMaterial.getPlates(1)) + .fluidInputs(aMaterial.getMolten(L)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(fluidSolidifierRecipes); + } + + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, 2L), + tBits, // DO_NOT_CHECK_FOR_COLLISIONS|BUFFERED|ONLY_ADD_IF_RESULT_IS_NOT_NULL|NOT_REMOVABLE + new Object[] { "hX", 'X', OrePrefixes.plate.get(aMaterial) }); + + if (aMaterial == Materials.Paper) { + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(2, aStack), + BUFFERED, + new Object[] { "XXX", 'X', new ItemStack(Items.reeds, 1, W) }); + } + + if (aMaterial.mUnificatable && aMaterial.mMaterialInto == aMaterial) { + + if (!aNoSmashing) { + + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + aMaterial.getPlates(1), + tBits, // DO_NOT_CHECK_FOR_COLLISIONS|BUFFERED|ONLY_ADD_IF_RESULT_IS_NOT_NULL|NOT_REMOVABLE + new Object[] { "h", // craftingToolHardHammer + "X", "X", 'X', OrePrefixes.ingot.get(aMaterial) }); + + // Only added if IC2 Forge Hammer is enabled in Recipes.cfg: B:ic2forgehammer_true=false + GT_ModHandler.addCraftingRecipe( + aMaterial.getPlates(1), + tBits, // DO_NOT_CHECK_FOR_COLLISIONS|BUFFERED|ONLY_ADD_IF_RESULT_IS_NOT_NULL|NOT_REMOVABLE + new Object[] { "H", // craftingToolForgeHammer + "X", 'H', ToolDictNames.craftingToolForgeHammer, 'X', OrePrefixes.ingot.get(aMaterial) }); + + GT_ModHandler.addCraftingRecipe( + aMaterial.getPlates(1), + tBits, // DO_NOT_CHECK_FOR_COLLISIONS|BUFFERED|ONLY_ADD_IF_RESULT_IS_NOT_NULL|NOT_REMOVABLE + new Object[] { "h", // craftingToolHardHammer + "X", 'X', OrePrefixes.gem.get(aMaterial) }); + + // Only added if IC2 Forge Hammer is enabled in Recipes.cfg: B:ic2forgehammer_true=false + GT_ModHandler.addCraftingRecipe( + aMaterial.getPlates(1), + tBits, // DO_NOT_CHECK_FOR_COLLISIONS|BUFFERED|ONLY_ADD_IF_RESULT_IS_NOT_NULL|NOT_REMOVABLE + new Object[] { "H", // craftingToolForgeHammer + "X", 'H', ToolDictNames.craftingToolForgeHammer, 'X', OrePrefixes.gem.get(aMaterial) }); + } + } + + if (aMaterial.contains(SubTag.MORTAR_GRINDABLE)) { + + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addShapelessCraftingRecipe( + aMaterial.getDust(1), + tBits, // DO_NOT_CHECK_FOR_COLLISIONS|BUFFERED|ONLY_ADD_IF_RESULT_IS_NOT_NULL|NOT_REMOVABLE + new Object[] { ToolDictNames.craftingToolMortar, OrePrefixes.plate.get(aMaterial) }); + } + } + } + } + + private void registerPlateDouble(final Materials aMaterial, final ItemStack aStack, final boolean aNoSmashing, + final long aMaterialMass) { + + registerCover(aMaterial, aStack); + + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + + if (!aNoSmashing || aMaterial.contains(SubTag.STRETCHY)) { + // 2 double -> 1 quadruple plate + if (GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 2L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + // 2 plates -> 1 double plate + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 2L), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .duration(Math.max(aMaterialMass * 2L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } else { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 2L), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .fluidInputs(Materials.Glue.getFluid(10L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(8) + .addTo(assemblerRecipes); + } + + if (!aNoSmashing) { + Object aPlateStack = OrePrefixes.plate.get(aMaterial); + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED, + new Object[] { "I", "B", "h", // craftingToolHardHammer + 'I', aPlateStack, 'B', aPlateStack }); + } + } + } + + private void registerPlateTriple(final Materials aMaterial, final ItemStack aStack, final boolean aNoSmashing, + final long aMaterialMass) { + + registerCover(aMaterial, aStack); + + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + + if (!aNoSmashing || aMaterial.contains(SubTag.STRETCHY)) { + if (GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L) != null) { + // 3 triple plates -> 1 dense plate + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L)) + .duration(Math.max(aMaterialMass * 3L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 3L), + GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .duration(Math.max(aMaterialMass * 3L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } else { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 3L), + GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .fluidInputs(Materials.Glue.getFluid(20L)) + .duration(4 * SECONDS + 16 * TICKS) + .eut(8) + .addTo(assemblerRecipes); + } + + if (!aNoSmashing) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + Object aPlateStack = OrePrefixes.plate.get(aMaterial); + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED, + new Object[] { "I", "B", "h", // craftingToolHardHammer + 'I', OrePrefixes.plateDouble.get(aMaterial), 'B', aPlateStack }); + + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED, + new Object[] { gregtech.api.enums.ToolDictNames.craftingToolForgeHammer, aPlateStack, aPlateStack, + aPlateStack }); + } + } + + if (GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Block_Powderbarrel.get(4)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_ModHandler.getIC2Item("dynamite", 1, null)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), new ItemStack(Blocks.tnt, 2)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_ModHandler.getIC2Item("industrialTnt", 1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(implosionRecipes); + } + } + + private void registerPlateQuadruple(final Materials aMaterial, final ItemStack aStack, final boolean aNoSmashing, + final long aMaterialMass, final boolean aNoWorking) { + + registerCover(aMaterial, aStack); + + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + + if (!aNoSmashing || aMaterial.contains(SubTag.STRETCHY)) { + // Quadruple plate + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 4L), + GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .duration(Math.max(aMaterialMass * 4L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } else { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 4L), + GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .fluidInputs(Materials.Glue.getFluid(30L)) + .duration(6 * SECONDS + 8 * TICKS) + .eut(8) + .addTo(assemblerRecipes); + } + if (!aNoSmashing) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + Object aPlateStack = OrePrefixes.plate.get(aMaterial); + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED, + new Object[] { "I", "B", "h", // craftingToolHardHammer + 'I', OrePrefixes.plateTriple.get(aMaterial), 'B', aPlateStack }); + + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED, + new Object[] { gregtech.api.enums.ToolDictNames.craftingToolForgeHammer, aPlateStack, aPlateStack, + aPlateStack, aPlateStack }); + } + } + } + + private void registerPlateQuintuple(final Materials aMaterial, final ItemStack aStack, final boolean aNoSmashing, + final long aMaterialMass) { + + registerCover(aMaterial, aStack); + + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + + if (!aNoSmashing || aMaterial.contains(SubTag.STRETCHY)) { + // quintuple plate + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 5L), + GT_Utility.getIntegratedCircuit(5)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .duration(Math.max(aMaterialMass * 5L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } else { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 5L), + GT_Utility.getIntegratedCircuit(5)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .fluidInputs(Materials.Glue.getFluid(40L)) + .duration(8 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + } + if (!aNoSmashing) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + Object aPlateStack = OrePrefixes.plate.get(aMaterial); + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED, + new Object[] { "I", "B", "h", // craftingToolHardHammer + 'I', OrePrefixes.plateQuadruple.get(aMaterial), 'B', aPlateStack }); + + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED, + new Object[] { ToolDictNames.craftingToolForgeHammer, aPlateStack, aPlateStack, aPlateStack, + aPlateStack, aPlateStack }); + } + } + } + + private void registerPlateDense(final Materials aMaterial, final ItemStack aStack, final boolean aNoSmashing, + final long aMaterialMass) { + + registerCover(aMaterial, aStack); + + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + + if (!aNoSmashing || aMaterial.contains(SubTag.STRETCHY)) { + // Dense plate + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 9L), + GT_Utility.getIntegratedCircuit(9)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .duration(Math.max(aMaterialMass * 9L, 1L)) + .eut(calculateRecipeEU(aMaterial, 96)) + .addTo(benderRecipes); + } + } + + private void registerItemCasing(final OrePrefixes aPrefix, final Materials aMaterial, final ItemStack aStack, + final boolean aNoSmashing) { + + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + + if (aMaterial.mStandardMoltenFluid != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Casing.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(L / 2)) + .duration(16 * TICKS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(fluidSolidifierRecipes); + } + + if (aMaterial.mUnificatable && aMaterial.mMaterialInto == aMaterial && !aNoSmashing) { + + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 1L), + tBits, // DO_NOT_CHECK_FOR_COLLISIONS|BUFFERED|ONLY_ADD_IF_RESULT_IS_NOT_NULL|NOT_REMOVABLE + new Object[] { "h X", 'X', OrePrefixes.plate.get(aMaterial) }); + + // Only added if IC2 Forge Hammer is enabled in Recipes.cfg: B:ic2forgehammer_true=false + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 1L), + tBits, // DO_NOT_CHECK_FOR_COLLISIONS|BUFFERED|ONLY_ADD_IF_RESULT_IS_NOT_NULL|NOT_REMOVABLE + new Object[] { "H X", 'H', ToolDictNames.craftingToolForgeHammer, 'X', + OrePrefixes.plate.get(aMaterial) }); + } + } + + if (GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 2L), + ItemList.Shape_Mold_Casing.get(0L)) + .itemOutputs(GT_Utility.copyAmount(3, aStack)) + .duration(6 * SECONDS + 8 * TICKS) + .eut(calculateRecipeEU(aMaterial, 15)) + .recipeCategory(RecipeCategories.alloySmelterMolding) + .addTo(alloySmelterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), + ItemList.Shape_Extruder_Casing.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 2L)) + .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 45)) + .addTo(extruderRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 2L)) + .fluidInputs( + Materials.Water.getFluid( + Math.max( + 4, + Math.min( + 1000, + ((int) Math.max(aMaterial.getMass(), 1L)) * (calculateRecipeEU(aMaterial, 16)) / 320)))) + .duration(2 * ((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 2L)) + .fluidInputs( + GT_ModHandler.getDistilledWater( + Math.max( + 3, + Math.min( + 750, + ((int) Math.max(aMaterial.getMass(), 1L)) * (calculateRecipeEU(aMaterial, 16)) / 426)))) + .duration(2 * ((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 2L)) + .fluidInputs( + Materials.Lubricant.getFluid( + Math.max( + 1, + Math.min( + 250, + ((int) Math.max(aMaterial.getMass(), 1L)) * (calculateRecipeEU(aMaterial, 16)) + / 1280)))) + .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(cutterRecipes); + } + GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); + } + + private void registerPlateAlloy(final String aOreDictName, final ItemStack aStack) { + + switch (aOreDictName) { + case "plateAlloyCarbon" -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_ModHandler.getIC2Item("generator", 1L), GT_Utility.copyAmount(4, aStack)) + .itemOutputs(GT_ModHandler.getIC2Item("windMill", 1L)) + .duration(5 * MINUTES + 20 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), new ItemStack(Blocks.glass, 3, W)) + .itemOutputs(GT_ModHandler.getIC2Item("reinforcedGlass", 4L)) + .duration(20 * SECONDS) + .eut(4) + .addTo(alloySmelterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), Materials.Glass.getDust(3)) + .itemOutputs(GT_ModHandler.getIC2Item("reinforcedGlass", 4L)) + .duration(20 * SECONDS) + .eut(4) + .addTo(alloySmelterRecipes); + } + case "plateAlloyAdvanced" -> { + GT_ModHandler.addAlloySmelterRecipe( + GT_Utility.copyAmount(1, aStack), + new ItemStack(Blocks.glass, 3, W), + GT_ModHandler.getIC2Item("reinforcedGlass", 4L), + 400, + 4, + false); + GT_ModHandler.addAlloySmelterRecipe( + GT_Utility.copyAmount(1, aStack), + Materials.Glass.getDust(3), + GT_ModHandler.getIC2Item("reinforcedGlass", 4L), + 400, + 4, + false); + } + case "plateAlloyIridium" -> + + // Remove IC2 Shaped recipe for Iridium Reinforced Plate + GT_ModHandler.removeRecipeByOutputDelayed(aStack); + default -> {} + } + } + + private void registerCover(final Materials aMaterial, final ItemStack aStack) { + + // Get ItemStack of Block matching Materials + ItemStack tStack = NI; + // Try different prefixes to use same smooth stones as older GT5U + for (OrePrefixes orePrefix : new OrePrefixes[] { OrePrefixes.block, OrePrefixes.block_, OrePrefixes.stoneSmooth, + OrePrefixes.stone }) { + if ((tStack = GT_OreDictUnificator.get(orePrefix, aMaterial, 1)) != NI) break; + } + + // Register the cover + GregTech_API.registerCover( + aStack, + // If there is an ItemStack of Block for Materials + tStack == NI ? + // Use Materials mRGBa dyed blocs/materialicons/MATERIALSET/block1 icons + TextureFactory.builder() + .addIcon(aMaterial.mIconSet.mTextures[TextureSet.INDEX_block1]) + .setRGBA(aMaterial.mRGBa) + .stdOrient() + .build() + : + // or copy Block texture + TextureFactory.of(Block.getBlockFromItem(tStack.getItem()), tStack.getItemDamage()), + null); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPure.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPure.java new file mode 100644 index 0000000000..01262d32f4 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPure.java @@ -0,0 +1,50 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingPure implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingPure() { + OrePrefixes.crushedPurified.add(this); + OrePrefixes.cleanGravel.add(this); + OrePrefixes.reduced.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustPure, aMaterial.mMacerateInto, 1L)) + .duration(10) + .eut(16) + .addTo(hammerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get( + OrePrefixes.dustPure, + aMaterial.mMacerateInto, + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), + 1L), + GT_OreDictUnificator.get( + OrePrefixes.dust, + GT_Utility.selectItemInList(1, aMaterial.mMacerateInto, aMaterial.mOreByProducts), + 1L)) + .outputChances(10000, 1000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingRawOre.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingRawOre.java new file mode 100644 index 0000000000..5ece6f5315 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingRawOre.java @@ -0,0 +1,219 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.enums.ToolDictNames; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingRawOre implements gregtech.api.interfaces.IOreRecipeRegistrator { + + private final OrePrefixes[] mRawOrePrefixes = { OrePrefixes.rawOre }; + + public ProcessingRawOre() { + for (OrePrefixes tPrefix : this.mRawOrePrefixes) tPrefix.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (aMaterial == Materials.Oilsands) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(new ItemStack(net.minecraft.init.Blocks.sand, 1, 0)) + .outputChances(4000) + .fluidOutputs(Materials.OilHeavy.getFluid(2000L)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(centrifugeRecipes); + } else { + registerStandardOreRecipes( + aPrefix, + aMaterial, + GT_Utility.copyAmount(1, aStack), + Math.max( + 1, + gregtech.api.GregTech_API.sOPStuff.get( + gregtech.api.enums.ConfigCategories.Materials.oreprocessingoutputmultiplier, + aMaterial.toString(), + 1))); + } + } + + private boolean registerStandardOreRecipes(OrePrefixes aPrefix, Materials aMaterial, ItemStack aOreStack, + int aMultiplier) { + if ((aOreStack == null) || (aMaterial == null)) return false; + GT_ModHandler + .addValuableOre(GT_Utility.getBlockFromStack(aOreStack), aOreStack.getItemDamage(), aMaterial.mOreValue); + Materials tMaterial = aMaterial.mOreReplacement; + Materials tPrimaryByMaterial = null; + aMultiplier = Math.max(1, aMultiplier); + aOreStack = GT_Utility.copyAmount(1, aOreStack); + aOreStack.stackSize = 1; + ItemStack tIngot = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L); + ItemStack tGem = GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial, 1L); + ItemStack tSmeltInto = tIngot + == null + ? null + : aMaterial.contains(SubTag.SMELTING_TO_GEM) + ? GT_OreDictUnificator.get( + OrePrefixes.gem, + tMaterial.mDirectSmelting, + GT_OreDictUnificator.get( + OrePrefixes.crystal, + tMaterial.mDirectSmelting, + GT_OreDictUnificator.get( + OrePrefixes.gem, + tMaterial, + GT_OreDictUnificator.get(OrePrefixes.crystal, tMaterial, 1L), + 1L), + 1L), + 1L) + : tIngot; + ItemStack tDust = GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial, tGem, 1L); + ItemStack tCleaned = GT_OreDictUnificator.get(OrePrefixes.crushedPurified, tMaterial, tDust, 1L); + ItemStack tCrushed = GT_OreDictUnificator.get(OrePrefixes.crushed, tMaterial, (long) aMaterial.mOreMultiplier); + ItemStack tPrimaryByProduct = null; + + if (tCrushed == null) { + tCrushed = GT_OreDictUnificator.get( + OrePrefixes.dustImpure, + tMaterial, + GT_Utility.copyAmount(aMaterial.mOreMultiplier, tCleaned, tDust, tGem), + (long) aMaterial.mOreMultiplier); + } + + for (Materials tMat : aMaterial.mOreByProducts) { + GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); + if (tPrimaryByProduct == null) { + tPrimaryByMaterial = tMat; + tPrimaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); + if (GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L) == null) GT_OreDictUnificator + .get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L); + } + GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); + if (GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L) == null) GT_OreDictUnificator + .get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L); + } + + if (tPrimaryByMaterial == null) tPrimaryByMaterial = tMaterial; + if (tPrimaryByProduct == null) tPrimaryByProduct = tDust; + boolean tHasSmelting = false; + + if (tSmeltInto != null) { + if ((aMaterial.mBlastFurnaceRequired) || (aMaterial.mDirectSmelting.mBlastFurnaceRequired)) { + GT_ModHandler.removeFurnaceSmelting(aOreStack); + } else { + tHasSmelting = GT_ModHandler + .addSmeltingRecipe(aOreStack, GT_Utility.copyAmount(aMaterial.mSmeltingMultiplier, tSmeltInto)); + } + + if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_TRIPLE)) { + if (aMaterial.mAutoGenerateBlastFurnaceRecipes) { + GT_Values.RA.stdBuilder() + .itemInputs( + aOreStack, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcite, aMultiplier)) + .itemOutputs( + GT_Utility.mul(3 * aMaterial.mSmeltingMultiplier, tSmeltInto), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)) + .duration(tSmeltInto.stackSize * 25 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1500) + .addTo(blastFurnaceRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + aOreStack, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, aMultiplier)) + .itemOutputs( + GT_Utility.mul(3 * aMaterial.mSmeltingMultiplier, tSmeltInto), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)) + .duration(tSmeltInto.stackSize * 25 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1500) + .addTo(blastFurnaceRecipes); + } + } else if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_DOUBLE)) { + if (aMaterial.mAutoGenerateBlastFurnaceRecipes) { + GT_Values.RA.stdBuilder() + .itemInputs( + aOreStack, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcite, aMultiplier)) + .itemOutputs( + GT_Utility.mul(2 * aMaterial.mSmeltingMultiplier, tSmeltInto), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)) + .duration(tSmeltInto.stackSize * 25 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1500) + .addTo(blastFurnaceRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + aOreStack, + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quicklime, aMultiplier)) + .itemOutputs( + GT_Utility.mul(2 * aMaterial.mSmeltingMultiplier, tSmeltInto), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)) + .duration(tSmeltInto.stackSize * 25 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1500) + .addTo(blastFurnaceRecipes); + } + } + } + + if (!tHasSmelting) { + GT_ModHandler.addSmeltingRecipe( + aOreStack, + GT_OreDictUnificator + .get(OrePrefixes.gem, tMaterial.mDirectSmelting, Math.max(1, aMaterial.mSmeltingMultiplier / 2))); + } + + if (tCrushed != null) { + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.mul(1, tCrushed), + new Object[] { aOreStack, ToolDictNames.craftingToolHardHammer }); + + GT_Values.RA.stdBuilder() + .itemInputs(aOreStack) + .itemOutputs(GT_Utility.copy(GT_Utility.copyAmount(tCrushed.stackSize, tGem), tCrushed)) + .duration(10) + .eut(16) + .addTo(hammerRecipes); + + int chanceOre2 = tPrimaryByProduct == null ? 0 + : tPrimaryByProduct.stackSize * 5 * aMaterial.mByProductMultiplier; + chanceOre2 = 100 * chanceOre2; // converting to the GT format, 100% is 10000 + GT_Values.RA.stdBuilder() + .itemInputs(aOreStack) + .itemOutputs( + GT_Utility.mul(2, tCrushed), + tMaterial.contains(SubTag.PULVERIZING_CINNABAR) ? GT_OreDictUnificator.get( + OrePrefixes.crystal, + Materials.Cinnabar, + GT_OreDictUnificator + .get(OrePrefixes.gem, tPrimaryByMaterial, GT_Utility.copyAmount(1, tPrimaryByProduct), 1L), + 1L) + : GT_OreDictUnificator + .get(OrePrefixes.gem, tPrimaryByMaterial, GT_Utility.copyAmount(1, tPrimaryByProduct), 1L), + GT_OreDictUnificator.getDust(aPrefix.mSecondaryMaterial)) + .outputChances(10000, chanceOre2, 5000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + } + return true; + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingRecycling.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingRecycling.java new file mode 100644 index 0000000000..bfa580b4c4 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingRecycling.java @@ -0,0 +1,45 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.cannerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeBuilder; +import gregtech.api.util.GT_Utility; + +public class ProcessingRecycling implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingRecycling() { + for (OrePrefixes tPrefix : OrePrefixes.values()) + if ((tPrefix.mIsMaterialBased) && (tPrefix.mMaterialAmount > 0L) && (tPrefix.mIsContainer)) + tPrefix.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if ((aMaterial != Materials.Empty) && (GT_Utility.getFluidForFilledItem(aStack, true) == null) + && !aMaterial.contains(SubTag.SMELTING_TO_FLUID) + && (GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L) != null)) { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + recipeBuilder.itemInputs(aStack); + if (GT_Utility.getContainerItem(aStack, true) == null) { + recipeBuilder.itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, aPrefix.mMaterialAmount / 3628800L)); + } else { + recipeBuilder.itemOutputs( + GT_Utility.getContainerItem(aStack, true), + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, aPrefix.mMaterialAmount / 3628800L)); + } + recipeBuilder.duration(((int) Math.max(aMaterial.getMass() / 2L, 1L)) * TICKS) + .eut(2) + .addTo(cannerRecipes); + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingRotor.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingRotor.java new file mode 100644 index 0000000000..3548bd437b --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingRotor.java @@ -0,0 +1,97 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.extruderRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +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.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingRotor implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingRotor() { + OrePrefixes.rotor.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if ((aMaterial.mUnificatable) && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_WORKING)) { + ItemStack tPlate = GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 4L); + ItemStack tRing = GT_OreDictUnificator.get(OrePrefixes.ring, aMaterial, 1L); + if (GT_Utility.isStackValid(tPlate) && GT_Utility.isStackValid(tRing)) { + + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "PhP", "SRf", "PdP", 'P', + aMaterial == Materials.Wood ? OrePrefixes.plank.get(aMaterial) + : OrePrefixes.plate.get(aMaterial), + 'R', OrePrefixes.ring.get(aMaterial), 'S', OrePrefixes.screw.get(aMaterial) }); + } + + GT_Values.RA.stdBuilder() + .itemInputs(tPlate.copy(), tRing.copy(), GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L)) + .fluidInputs(Materials.Tin.getMolten(32)) + .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 24)) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(tPlate.copy(), tRing.copy(), GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L)) + .fluidInputs(Materials.Lead.getMolten(48)) + .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 24)) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(tPlate.copy(), tRing.copy(), GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L)) + .fluidInputs(Materials.SolderingAlloy.getMolten(16)) + .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 24)) + .addTo(assemblerRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 5L), + ItemList.Shape_Extruder_Rotor.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L)) + .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 24)) + .addTo(extruderRecipes); + } + if (aMaterial.mStandardMoltenFluid != null) { + if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Rotor.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.rotor, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(612L)) + .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 24)) + .addTo(fluidSolidifierRecipes); + } + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingRound.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingRound.java new file mode 100644 index 0000000000..0eb2cb3dd0 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingRound.java @@ -0,0 +1,52 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.latheRecipes; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import net.minecraft.item.ItemStack; + +import appeng.core.Api; +import gregtech.api.enums.GT_Values; +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_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingRound implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingRound() { + OrePrefixes.round.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (!aMaterial.contains(SubTag.NO_WORKING)) { + if (GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial, 1L)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .duration(((int) Math.max(aMaterial.getMass() / 4L, 1L)) * TICKS) + .eut(8) + .addTo(latheRecipes); + } + + if ((aMaterial.mUnificatable) && (aMaterial.mMaterialInto == aMaterial)) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.round, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "fX", "Xh", 'X', OrePrefixes.nugget.get(aMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.round, aMaterial, 4L), + GT_Proxy.tBits, + new Object[] { "fXh", 'X', OrePrefixes.ingot.get(aMaterial) }); + } + } + Api.INSTANCE.registries() + .matterCannon() + .registerAmmo(GT_OreDictUnificator.get(OrePrefixes.round, aMaterial, 1L), aMaterial.getMass()); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingSand.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingSand.java new file mode 100644 index 0000000000..b1996d067f --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingSand.java @@ -0,0 +1,36 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.init.Blocks; +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.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingSand implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingSand() { + OrePrefixes.sand.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (aOreDictName.equals("sandOil")) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Cell_Empty.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Oil, 1L), + new ItemStack(Blocks.sand, 1, 0)) + .duration(50 * SECONDS) + .eut(5) + .addTo(centrifugeRecipes); + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingSaplings.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingSaplings.java new file mode 100644 index 0000000000..f13c2aa9b5 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingSaplings.java @@ -0,0 +1,50 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.compressorRecipes; +import static gregtech.api.recipe.RecipeMaps.latheRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +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.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingSaplings implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingSaplings() { + OrePrefixes.treeSapling.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Wood, 2L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(8, aStack)) + .itemOutputs(ItemList.IC2_Plantball.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.stick, Materials.Wood, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Wood, 1L)) + .duration(16 * TICKS) + .eut(8) + .addTo(latheRecipes); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingScrew.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingScrew.java new file mode 100644 index 0000000000..afafe8525d --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingScrew.java @@ -0,0 +1,46 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.latheRecipes; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingScrew implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingScrew() { + OrePrefixes.screw.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (!aMaterial.contains(SubTag.NO_WORKING)) { + if (GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .duration(((int) Math.max(aMaterial.getMass() / 8L, 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 4)) + .addTo(latheRecipes); + } + if ((aMaterial.mUnificatable) && (aMaterial.mMaterialInto == aMaterial)) + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.screw, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "fX", "X ", 'X', OrePrefixes.bolt.get(aMaterial) }); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java new file mode 100644 index 0000000000..5493aa9b8e --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java @@ -0,0 +1,620 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.alloySmelterRecipes; +import static gregtech.api.recipe.RecipeMaps.extruderRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +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.enums.TierEU; +import gregtech.api.recipe.RecipeCategories; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +@SuppressWarnings("RedundantLabeledSwitchRuleCodeBlock") +public class ProcessingShaping implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingShaping() { + OrePrefixes.ingot.add(this); + OrePrefixes.dust.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (((aMaterial == Materials.Glass) || (GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null)) + && (!aMaterial.contains(SubTag.NO_SMELTING))) { + long aMaterialMass = aMaterial.getMass(); + int tAmount = (int) (aPrefix.mMaterialAmount / 3628800L); + if ((tAmount > 0) && (tAmount <= 64) && (aPrefix.mMaterialAmount % 3628800L == 0L)) { + int tVoltageMultiplier = aMaterial.mBlastFurnaceTemp >= 2800 ? 60 : 15; + int tTrueVoltage = aMaterial.getProcessingMaterialTierEU(); + + if (aMaterial.contains(SubTag.NO_SMASHING)) { + tVoltageMultiplier /= 4; + } else if (aPrefix.name() + .startsWith(OrePrefixes.dust.name())) { + return; + } + + if (!OrePrefixes.block.isIgnored(aMaterial.mSmeltInto) + && (GT_OreDictUnificator.get(OrePrefixes.block, aMaterial.mSmeltInto, 1L) != null) + && aMaterial != Materials.Ichorium) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack), ItemList.Shape_Extruder_Block.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial.mSmeltInto, tAmount)) + .duration((10 * tAmount) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + + // Allow creation of alloy smelter recipes for material recycling if < IV tier. + if (tTrueVoltage < TierEU.IV) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(9, aStack), ItemList.Shape_Mold_Block.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial.mSmeltInto, tAmount)) + .duration((5 * tAmount) * TICKS) + .eut(calculateRecipeEU(aMaterial, 4 * tVoltageMultiplier)) + .recipeCategory(RecipeCategories.alloySmelterMolding) + .addTo(alloySmelterRecipes); + } + } + if ((aPrefix != OrePrefixes.ingot || aMaterial != aMaterial.mSmeltInto) + && GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Ingot.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, tAmount)) + .duration(10 * TICKS) + .eut(calculateRecipeEU(aMaterial, 4 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.pipeTiny, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Pipe_Tiny.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeTiny, aMaterial.mSmeltInto, tAmount * 2)) + .duration((4 * tAmount) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.pipeSmall, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Pipe_Small.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeSmall, aMaterial.mSmeltInto, tAmount)) + .duration((8 * tAmount) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.pipeMedium, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), ItemList.Shape_Extruder_Pipe_Medium.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeMedium, aMaterial.mSmeltInto, tAmount)) + .duration((24 * tAmount) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.pipeLarge, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(6, aStack), ItemList.Shape_Extruder_Pipe_Large.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeLarge, aMaterial.mSmeltInto, tAmount)) + .duration((48 * tAmount) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.pipeHuge, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(12, aStack), ItemList.Shape_Extruder_Pipe_Huge.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeHuge, aMaterial.mSmeltInto, tAmount)) + .duration((96 * tAmount) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Plate.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Small_Gear.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.turbineBlade, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(6, aStack), ItemList.Shape_Extruder_Turbine_Blade.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.turbineBlade, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + + if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { + if (aMaterial.mStandardMoltenFluid != null) { + if (GT_OreDictUnificator.get(OrePrefixes.ring, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Ring.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ring, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(36L)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 4 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.screw, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Screw.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.screw, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(18L)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(calculateRecipeEU(aMaterial, 2 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Rod.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(72L)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Bolt.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(18L)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(calculateRecipeEU(aMaterial, 2 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.round, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Round.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.round, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(18L)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(calculateRecipeEU(aMaterial, 2 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Rod_Long.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(144L)) + .duration(15 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.turbineBlade, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Turbine_Blade.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.turbineBlade, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(864L)) + .duration(20 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.pipeTiny, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Pipe_Tiny.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeTiny, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(72L)) + .duration(1 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.pipeSmall, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Pipe_Small.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeSmall, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(144L)) + .duration(2 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.pipeMedium, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Pipe_Medium.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeMedium, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(432L)) + .duration(4 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.pipeLarge, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Pipe_Large.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeLarge, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(864L)) + .duration(8 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.pipeHuge, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Pipe_Huge.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.pipeHuge, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(1728L)) + .duration(16 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(fluidSolidifierRecipes); + } + } + } + if (tAmount * 2 <= 64 && aMaterial != Materials.Obsidian) { + if (!(aMaterial == Materials.Aluminium)) { + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Rod.get(0L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mSmeltInto, tAmount * 2)) + .duration(((int) Math.max(aMaterialMass * 2L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 6 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + } else { + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Rod.get(0L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mSmeltInto, tAmount * 2)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 2 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + } + } + if (tAmount * 2 <= 64) { + if (GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Wire.get(0L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial.mSmeltInto, tAmount * 2)) + .duration(((int) Math.max(aMaterialMass * 2L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 6 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + } + if (tAmount * 8 <= 64) { + if (GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Bolt.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial.mSmeltInto, tAmount * 8)) + .duration(((int) Math.max(aMaterialMass * 2L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + } + if (tAmount * 4 <= 64) { + if (GT_OreDictUnificator.get(OrePrefixes.ring, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Ring.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.ring, aMaterial.mSmeltInto, tAmount * 4)) + .duration(((int) Math.max(aMaterialMass * 2L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 6 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if ((aMaterial.mUnificatable) && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_SMASHING)) { + // If material tier < IV then add manual recipe. + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV + && GT_OreDictUnificator.get(OrePrefixes.ring, aMaterial, 1L) != null) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.ring, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "h ", "fX", 'X', OrePrefixes.stick.get(aMaterial) }); + } + } + } + + if (GT_OreDictUnificator.get(OrePrefixes.toolHeadSword, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Extruder_Sword.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.toolHeadSword, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 2L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.toolHeadPickaxe, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), ItemList.Shape_Extruder_Pickaxe.get(0L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.toolHeadPickaxe, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 3L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.toolHeadShovel, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Shovel.get(0L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.toolHeadShovel, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 1L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.toolHeadAxe, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), ItemList.Shape_Extruder_Axe.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.toolHeadAxe, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 3L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.toolHeadHoe, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Extruder_Hoe.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.toolHeadHoe, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 2L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.toolHeadHammer, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(6, aStack), ItemList.Shape_Extruder_Hammer.get(0L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.toolHeadHammer, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 6L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.toolHeadFile, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Extruder_File.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.toolHeadFile, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 2L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.toolHeadSaw, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Extruder_Saw.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.toolHeadSaw, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 2L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), ItemList.Shape_Extruder_Gear.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 5L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 8 * tVoltageMultiplier)) + .addTo(extruderRecipes); + } + + if (!(aMaterial == Materials.StyreneButadieneRubber || aMaterial == Materials.Silicone)) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Mold_Plate.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 2L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 2 * tVoltageMultiplier)) + .recipeCategory(RecipeCategories.alloySmelterMolding) + .addTo(alloySmelterRecipes); + } + } + } else { + // If tier < IV then add ability to turn ingots into plates via alloy smelter. + if (tTrueVoltage < TierEU.IV) { + if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Mold_Plate.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 2L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 2 * tVoltageMultiplier)) + .recipeCategory(RecipeCategories.alloySmelterMolding) + .addTo(alloySmelterRecipes); + } + } + } + + // If tier < IV then add ability to turn ingots into gears via alloy smelter. + if (tTrueVoltage < TierEU.IV) { + if (GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial.mSmeltInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(8, aStack), ItemList.Shape_Mold_Gear.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial.mSmeltInto, tAmount)) + .duration(((int) Math.max(aMaterialMass * 10L * tAmount, tAmount)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 2 * tVoltageMultiplier)) + .recipeCategory(RecipeCategories.alloySmelterMolding) + .addTo(alloySmelterRecipes); + } + } + + switch (aMaterial.mSmeltInto.mName) { + case "Glass" -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Bottle.get(0L)) + .itemOutputs(new ItemStack(Items.glass_bottle, 1)) + .duration((tAmount * 32) * TICKS) + .eut(16) + .addTo(extruderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Mold_Bottle.get(0L)) + .itemOutputs(new ItemStack(Items.glass_bottle, 1)) + .duration((tAmount * 64) * TICKS) + .eut(4) + .addTo(alloySmelterRecipes); + } + case "Steel" -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Cell.get(0L)) + .itemOutputs(ItemList.Cell_Empty.get(tAmount)) + .duration((tAmount * 128) * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(extruderRecipes); + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casingadviron", tAmount * 2)) + .duration((tAmount * 32) * TICKS) + .eut(3 * tVoltageMultiplier) + .addTo(extruderRecipes); + } + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Mold_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casingadviron", tAmount * 3)) + .duration((tAmount * 128) * TICKS) + .eut(1 * tVoltageMultiplier) + .addTo(alloySmelterRecipes); + } + } + case "Iron", "WroughtIron" -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Cell.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("fuelRod", tAmount)) + .duration((tAmount * 128) * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(extruderRecipes); + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casingiron", tAmount * 2)) + .duration((tAmount * 32) * TICKS) + .eut(3 * tVoltageMultiplier) + .addTo(extruderRecipes); + } + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Mold_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casingiron", tAmount * 3)) + .duration((tAmount * 128) * TICKS) + .eut(1 * tVoltageMultiplier) + .addTo(alloySmelterRecipes); + } + if (tAmount * 31 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(31, aStack), ItemList.Shape_Mold_Anvil.get(0L)) + .itemOutputs(new ItemStack(Blocks.anvil, 1, 0)) + .duration((tAmount * 512) * TICKS) + .eut(4 * tVoltageMultiplier) + .addTo(alloySmelterRecipes); + } + } + case "Tin" -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Extruder_Cell.get(0L)) + .itemOutputs(ItemList.Cell_Empty.get(tAmount)) + .duration((tAmount * 128) * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(extruderRecipes); + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casingtin", tAmount * 2)) + .duration((tAmount * 32) * TICKS) + .eut(3 * tVoltageMultiplier) + .addTo(extruderRecipes); + } + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Mold_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casingtin", tAmount * 3)) + .duration((tAmount * 128) * TICKS) + .eut(1 * tVoltageMultiplier) + .addTo(alloySmelterRecipes); + } + } + case "Lead" -> { + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casinglead", tAmount * 2)) + .duration((tAmount * 32) * TICKS) + .eut(3 * tVoltageMultiplier) + .addTo(extruderRecipes); + } + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Mold_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casinglead", tAmount * 3)) + .duration((tAmount * 128) * TICKS) + .eut(1 * tVoltageMultiplier) + .addTo(alloySmelterRecipes); + } + } + case "Copper", "AnnealedCopper" -> { + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casingcopper", tAmount * 2)) + .duration((tAmount * 32) * TICKS) + .eut(3 * tVoltageMultiplier) + .addTo(extruderRecipes); + } + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Mold_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casingcopper", tAmount * 3)) + .duration((tAmount * 128) * TICKS) + .eut(1 * tVoltageMultiplier) + .addTo(alloySmelterRecipes); + } + } + case "Bronze" -> { + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casingbronze", tAmount * 2)) + .duration((tAmount * 32) * TICKS) + .eut(3 * tVoltageMultiplier) + .addTo(extruderRecipes); + } + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Mold_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casingbronze", tAmount * 3)) + .duration((tAmount * 128) * TICKS) + .eut(1 * tVoltageMultiplier) + .addTo(alloySmelterRecipes); + } + } + case "Gold" -> { + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casinggold", tAmount * 2)) + .duration((tAmount * 32) * TICKS) + .eut(3 * tVoltageMultiplier) + .addTo(extruderRecipes); + } + if (tAmount * 2 <= 64) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), ItemList.Shape_Mold_Casing.get(0L)) + .itemOutputs(GT_ModHandler.getIC2Item("casinggold", tAmount * 3)) + .duration((tAmount * 128) * TICKS) + .eut(1 * tVoltageMultiplier) + .addTo(alloySmelterRecipes); + } + } + case "Polytetrafluoroethylene" -> { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), ItemList.Shape_Extruder_Cell.get(0L)) + .itemOutputs(ItemList.Cell_Empty.get(tAmount * 4)) + .duration((tAmount * 128) * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(extruderRecipes); + } + } + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingSlab.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingSlab.java new file mode 100644 index 0000000000..35947755d3 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingSlab.java @@ -0,0 +1,36 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.enums.Mods.Railcraft; +import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +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.util.GT_Utility; + +public class ProcessingSlab implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingSlab() { + OrePrefixes.slab.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (aOreDictName.startsWith("slabWood")) { + if (Railcraft.isModLoaded()) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack)) + .itemOutputs(ItemList.RC_Tie_Wood.get(3L)) + .fluidInputs(Materials.Creosote.getFluid(300L)) + .duration(10 * SECONDS) + .eut(4) + .addTo(chemicalBathRecipes); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStick.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStick.java new file mode 100644 index 0000000000..e5aac7bfe7 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStick.java @@ -0,0 +1,141 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.recipe.RecipeMaps.cutterRecipes; +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.latheRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingStick implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingStick() { + OrePrefixes.stick.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.springSmall, aMaterial, 1L), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { " s ", "fPx", 'P', OrePrefixes.stick.get(aMaterial) }); + } + if (!aMaterial.contains(gregtech.api.enums.SubTag.NO_WORKING)) { + + if ((aMaterial.contains(SubTag.CRYSTAL) ? GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) + : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L)) != null + && GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial.mMacerateInto, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + aMaterial.contains(SubTag.CRYSTAL) ? GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) + : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial.mMacerateInto, 2L)) + .duration(((int) Math.max(aMaterial.getMass() * 5L, 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(latheRecipes); + } + + if (GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L) != null) { + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 4L)) + .fluidInputs( + Materials.Water.getFluid( + Math.max( + 4, + Math.min( + 1000, + 2 * ((int) Math.max(aMaterial.getMass() * 2L, 1L)) + * calculateRecipeEU(aMaterial, 4) + / 320)))) + .duration(2 * ((int) Math.max(aMaterial.getMass() * 2L, 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 4)) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 4L)) + .fluidInputs( + GT_ModHandler.getDistilledWater( + Math.max( + 3, + Math.min( + 750, + 2 * ((int) Math.max(aMaterial.getMass() * 2L, 1L)) + * calculateRecipeEU(aMaterial, 4) + / 426)))) + .duration(2 * ((int) Math.max(aMaterial.getMass() * 2L, 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 4)) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 4L)) + .fluidInputs( + Materials.Lubricant.getFluid( + Math.max( + 1, + Math.min( + 250, + ((int) Math.max(aMaterial.getMass() * 2L, 1L)) * calculateRecipeEU(aMaterial, 4) + / 1280)))) + .duration(((int) Math.max(aMaterial.getMass() * 2L, 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 4)) + .addTo(cutterRecipes); + } + + if ((aMaterial.mUnificatable) && (aMaterial.mMaterialInto == aMaterial)) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 2L), + GT_Proxy.tBits, + new Object[] { "s", "X", 'X', OrePrefixes.stickLong.get(aMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "f ", " X", 'X', OrePrefixes.ingot.get(aMaterial) }); + } + } + } + if (!aMaterial.contains(gregtech.api.enums.SubTag.NO_SMASHING)) { + // bender recipe + { + if (GT_OreDictUnificator.get(OrePrefixes.springSmall, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.springSmall, aMaterial, 2L)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(benderRecipes); + } + } + + if (GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L)) + .duration(Math.max(aMaterial.getMass(), 1L)) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(hammerRecipes); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStickLong.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStickLong.java new file mode 100644 index 0000000000..1f00300264 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStickLong.java @@ -0,0 +1,120 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.recipe.RecipeMaps.cutterRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingStickLong implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingStickLong() { + OrePrefixes.stickLong.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.spring, aMaterial, 1L), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { " s ", "fSx", " S ", 'S', OrePrefixes.stickLong.get(aMaterial) }); + } + if (!aMaterial.contains(SubTag.NO_WORKING)) { + + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 2L)) + .fluidInputs( + Materials.Water.getFluid( + Math.max( + 4, + Math.min( + 1000, + ((int) Math.max(aMaterial.getMass(), 1L)) * calculateRecipeEU(aMaterial, 4) + / 320)))) + .duration(2 * ((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 4)) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 2L)) + .fluidInputs( + GT_ModHandler.getDistilledWater( + Math.max( + 3, + Math.min( + 750, + ((int) Math.max(aMaterial.getMass(), 1L)) * calculateRecipeEU(aMaterial, 4) + / 426)))) + .duration(2 * ((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 4)) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 2L)) + .fluidInputs( + Materials.Lubricant.getFluid( + Math.max( + 1, + Math.min( + 250, + ((int) Math.max(aMaterial.getMass(), 1L)) * calculateRecipeEU(aMaterial, 4) + / 1280)))) + .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 4)) + .addTo(cutterRecipes); + } + + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "sf", "G ", 'G', OrePrefixes.gemFlawless.get(aMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 2L), + GT_Proxy.tBits, + new Object[] { "sf", "G ", 'G', OrePrefixes.gemExquisite.get(aMaterial) }); + } + } + } + if (!aMaterial.contains(SubTag.NO_SMASHING)) { + // Bender recipes + { + if (GT_OreDictUnificator.get(OrePrefixes.spring, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.spring, aMaterial, 1L)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(benderRecipes); + } + } + + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "ShS", 'S', OrePrefixes.stick.get(aMaterial) }); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java new file mode 100644 index 0000000000..840f49b4dd --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java @@ -0,0 +1,348 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.cutterRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.interfaces.IOreRecipeRegistrator; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingStone implements IOreRecipeRegistrator { + + public ProcessingStone() { + OrePrefixes.stone.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + Block aBlock = GT_Utility.getBlockFromStack(aStack); + switch (aMaterial.mName) { + case "NULL": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(3, aStack), new ItemStack(Blocks.redstone_torch, 2)) + .itemOutputs(new ItemStack(Items.repeater, 1)) + .fluidInputs(Materials.Redstone.getMolten(144L)) + .duration(5 * SECONDS) + .eut(48) + .addTo(assemblerRecipes); + break; + case "Sand": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(new ItemStack(Blocks.sand, 1, 0)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Endstone": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Endstone, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Tungstate, 1L)) + .outputChances(10000, 500) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Netherrack": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Netherrack, 1L), + GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Gold, 1L)) + .outputChances(10000, 500) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "NetherBrick": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(new ItemStack(Blocks.nether_brick_fence, 1)) + .duration(5 * SECONDS) + .eut(4) + .addTo(assemblerRecipes); + break; + case "Obsidian": + if (aBlock != Blocks.air) aBlock.setResistance(20.0F); + break; + case "Concrete": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(Materials.Water.getFluid(Math.max(4, Math.min(1000, 200 * 30 / 320)))) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(GT_ModHandler.getDistilledWater(Math.max(3, Math.min(750, 200 * 30 / 426)))) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(Materials.Lubricant.getFluid(Math.max(1, Math.min(250, 100 * 30 / 1280)))) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Rhyolite": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.PotassiumFeldspar, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Quartz, 1L)) + .outputChances(10000, 2000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Komatiite": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Biotite, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Uranium, 1L)) + .outputChances(10000, 500) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Dacite": + case "Andesite": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconDioxide, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Obsidian, 1L)) + .outputChances(10000, 2000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Gabbro": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.PotassiumFeldspar, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Pyrite, 1L)) + .outputChances(10000, 2000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Eclogite": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconDioxide, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Rutile, 1L)) + .outputChances(10000, 1000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Soapstone": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Talc, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Chromite, 1L)) + .outputChances(10000, 1000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Greenschist": + case "Blueschist": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Glauconite, 2L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Basalt, 1L)) + .outputChances(10000, 1000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Gneiss": + case "Migmatite": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconDioxide, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.GraniteBlack, 1L)) + .outputChances(10000, 5000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Redrock": + case "Marble": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(Materials.Water.getFluid(Math.max(4, Math.min(1000, 400 * 30 / 320)))) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(GT_ModHandler.getDistilledWater(Math.max(3, Math.min(750, 400 * 30 / 426)))) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(Materials.Lubricant.getFluid(Math.max(1, Math.min(250, 200 * 30 / 1280)))) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + case "Basalt": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(Materials.Water.getFluid(Math.max(4, Math.min(1000, 400 * 30 / 320)))) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(GT_ModHandler.getDistilledWater(Math.max(3, Math.min(750, 400 * 30 / 426)))) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(Materials.Lubricant.getFluid(Math.max(1, Math.min(250, 200 * 30 / 1280)))) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + case "Quartzite": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L)) + .outputChances(10000, 1000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "Flint": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 2L), + new ItemStack(Items.flint, 1)) + .outputChances(10000, 5000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "GraniteBlack": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(Materials.Water.getFluid(Math.max(4, Math.min(1000, 400 * 30 / 320)))) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(GT_ModHandler.getDistilledWater(Math.max(3, Math.min(750, 400 * 30 / 426)))) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(Materials.Lubricant.getFluid(Math.max(1, Math.min(250, 200 * 30 / 1280)))) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Thorium, 1L)) + .outputChances(10000, 100) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + break; + case "GraniteRed": + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(Materials.Water.getFluid(Math.max(4, Math.min(1000, 400 * 30 / 320)))) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(GT_ModHandler.getDistilledWater(Math.max(3, Math.min(750, 400 * 30 / 426)))) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)) + .fluidInputs(Materials.Lubricant.getFluid(Math.max(1, Math.min(250, 200 * 30 / 1280)))) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(cutterRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Uranium, 1L)) + .outputChances(10000, 100) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStoneCobble.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStoneCobble.java new file mode 100644 index 0000000000..fb9431e8e4 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStoneCobble.java @@ -0,0 +1,30 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_Utility; + +public class ProcessingStoneCobble implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingStoneCobble() { + OrePrefixes.stoneCobble.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(8, aStack), GT_Utility.getIntegratedCircuit(8)) + .itemOutputs(new ItemStack(Blocks.furnace, 1)) + .duration(20 * SECONDS) + .eut(4) + .addTo(assemblerRecipes); + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingStoneVarious.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStoneVarious.java new file mode 100644 index 0000000000..d6762a25ab --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingStoneVarious.java @@ -0,0 +1,25 @@ +package gregtech.loaders.oreprocessing; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.OrePrefixes; + +public class ProcessingStoneVarious implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingStoneVarious() { + OrePrefixes.stone.add(this); + OrePrefixes.stoneCobble.add(this); + OrePrefixes.stoneBricks.add(this); + OrePrefixes.stoneChiseled.add(this); + OrePrefixes.stoneCracked.add(this); + OrePrefixes.stoneMossy.add(this); + OrePrefixes.stoneMossyBricks.add(this); + OrePrefixes.stoneSmooth.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, gregtech.api.enums.Materials aMaterial, String aOreDictName, + String aModName, ItemStack aStack) { + // no recipes currently. + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingToolHead.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingToolHead.java new file mode 100644 index 0000000000..4b610fea8e --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingToolHead.java @@ -0,0 +1,1273 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.extruderRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.recipe.RecipeMaps.formingPressRecipes; +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_Utility.calculateRecipeEU; + +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.enums.TierEU; +import gregtech.api.enums.ToolDictNames; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; +import gregtech.common.items.GT_MetaGenerated_Tool_01; + +public class ProcessingToolHead implements gregtech.api.interfaces.IOreRecipeRegistrator { // TODO COMPARE WITH OLD TOOL + // HEAD??? generator + + public ProcessingToolHead() { + OrePrefixes.toolHeadArrow.add(this); + OrePrefixes.toolHeadAxe.add(this); + OrePrefixes.toolHeadBuzzSaw.add(this); + OrePrefixes.toolHeadChainsaw.add(this); + OrePrefixes.toolHeadDrill.add(this); + OrePrefixes.toolHeadFile.add(this); + OrePrefixes.toolHeadHoe.add(this); + OrePrefixes.toolHeadPickaxe.add(this); + OrePrefixes.toolHeadPlow.add(this); + OrePrefixes.toolHeadSaw.add(this); + OrePrefixes.toolHeadSense.add(this); + OrePrefixes.toolHeadShovel.add(this); + OrePrefixes.toolHeadSword.add(this); + OrePrefixes.toolHeadUniversalSpade.add(this); + OrePrefixes.toolHeadWrench.add(this); + OrePrefixes.toolHeadHammer.add(this); + OrePrefixes.turbineBlade.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + boolean aSpecialRecipeReq1 = aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_SMASHING); + boolean aSpecialRecipeReq2 = aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_WORKING); + boolean aNoWorking = aMaterial.contains(SubTag.NO_WORKING); + boolean aProducesSoftMallet = aMaterial.contains(SubTag.BOUNCY) || aMaterial.contains(SubTag.WOOD) + || aMaterial.contains(SubTag.SOFT); + switch (aPrefix) { + case toolHeadArrow -> { + if (aMaterial.mStandardMoltenFluid != null) + if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Arrow.get(0L)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .fluidInputs(aMaterial.getMolten(36L)) + .duration(16 * TICKS) + .eut(8) + .addTo(fluidSolidifierRecipes); + } + if (aSpecialRecipeReq2) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadArrow, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "Xf", 'X', OrePrefixes.gemChipped.get(aMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadArrow, aMaterial, 3L), + GT_Proxy.tBits, + new Object[] { (aMaterial.contains(SubTag.WOOD) ? 115 : 'x') + "Pf", 'P', + OrePrefixes.plate.get(aMaterial) }); + } + } + case toolHeadAxe -> { + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.AXE, 1, aMaterial, aMaterial.mHandleMaterial, null), + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadAxe, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.AXE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + } + if (aSpecialRecipeReq1) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadAxe, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "PIh", "P ", "f ", 'P', OrePrefixes.plate.get(aMaterial), 'I', + OrePrefixes.ingot.get(aMaterial) }); + if (!aNoWorking) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadAxe, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "GG ", "G ", "f ", 'G', OrePrefixes.gem.get(aMaterial) }); + } + case toolHeadBuzzSaw -> { + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.BUZZSAW_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 100000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PBM", "dXG", "SGP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.BUZZSAW_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 75000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PBM", "dXG", "SGP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.BUZZSAW_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 50000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PBM", "dXG", "SGP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.BUZZSAW_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 400000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PBM", "dXG", "SGP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.BUZZSAW_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 300000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PBM", "dXG", "SGP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.BUZZSAW_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 200000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PBM", "dXG", "SGP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.BUZZSAW_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1600000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PBM", "dXG", "SGP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.BUZZSAW_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1200000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PBM", "dXG", "SGP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.BUZZSAW_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 800000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PBM", "dXG", "SGP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Sodium.get(1L) }); + if (aSpecialRecipeReq2) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadBuzzSaw, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "wXh", "X X", "fXx", 'X', OrePrefixes.plate.get(aMaterial) }); + } + case toolHeadChainsaw -> { + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.CHAINSAW_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 100000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.CHAINSAW_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 75000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.CHAINSAW_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 50000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.CHAINSAW_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 400000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.CHAINSAW_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 300000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.CHAINSAW_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 200000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.CHAINSAW_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1600000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.CHAINSAW_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1200000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.CHAINSAW_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 800000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Sodium.get(1L) }); + if (aSpecialRecipeReq2) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadChainsaw, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "SRS", "XhX", "SRS", 'X', OrePrefixes.plate.get(aMaterial), 'S', + OrePrefixes.plate.get(Materials.Steel), 'R', OrePrefixes.ring.get(Materials.Steel) }); + } + case toolHeadDrill -> { + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.DRILL_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 100_000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.DRILL_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 75_000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.DRILL_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 50_000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.DRILL_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 400_000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.DRILL_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 300_000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.DRILL_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 200_000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.DRILL_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1_600_000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.DRILL_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1_200_000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.DRILL_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 800_000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.JACKHAMMER, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1_600_000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "PRP", "MPB", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Piston_HV.get(1L), 'S', OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'R', + OrePrefixes.spring.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.JACKHAMMER, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1_200_000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "PRP", "MPB", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Piston_HV.get(1L), 'S', OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'R', + OrePrefixes.spring.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.JACKHAMMER, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 800_000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "PRP", "MPB", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Piston_HV.get(1L), 'S', OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'R', + OrePrefixes.spring.get(Materials.StainlessSteel), 'B', ItemList.Battery_RE_HV_Sodium.get(1L) }); + if (aSpecialRecipeReq2) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadDrill, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "XSX", "XSX", "ShS", 'X', OrePrefixes.plate.get(aMaterial), 'S', + OrePrefixes.plate.get(Materials.Steel) }); + if (aMaterial.mStandardMoltenFluid != null) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_ToolHeadDrill.get(0)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.toolHeadDrill, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(144 * 4)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(fluidSolidifierRecipes); + } + if (GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 4L), + ItemList.Shape_Extruder_ToolHeadDrill.get(0)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.toolHeadDrill, aMaterial, 1L)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(extruderRecipes); + } + } + } + case toolHeadFile -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.FILE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + + if ((!aMaterial.contains(SubTag.NO_SMASHING)) && (!aMaterial.contains(SubTag.BOUNCY))) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.FILE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + GT_ModHandler.RecipeBits.MIRRORED | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "P", "P", "S", 'P', OrePrefixes.plate.get(aMaterial), 'S', + OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + } + } + } + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadFile, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(15)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.FILE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(assemblerRecipes); + } + } + case toolHeadHoe -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.HOE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + } + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadHoe, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(16)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.HOE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(assemblerRecipes); + } + if (aSpecialRecipeReq1) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadHoe, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "PIh", "f ", 'P', OrePrefixes.plate.get(aMaterial), 'I', + OrePrefixes.ingot.get(aMaterial) }); + if (!aNoWorking) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadHoe, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "GG ", "f ", " ", 'G', OrePrefixes.gem.get(aMaterial) }); + } + case toolHeadPickaxe -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.PICKAXE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + + if (aSpecialRecipeReq1) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadPickaxe, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "PII", "f h", 'P', OrePrefixes.plate.get(aMaterial), 'I', + OrePrefixes.ingot.get(aMaterial) }); + + if (!aNoWorking) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadPickaxe, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "GGG", "f ", 'G', OrePrefixes.gem.get(aMaterial) }); + } + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadPickaxe, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(5)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.PICKAXE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(assemblerRecipes); + } + } + case toolHeadPlow -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.PLOW, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + + if (aSpecialRecipeReq1) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadPlow, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "PP", "PP", "hf", 'P', OrePrefixes.plate.get(aMaterial) }); + + if (!aNoWorking) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadPlow, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "GG", "GG", " f", 'G', OrePrefixes.gem.get(aMaterial) }); + } + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadPlow, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(6)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.PLOW, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(assemblerRecipes); + } + } + case toolHeadSaw -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SAW, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + + if (aSpecialRecipeReq1) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadSaw, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "PP ", "fh ", 'P', OrePrefixes.plate.get(aMaterial), 'I', + OrePrefixes.ingot.get(aMaterial) }); + + if (!aNoWorking) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadSaw, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "GGf", 'G', OrePrefixes.gem.get(aMaterial) }); + } + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadSaw, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(7)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SAW, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(assemblerRecipes); + } + } + case toolHeadSense -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SENSE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + + if (aSpecialRecipeReq1) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadSense, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "PPI", "hf ", 'P', OrePrefixes.plate.get(aMaterial), 'I', + OrePrefixes.ingot.get(aMaterial) }); + + if (!aNoWorking) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadSense, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "GGG", " f ", " ", 'G', OrePrefixes.gem.get(aMaterial) }); + } + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadSense, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(8)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SENSE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(assemblerRecipes); + } + } + case toolHeadShovel -> { + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SHOVEL, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadShovel, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(9)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SHOVEL, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(assemblerRecipes); + } + if (aSpecialRecipeReq1) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadShovel, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "fPh", 'P', OrePrefixes.plate.get(aMaterial), 'I', + OrePrefixes.ingot.get(aMaterial) }); + if (!aNoWorking) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadShovel, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "fG", 'G', OrePrefixes.gem.get(aMaterial) }); + } + case toolHeadSword -> { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SWORD, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + + if (aSpecialRecipeReq1) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadSword, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { " P ", "fPh", 'P', OrePrefixes.plate.get(aMaterial), 'I', + OrePrefixes.ingot.get(aMaterial) }); + + if (!aNoWorking) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadSword, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { " G", "fG", 'G', OrePrefixes.gem.get(aMaterial) }); + } + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadSword, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(10)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SWORD, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(assemblerRecipes); + } + } + case toolHeadUniversalSpade -> { + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.UNIVERSALSPADE, 1, aMaterial, aMaterial, null), + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial), OrePrefixes.screw.get(aMaterial), + ToolDictNames.craftingToolScrewdriver }); + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null + && GT_OreDictUnificator.get(OrePrefixes.screw, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.screw, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadUniversalSpade, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(11)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.UNIVERSALSPADE, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(assemblerRecipes); + } + if (aSpecialRecipeReq2) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadUniversalSpade, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "fX", 'X', OrePrefixes.toolHeadShovel.get(aMaterial) }); + } + case toolHeadWrench -> { + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.WRENCH_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 100000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.WRENCH_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 75000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.WRENCH_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 50000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_LV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Steel), 'P', OrePrefixes.plate.get(Materials.Steel), 'G', + OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', ItemList.Battery_RE_LV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.WRENCH_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 400000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.WRENCH_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 300000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.WRENCH_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 200000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_MV.get(1L), 'S', + OrePrefixes.screw.get(Materials.Aluminium), 'P', OrePrefixes.plate.get(Materials.Aluminium), + 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.WRENCH_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1600000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.WRENCH_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1200000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.WRENCH_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 800000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SCREWDRIVER_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 100000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PdX", "MGS", "GBP", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Motor_LV.get(1L), 'S', OrePrefixes.screw.get(Materials.Steel), 'P', + OrePrefixes.plate.get(Materials.Steel), 'G', OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', + ItemList.Battery_RE_LV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SCREWDRIVER_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 75000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PdX", "MGS", "GBP", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Motor_LV.get(1L), 'S', OrePrefixes.screw.get(Materials.Steel), 'P', + OrePrefixes.plate.get(Materials.Steel), 'G', OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', + ItemList.Battery_RE_LV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SCREWDRIVER_LV, + 1, + aMaterial, + Materials.Steel, + new long[] { 50000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PdX", "MGS", "GBP", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Motor_LV.get(1L), 'S', OrePrefixes.screw.get(Materials.Steel), 'P', + OrePrefixes.plate.get(Materials.Steel), 'G', OrePrefixes.gearGtSmall.get(Materials.Steel), 'B', + ItemList.Battery_RE_LV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SCREWDRIVER_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 400000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PdX", "MGS", "GBP", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Motor_MV.get(1L), 'S', OrePrefixes.screw.get(Materials.Aluminium), 'P', + OrePrefixes.plate.get(Materials.Aluminium), 'G', + OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SCREWDRIVER_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 300000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PdX", "MGS", "GBP", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Motor_MV.get(1L), 'S', OrePrefixes.screw.get(Materials.Aluminium), 'P', + OrePrefixes.plate.get(Materials.Aluminium), 'G', + OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', + ItemList.Battery_RE_MV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SCREWDRIVER_MV, + 1, + aMaterial, + Materials.Aluminium, + new long[] { 200000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PdX", "MGS", "GBP", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Motor_MV.get(1L), 'S', OrePrefixes.screw.get(Materials.Aluminium), 'P', + OrePrefixes.plate.get(Materials.Aluminium), 'G', + OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'B', ItemList.Battery_RE_MV_Sodium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SCREWDRIVER_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1600000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PdX", "MGS", "GBP", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Motor_HV.get(1L), 'S', OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SCREWDRIVER_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 1200000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PdX", "MGS", "GBP", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Motor_HV.get(1L), 'S', OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Cadmium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SCREWDRIVER_HV, + 1, + aMaterial, + Materials.StainlessSteel, + new long[] { 800000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PdX", "MGS", "GBP", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', + ItemList.Electric_Motor_HV.get(1L), 'S', OrePrefixes.screw.get(Materials.StainlessSteel), 'P', + OrePrefixes.plate.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'B', + ItemList.Battery_RE_HV_Sodium.get(1L) }); + if (aSpecialRecipeReq2) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadWrench, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "hXW", "XRX", "WXd", 'X', OrePrefixes.plate.get(aMaterial), 'S', + OrePrefixes.plate.get(Materials.Steel), 'R', OrePrefixes.ring.get(Materials.Steel), 'W', + OrePrefixes.screw.get(Materials.Steel) }); + } + case toolHeadHammer, toolHeadMallet -> { + if (GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mHandleMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.toolHeadHammer, aMaterial, 1L), + GT_Utility.getIntegratedCircuit(14)) + .itemOutputs( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + aProducesSoftMallet ? GT_MetaGenerated_Tool_01.SOFTMALLET + : GT_MetaGenerated_Tool_01.HARDHAMMER, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, (int) TierEU.RECIPE_MV)) + .addTo(assemblerRecipes); + } + if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint)) { + GT_ModHandler.addShapelessCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + aProducesSoftMallet ? GT_MetaGenerated_Tool_01.SOFTMALLET + : GT_MetaGenerated_Tool_01.HARDHAMMER, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + aProducesSoftMallet ? GT_MetaGenerated_Tool_01.SOFTMALLET + : GT_MetaGenerated_Tool_01.HARDHAMMER, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "XX ", "XXS", "XX ", 'X', + aMaterial == Materials.Wood ? OrePrefixes.plank.get(Materials.Wood) + : OrePrefixes.ingot.get(aMaterial), + 'S', OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + aProducesSoftMallet ? GT_MetaGenerated_Tool_01.SOFTMALLET + : GT_MetaGenerated_Tool_01.HARDHAMMER, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "XX ", "XXS", "XX ", 'X', + aMaterial == Materials.Wood ? OrePrefixes.plank.get(Materials.Wood) + : OrePrefixes.gem.get(aMaterial), + 'S', OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + } + if (aPrefix == OrePrefixes.toolHeadHammer) if (aSpecialRecipeReq1) GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.toolHeadHammer, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "II ", "IIh", "II ", 'P', OrePrefixes.plate.get(aMaterial), 'I', + OrePrefixes.ingot.get(aMaterial) }); + } + case turbineBlade -> { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.turbineBlade, aMaterial, 4L), + GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Magnalium, 1L)) + .itemOutputs(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(170, 1, aMaterial, aMaterial, null)) + .duration(8 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 100)) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.turbineBlade, aMaterial, 8L), + GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Titanium, 1L)) + .itemOutputs(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(172, 1, aMaterial, aMaterial, null)) + .duration(16 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 400)) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.turbineBlade, aMaterial, 12L), + GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.TungstenSteel, 1L)) + .itemOutputs(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(174, 1, aMaterial, aMaterial, null)) + .duration(32 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 1600)) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.turbineBlade, aMaterial, 16L), + GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Americium, 1L)) + .itemOutputs(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(176, 1, aMaterial, aMaterial, null)) + .duration(1 * MINUTES + 4 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 6400)) + .addTo(assemblerRecipes); + if (aSpecialRecipeReq2) { + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.turbineBlade, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "fPd", "SPS", " P ", 'P', + aMaterial == Materials.Wood ? OrePrefixes.plank.get(aMaterial) + : OrePrefixes.plateDouble.get(aMaterial), + 'R', OrePrefixes.ring.get(aMaterial), 'S', OrePrefixes.screw.get(aMaterial) }); + } + + // Turbine blades + if (GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L) != null + && GT_OreDictUnificator.get(OrePrefixes.screw, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.screw, aMaterial, 2L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.turbineBlade, aMaterial, 1L)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 60)) + .addTo(formingPressRecipes); + } + } + } + default -> {} + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingToolOther.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingToolOther.java new file mode 100644 index 0000000000..a0e282dc1b --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingToolOther.java @@ -0,0 +1,137 @@ +package gregtech.loaders.oreprocessing; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.Dyes; +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.common.items.GT_MetaGenerated_Tool_01; + +public class ProcessingToolOther implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingToolOther() { + OrePrefixes.toolHeadHammer.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if ((aMaterial == Materials.Stone) || (aMaterial == Materials.Flint)) { + return; + } + + if (aMaterial != Materials.Rubber) { + // Crafting recipes + { + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.PLUNGER, 1, aMaterial, aMaterial, null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "xRR", " SR", "S f", 'S', OrePrefixes.stick.get(aMaterial), 'R', + OrePrefixes.plate.get(Materials.AnyRubber) }); + } + } + + if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY)) + && (!aMaterial.contains(SubTag.NO_SMASHING))) { + // Crafting recipes + { + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.WRENCH, 1, aMaterial, aMaterial, null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "IhI", "III", " I ", 'I', OrePrefixes.ingot.get(aMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.CROWBAR, 1, aMaterial, aMaterial, null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "hDS", "DSD", "SDf", 'S', OrePrefixes.stick.get(aMaterial), 'D', Dyes.dyeBlue }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SCREWDRIVER, + 1, + aMaterial, + aMaterial.mHandleMaterial, + null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { " fS", " Sh", "W ", 'S', OrePrefixes.stick.get(aMaterial), 'W', + OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.WIRECUTTER, 1, aMaterial, aMaterial, null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PfP", "hPd", "STS", 'S', OrePrefixes.stick.get(aMaterial), 'P', + OrePrefixes.plate.get(aMaterial), 'T', OrePrefixes.screw.get(aMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.SCOOP, 1, aMaterial, aMaterial, null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "SWS", "SSS", "xSh", 'S', OrePrefixes.stick.get(aMaterial), 'W', + new ItemStack(Blocks.wool, 1, 32767) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.BRANCHCUTTER, 1, aMaterial, aMaterial, null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PfP", "PdP", "STS", 'S', OrePrefixes.stick.get(aMaterial), 'P', + OrePrefixes.plate.get(aMaterial), 'T', OrePrefixes.screw.get(aMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.KNIFE, 1, aMaterial, aMaterial, null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "fPh", " S ", 'S', OrePrefixes.stick.get(aMaterial), 'P', + OrePrefixes.plate.get(aMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.BUTCHERYKNIFE, 1, aMaterial, aMaterial, null), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "PPf", "PP ", "Sh ", 'S', OrePrefixes.stick.get(aMaterial), 'P', + OrePrefixes.plate.get(aMaterial) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SOLDERING_IRON_LV, + 1, + aMaterial, + Materials.Rubber, + new long[] { 100000L, 32L, 1L, -1L }), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "LBf", "Sd ", "P ", 'B', OrePrefixes.bolt.get(aMaterial), 'P', + OrePrefixes.plate.get(Materials.AnyRubber), 'S', OrePrefixes.stick.get(Materials.Iron), 'L', + ItemList.Battery_RE_LV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SOLDERING_IRON_MV, + 1, + aMaterial, + Materials.Rubber, + new long[] { 400000L, 128L, 2L, -1L }), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "LBf", "Sd ", "P ", 'B', OrePrefixes.bolt.get(aMaterial), 'P', + OrePrefixes.plate.get(Materials.AnyRubber), 'S', OrePrefixes.stick.get(Materials.Steel), 'L', + ItemList.Battery_RE_MV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( + GT_MetaGenerated_Tool_01.SOLDERING_IRON_HV, + 1, + aMaterial, + Materials.AnySyntheticRubber, + new long[] { 1600000L, 512L, 3L, -1L }), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "LBf", "Sd ", "P ", 'B', OrePrefixes.bolt.get(aMaterial), 'P', + OrePrefixes.plate.get(Materials.AnySyntheticRubber), 'S', + OrePrefixes.stick.get(Materials.StainlessSteel), 'L', ItemList.Battery_RE_HV_Lithium.get(1L) }); + GT_ModHandler.addCraftingRecipe( + (GT_MetaGenerated_Tool_01.INSTANCE + .getToolWithStats(GT_MetaGenerated_Tool_01.POCKET_MULTITOOL, 1, aMaterial, aMaterial, null)), + GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { "ABC", "DEF", "CFG", 'A', OrePrefixes.stickLong.get(aMaterial), 'B', + OrePrefixes.toolHeadSaw.get(aMaterial), 'C', OrePrefixes.ring.get(aMaterial), 'D', + OrePrefixes.toolHeadFile.get(aMaterial), 'E', OrePrefixes.plate.get(aMaterial), 'F', + OrePrefixes.toolHeadSword.get(aMaterial), 'G', Dyes.dyeBlue }); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingTransforming.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingTransforming.java new file mode 100644 index 0000000000..4e3febc469 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingTransforming.java @@ -0,0 +1,176 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes; +import static gregtech.api.recipe.RecipeMaps.polarizerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.interfaces.IOreRecipeRegistrator; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class ProcessingTransforming implements IOreRecipeRegistrator { + + public ProcessingTransforming() { + for (OrePrefixes tPrefix : OrePrefixes.values()) + if (((tPrefix.mMaterialAmount > 0L) && (!tPrefix.mIsContainer) && (!tPrefix.mIsEnchantable)) + || (tPrefix == OrePrefixes.plank)) tPrefix.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + + if (aPrefix == OrePrefixes.plank) { + aPrefix = OrePrefixes.plate; + } + + switch (aMaterial.mName) { + case "Wood" -> + // Chemical bath recipes + { + if (GT_OreDictUnificator.get(aPrefix, Materials.WoodSealed, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, Materials.WoodSealed, 1L)) + .fluidInputs( + Materials.SeedOil + .getFluid(GT_Utility.translateMaterialToAmount(aPrefix.mMaterialAmount, 120L, true))) + .duration(5 * SECONDS) + .eut(TierEU.ULV) + .addTo(chemicalBathRecipes); + } + + } + case "Iron" -> { + // Chemical bath recipes + { + if (GT_OreDictUnificator.get(aPrefix, Materials.FierySteel, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, Materials.FierySteel, 1L)) + .fluidInputs( + Materials.FierySteel.getFluid( + GT_Utility.translateMaterialToAmount(aPrefix.mMaterialAmount, 250L, true))) + .duration(5 * SECONDS) + .eut(TierEU.ULV) + .addTo(chemicalBathRecipes); + } + } + + // Polarizer recipes + { + if (GT_OreDictUnificator.get(aPrefix, Materials.IronMagnetic, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, Materials.IronMagnetic, 1L)) + .duration(((int) Math.max(16L, aPrefix.mMaterialAmount * 128L / GT_Values.M)) * TICKS) + .eut((int) TierEU.LV / 2) + .addTo(polarizerRecipes); + } + } + } + case "WroughtIron" -> { + // Chemical bath recipes + { + if (GT_OreDictUnificator.get(aPrefix, Materials.FierySteel, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, Materials.FierySteel, 1L)) + .fluidInputs( + Materials.FierySteel.getFluid( + GT_Utility.translateMaterialToAmount(aPrefix.mMaterialAmount, 225L, true))) + .duration(5 * SECONDS) + .eut(TierEU.ULV) + .addTo(chemicalBathRecipes); + } + } + + // Polarizer recipes + { + if (GT_OreDictUnificator.get(aPrefix, Materials.IronMagnetic, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, Materials.IronMagnetic, 1L)) + .duration(((int) Math.max(16L, aPrefix.mMaterialAmount * 128L / GT_Values.M)) * TICKS) + .eut((int) TierEU.LV / 2) + .addTo(polarizerRecipes); + } + } + } + case "Steel" -> { + // Chemical Bath recipes + { + if (GT_OreDictUnificator.get(aPrefix, Materials.FierySteel, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, Materials.FierySteel, 1L)) + .fluidInputs( + Materials.FierySteel.getFluid( + GT_Utility.translateMaterialToAmount(aPrefix.mMaterialAmount, 200L, true))) + .duration(5 * SECONDS) + .eut(TierEU.ULV) + .addTo(chemicalBathRecipes); + } + } + + // Polarizer recipes + { + if (GT_OreDictUnificator.get(aPrefix, Materials.SteelMagnetic, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, Materials.SteelMagnetic, 1L)) + .duration(((int) Math.max(16L, aPrefix.mMaterialAmount * 128L / GT_Values.M)) * TICKS) + .eut((int) TierEU.LV / 2) + .addTo(polarizerRecipes); + } + } + } + case "Neodymium" -> + // Polarizer recipes + { + if (GT_OreDictUnificator.get(aPrefix, Materials.NeodymiumMagnetic, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, Materials.NeodymiumMagnetic, 1L)) + .duration(((int) Math.max(16L, aPrefix.mMaterialAmount * 128L / GT_Values.M)) * TICKS) + .eut((int) TierEU.HV / 2) + .addTo(polarizerRecipes); + } + } + case "Samarium" -> + // Polarizer recipes + { + if (GT_OreDictUnificator.get(aPrefix, Materials.SamariumMagnetic, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, Materials.SamariumMagnetic, 1L)) + .duration(((int) Math.max(16L, aPrefix.mMaterialAmount * 128L / GT_Values.M)) * TICKS) + .eut((int) TierEU.IV / 2) + .addTo(polarizerRecipes); + } + } + + case "TengamPurified" -> + // Polarizer recipes + { + if (GT_OreDictUnificator.get(aPrefix, Materials.TengamAttuned, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .itemOutputs(GT_OreDictUnificator.get(aPrefix, Materials.TengamAttuned, 1L)) + .duration(((int) Math.max(16L, aPrefix.mMaterialAmount * 128L / GT_Values.M)) * TICKS) + .eut((int) TierEU.RECIPE_UHV) + .addTo(polarizerRecipes); + } + } + + default -> { /* NO-OP */ } + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWax.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWax.java new file mode 100644 index 0000000000..7635546d23 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWax.java @@ -0,0 +1,31 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.util.GT_RecipeConstants.FUEL_TYPE; +import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_RecipeConstants; +import gregtech.api.util.GT_Utility; + +public class ProcessingWax implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingWax() { + OrePrefixes.wax.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (aOreDictName.equals("waxMagical")) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack)) + .metadata(FUEL_VALUE, 6) + .metadata(FUEL_TYPE, 5) + .addTo(GT_RecipeConstants.Fuel); + } + } +} diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire.java new file mode 100644 index 0000000000..1f5bd5f1c2 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingWire.java @@ -0,0 +1,506 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.recipe.RecipeMaps.alloySmelterRecipes; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.recipe.RecipeMaps.packagerRecipes; +import static gregtech.api.recipe.RecipeMaps.unpackagerRecipes; +import static gregtech.api.recipe.RecipeMaps.wiremillRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + +import java.util.ArrayList; + +import net.minecraft.item.ItemStack; + +import appeng.api.config.TunnelType; +import appeng.core.Api; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; + +public class ProcessingWire implements gregtech.api.interfaces.IOreRecipeRegistrator { + + private final Materials[] dielectrics = { Materials.PolyvinylChloride, Materials.Polydimethylsiloxane }; + private final Materials[] syntheticRubbers = { Materials.StyreneButadieneRubber, Materials.Silicone }; + + private static Object tt; + + public ProcessingWire() { + OrePrefixes.wireGt01.add(this); + OrePrefixes.wireGt02.add(this); + OrePrefixes.wireGt04.add(this); + OrePrefixes.wireGt08.add(this); + OrePrefixes.wireGt12.add(this); + OrePrefixes.wireGt16.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, + ItemStack aStack) { + if (tt == TunnelType.ME) { + try { + tt = TunnelType.valueOf("GT_POWER"); + } catch (IllegalArgumentException ignored) { + tt = TunnelType.IC2_POWER; + } + } + + int cableWidth; + OrePrefixes correspondingCable; + + switch (aPrefix) { + case wireGt01 -> { + cableWidth = 1; + correspondingCable = OrePrefixes.cableGt01; + if (!aMaterial.contains(SubTag.NO_SMASHING)) { + // Bender recipes + { + if (GT_OreDictUnificator.get(OrePrefixes.springSmall, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.springSmall, aMaterial, 2L)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(benderRecipes); + } + } + + // Wiremill Recipes + { + if (GT_OreDictUnificator.get(OrePrefixes.wireFine, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.wireFine, aMaterial, 4L)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(wiremillRecipes); + } + } + } + + // crafting recipe + if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_WORKING) + && (aMaterial.getProcessingMaterialTierEU() < TierEU.IV)) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] { "Xx", 'X', OrePrefixes.plate.get(aMaterial) }); + + } + + // Assembler recipes + { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(2, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.wireGt02, aMaterial, 1L)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.wireGt04, aMaterial, 1L)) + .duration(10 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(8, aStack), GT_Utility.getIntegratedCircuit(8)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.wireGt08, aMaterial, 1L)) + .duration(15 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(12, aStack), GT_Utility.getIntegratedCircuit(12)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.wireGt12, aMaterial, 1L)) + .duration(20 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(16, aStack), GT_Utility.getIntegratedCircuit(16)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.wireGt16, aMaterial, 1L)) + .duration(25 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + } + } + case wireGt02 -> { + cableWidth = 2; + correspondingCable = OrePrefixes.cableGt02; + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + // Shapeless crafting recipes + { + GT_ModHandler.addShapelessCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 2L), + new Object[] { aOreDictName }); + + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + new Object[] { OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial) }); + } + } + } + case wireGt04 -> { + cableWidth = 4; + correspondingCable = OrePrefixes.cableGt04; + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + // Shapeless crafting recipes + { + GT_ModHandler.addShapelessCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 4L), + new Object[] { aOreDictName }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + new Object[] { OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial), + OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial) }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + new Object[] { OrePrefixes.wireGt02.get(aMaterial), OrePrefixes.wireGt02.get(aMaterial) }); + } + } + } + case wireGt08 -> { + cableWidth = 8; + correspondingCable = OrePrefixes.cableGt08; + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + // Shapeless crafting recipes + { + GT_ModHandler.addShapelessCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 8L), + new Object[] { aOreDictName }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + new Object[] { OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial), + OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial), + OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial), + OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial) }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + new Object[] { OrePrefixes.wireGt04.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) }); + } + } + } + case wireGt12 -> { + cableWidth = 12; + correspondingCable = OrePrefixes.cableGt12; + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + // Shapeless crafting recipes + { + GT_ModHandler.addShapelessCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 12L), + new Object[] { aOreDictName }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + new Object[] { OrePrefixes.wireGt08.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) }); + } + } + } + case wireGt16 -> { + cableWidth = 16; + correspondingCable = OrePrefixes.cableGt16; + if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) { + // Shapeless crafting recipes + { + GT_ModHandler.addShapelessCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 16L), + new Object[] { aOreDictName }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + new Object[] { OrePrefixes.wireGt08.get(aMaterial), OrePrefixes.wireGt08.get(aMaterial) }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + new Object[] { OrePrefixes.wireGt12.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) }); + } + + AE2addNewAttunement(aStack); + } + } + default -> { + GT_Log.err.println( + "OrePrefix " + aPrefix.name() + " cannot be registered as a cable for Material " + aMaterial.mName); + return; + } + } + + int costMultiplier = cableWidth / 4 + 1; + + switch (aMaterial.mName) { + case "RedAlloy", "Cobalt", "Lead", "Tin", "Zinc", "SolderingAlloy" -> { + ArrayList<Object> craftingListRubber = new ArrayList<>(); + craftingListRubber.add(aOreDictName); + for (int i = 0; i < costMultiplier; i++) { + craftingListRubber.add(OrePrefixes.plate.get(Materials.Rubber)); + } + + // shapeless crafting + if (GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L) != null) { + GT_ModHandler.addShapelessCraftingRecipe( + GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L), + craftingListRubber.toArray()); + } + + // Packer recipe + if (GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(1, aStack), + GT_OreDictUnificator.get(OrePrefixes.plate.get(Materials.Rubber), costMultiplier)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .duration(5 * SECONDS) + .eut(8) + .addTo(packagerRecipes); + } + // alloy smelter recipes + { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Rubber, 2L), + GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.cableGt01, aMaterial, 1L)) + .duration(5 * SECONDS) + .eut(8) + .addTo(alloySmelterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Rubber, 2L), + GT_OreDictUnificator.get(OrePrefixes.wireGt02, aMaterial, 1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.cableGt02, aMaterial, 1L)) + .duration(10 * SECONDS) + .eut(16) + .addTo(alloySmelterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Rubber, 4L), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, aMaterial, 1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.cableGt04, aMaterial, 1L)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(alloySmelterRecipes); + } + // Assembler recipes + { + if (GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(aStack, GT_Utility.getIntegratedCircuit(24)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(Materials.Rubber.getMolten(144L * costMultiplier)) + .duration(5 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(aStack, GT_Utility.getIntegratedCircuit(24)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(Materials.StyreneButadieneRubber.getMolten(108L * costMultiplier)) + .duration(5 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(aStack, GT_Utility.getIntegratedCircuit(24)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(Materials.Silicone.getMolten(72L * costMultiplier)) + .duration(5 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + for (Materials dielectric : dielectrics) { + for (Materials syntheticRubber : syntheticRubbers) { + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), dielectric.getDust(costMultiplier)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 4L)) + .fluidInputs(syntheticRubber.getMolten(costMultiplier * 144L)) + .duration(20 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(aStack, dielectric.getDustSmall(costMultiplier)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(syntheticRubber.getMolten(costMultiplier * 36L)) + .duration(5 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + } + } + } + } + } + case "Iron", "Nickel", "Cupronickel", "Copper", "AnnealedCopper", "Kanthal", "Gold", "Electrum", "Silver", "Nichrome", "Steel", "BlackSteel", "Titanium", "Aluminium", "BlueAlloy", "NetherStar", "RedstoneAlloy" -> { + + if (GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L) == null) { + break; + } + // Assembler recipes + GT_Values.RA.stdBuilder() + .itemInputs(aStack, GT_Utility.getIntegratedCircuit(24)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(Materials.Rubber.getMolten(144 * costMultiplier)) + .duration(5 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(aStack, GT_Utility.getIntegratedCircuit(24)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(Materials.StyreneButadieneRubber.getMolten(108 * costMultiplier)) + .duration(5 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(aStack, GT_Utility.getIntegratedCircuit(24)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(Materials.Silicone.getMolten(72 * costMultiplier)) + .duration(5 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + for (Materials dielectric : dielectrics) { + for (Materials syntheticRubber : syntheticRubbers) { + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4, aStack), dielectric.getDust(costMultiplier)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 4L)) + .fluidInputs(syntheticRubber.getMolten(costMultiplier * 144L)) + .duration(20 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(aStack, dielectric.getDustSmall(costMultiplier)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(syntheticRubber.getMolten(costMultiplier * 36L)) + .duration(5 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + } + } + } + + default -> { + if (GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L) == null) { + break; + } + + // Assembler recipes + GT_Values.RA.stdBuilder() + .itemInputs( + aStack, + GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, costMultiplier), + GT_Utility.getIntegratedCircuit(24)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(Materials.Silicone.getMolten(costMultiplier * 72)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + aStack, + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.PolyphenyleneSulfide, costMultiplier), + GT_Utility.getIntegratedCircuit(24)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(Materials.Silicone.getMolten(costMultiplier * 72)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + + for (Materials dielectric : dielectrics) { + for (Materials syntheticRubber : syntheticRubbers) { + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(4, aStack), + dielectric.getDust(costMultiplier), + GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, costMultiplier * 4L)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 4L)) + .fluidInputs(syntheticRubber.getMolten(costMultiplier * 144L)) + .duration(20 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(4, aStack), + dielectric.getDust(costMultiplier), + GT_OreDictUnificator + .get(OrePrefixes.foil, Materials.PolyphenyleneSulfide, costMultiplier * 4L)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 4L)) + .fluidInputs(syntheticRubber.getMolten(costMultiplier * 144L)) + .duration(20 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + aStack, + dielectric.getDustSmall(costMultiplier), + GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, costMultiplier)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(syntheticRubber.getMolten(costMultiplier * 36L)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + aStack, + dielectric.getDustSmall(costMultiplier), + GT_OreDictUnificator + .get(OrePrefixes.foil, Materials.PolyphenyleneSulfide, costMultiplier)) + .itemOutputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .fluidInputs(syntheticRubber.getMolten(costMultiplier * 36L)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(assemblerRecipes); + } + } + } + } + + if (GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L)) + .itemOutputs(GT_Utility.copyAmount(1, aStack)) + .duration(5 * SECONDS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(unpackagerRecipes); + } + + if (GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L) != null) { + AE2AddNetAttunementCable(aStack, correspondingCable, aMaterial); + } + } + + // region AE2 compat + static { + setAE2Field(); + } + + private static void setAE2Field() { + tt = TunnelType.ME; + } + + private void AE2addNewAttunement(ItemStack aStack) { + Api.INSTANCE.registries() + .p2pTunnel() + .addNewAttunement(aStack, (TunnelType) tt); + } + + private void AE2AddNetAttunementCable(ItemStack aStack, OrePrefixes correspondingCable, Materials aMaterial) { + Api.INSTANCE.registries() + .p2pTunnel() + .addNewAttunement(aStack, (TunnelType) tt); + Api.INSTANCE.registries() + .p2pTunnel() + .addNewAttunement(GT_OreDictUnificator.get(correspondingCable, aMaterial, 1L), (TunnelType) tt); + } + // end region +} |