From 686a78b8df700bc69849b36da30cdbcf72513e60 Mon Sep 17 00:00:00 2001 From: chochem <40274384+chochem@users.noreply.github.com> Date: Tue, 16 May 2023 18:19:57 +0100 Subject: more Ra2 recipe conversions and some small fixes/improvements in GT recipe generation (#1994) * oredict plate recipes * oredict dust recipes * ore processing recycling recipes * shaping recipes * more fixes * fixes * 2 fixes * remove unnecessary qualifications --- .../loaders/oreprocessing/ProcessingCell.java | 80 +- .../loaders/oreprocessing/ProcessingDust.java | 469 +++++++--- .../loaders/oreprocessing/ProcessingOre.java | 13 +- .../loaders/oreprocessing/ProcessingPlate.java | 324 ++++--- .../loaders/oreprocessing/ProcessingRecycling.java | 24 +- .../loaders/oreprocessing/ProcessingShaping.java | 994 +++++++++++++-------- 6 files changed, 1223 insertions(+), 681 deletions(-) (limited to 'src') diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java index 8c66a2262c..1f33a3c7bc 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java @@ -18,6 +18,7 @@ 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_Utility; public class ProcessingCell implements IOreRecipeRegistrator { @@ -103,20 +104,21 @@ public class ProcessingCell implements IOreRecipeRegistrator { // Electrolyzer recipe { if (GT_Utility.getFluidForFilledItem(aStack, true) == null) { - int capsuleCount = tCapsuleCount <= 0L ? 0 : (int) tCapsuleCount; - ItemStack cells = capsuleCount <= 0 ? null - : ItemList.Cell_Empty.get(capsuleCount); // dust stuffed cell e.g. Phosphate, Phosphorous Pentoxide - GT_Values.RA.stdBuilder() - .itemInputs(GT_Utility.copyAmount(tItemAmount, aStack), cells) - .itemOutputs( - tList.get(0), - tList.size() >= 2 ? tList.get(1) : null, - tList.size() >= 3 ? tList.get(2) : null, - tList.size() >= 4 ? tList.get(3) : null, - tList.size() >= 5 ? tList.get(4) : null, - tCapsuleCount >= 0L ? tList.size() >= 6 ? tList.get(5) : null - : ItemList.Cell_Empty.get(-tCapsuleCount)) + 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) .noFluidInputs() .noFluidOutputs() .duration(Math.max(1L, Math.abs(aMaterial.getProtons() * 2L * tItemAmount))) @@ -124,20 +126,18 @@ public class ProcessingCell implements IOreRecipeRegistrator { .addTo(sElectrolyzerRecipes); } else { long tCellBalance = tCapsuleCount + tItemAmount - 1; - int capsuleCount = tCellBalance <= 0L ? 0 : (int) tCellBalance; - ItemStack cells = capsuleCount <= 0 ? null - : ItemList.Cell_Empty.get(capsuleCount); - - GT_Values.RA.stdBuilder() - .itemInputs(aStack, cells) - .itemOutputs( - tList.get(0), - tList.size() >= 2 ? tList.get(1) : null, - tList.size() >= 3 ? tList.get(2) : null, - tList.size() >= 4 ? tList.get(3) : null, - tList.size() >= 5 ? tList.get(4) : null, - tCapsuleCount >= 0L ? tList.size() >= 6 ? tList.get(5) : null - : tCellBalance < 0 ? ItemList.Cell_Empty.get(-tCellBalance) : null) + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + if (tCellBalance > 0L) { + recipeBuilder.itemInputs(aStack, ItemList.Cell_Empty.get(tCellBalance)); + } else { + recipeBuilder.itemInputs(GT_Utility.copyAmount(tItemAmount, 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) .noFluidInputs() .noFluidOutputs() .duration(Math.max(1L, Math.abs(aMaterial.getProtons() * 8L * tItemAmount))) @@ -147,19 +147,19 @@ public class ProcessingCell implements IOreRecipeRegistrator { } } if ((aMaterial.mExtraData & 0x2) != 0) { - ItemStack emptyCells = tCapsuleCount > 0 ? ItemList.Cell_Empty.get(tCapsuleCount) - : null; - - GT_Values.RA.stdBuilder() - .itemInputs(GT_Utility.copyAmount(tItemAmount, aStack), emptyCells) - .itemOutputs( - tList.get(0), - tList.size() >= 2 ? tList.get(1) : null, - tList.size() >= 3 ? tList.get(2) : null, - tList.size() >= 4 ? tList.get(3) : null, - tList.size() >= 5 ? tList.get(4) : null, - tCapsuleCount >= 0L ? tList.size() >= 6 ? tList.get(5) : null - : ItemList.Cell_Empty.get(-tCapsuleCount)) + 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) .noFluidInputs() .noFluidOutputs() .duration(Math.max(1L, Math.abs(aMaterial.getMass() * 2L * tItemAmount))) diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java index 804bded008..7ca1f0cb15 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java @@ -1,19 +1,35 @@ package gregtech.loaders.oreprocessing; +import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sAutoclaveRecipes; +import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCannerRecipes; import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes; import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCompressorRecipes; +import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sElectroMagneticSeparatorRecipes; import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sElectrolyzerRecipes; +import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sImplosionRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +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.*; +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; @@ -33,17 +49,29 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr ItemStack aStack) { switch (aPrefix) { case dust -> { - if (aMaterial.mFuelPower > 0) GT_Values.RA - .addFuel(GT_Utility.copyAmount(1L, aStack), null, aMaterial.mFuelPower, aMaterial.mFuelType); - if (GT_Utility.getFluidForFilledItem(GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L), true) - == null) - GT_Values.RA.addCannerRecipe( - aStack, - ItemList.Cell_Empty.get(1L), - GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L), - null, - 100, - 1); + if (aMaterial.mFuelPower > 0) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack)) + .noItemOutputs() + .noFluidInputs() + .noFluidOutputs() + .metadata(FUEL_VALUE, aMaterial.mFuelPower) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .duration(0) + .eut(0) + .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)) + .noFluidInputs() + .noFluidOutputs() + .duration(5 * SECONDS) + .eut(1) + .addTo(sCannerRecipes); + } if (!aMaterial.mBlastFurnaceRequired) { GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) { @@ -141,9 +169,9 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr if (tDustStack != null) { tDustStack.stackSize = ((int) (tDustStack.stackSize * tDensityMultiplier)); while ((tDustStack.stackSize > 64) && (tList.size() < 6) - && (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCount(tDustStack) * 64 + && (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCount(tDustStack) * 64L <= 64L)) { - tCapsuleCount += GT_ModHandler.getCapsuleCellContainerCount(tDustStack) * 64; + tCapsuleCount += GT_ModHandler.getCapsuleCellContainerCount(tDustStack) * 64L; tList.add(GT_Utility.copyAmount(64L, tDustStack)); tDustStack.stackSize -= 64; } @@ -174,71 +202,91 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr } } if ((aMaterial.mExtraData & 0x1) != 0) { - ItemStack cells = tCapsuleCount > 0L ? ItemList.Cell_Empty.get(tCapsuleCount) : null; - - GT_Values.RA.stdBuilder() - .itemInputs(GT_Utility.copyAmount(tItemAmount, aStack), cells) - .itemOutputs( - tList.size() < 1 ? null : tList.get(0), - tList.size() < 2 ? null : tList.get(1), - tList.size() < 3 ? null : tList.get(2), - tList.size() < 4 ? null : tList.get(3), - tList.size() < 5 ? null : tList.get(4), - tList.size() < 6 ? null : tList.get(5)) - .noFluidInputs() - .fluidOutputs(tFluid) - .duration(Math.max(1L, Math.abs(aMaterial.getProtons() * 2L * tItemAmount))) - .eut(Math.min(4, tList.size()) * 30) - .addTo(sElectrolyzerRecipes); + 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); + } else { + recipeBuilder.noItemOutputs(); + } + recipeBuilder.noFluidInputs(); + if (tFluid != null) { + recipeBuilder.fluidOutputs(tFluid); + } else { + recipeBuilder.noFluidOutputs(); + } + recipeBuilder + .duration(Math.max(1L, Math.abs(aMaterial.getProtons() * 2L * tItemAmount))) + .eut(Math.min(4, tList.size()) * 30) + .addTo(sElectrolyzerRecipes); + } } if ((aMaterial.mExtraData & 0x2) != 0) { - GT_Values.RA.stdBuilder() - .itemInputs( - GT_Utility.copyAmount(tItemAmount, aStack), - tCapsuleCount > 0L ? ItemList.Cell_Empty.get(tCapsuleCount) : null) - .itemOutputs( - tList.size() < 1 ? null : tList.get(0), - tList.size() < 2 ? null : tList.get(1), - tList.size() < 3 ? null : tList.get(2), - tList.size() < 4 ? null : tList.get(3), - tList.size() < 5 ? null : tList.get(4), - tList.size() < 6 ? null : tList.get(5)) - .noFluidInputs() - .fluidOutputs(tFluid) - .duration(Math.max(1L, Math.abs(aMaterial.getMass() * 4L * tItemAmount))) - .eut(Math.min(4, tList.size()) * 5) - .addTo(sCentrifugeRecipes); + 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); + } else { + recipeBuilder.noItemOutputs(); + } + recipeBuilder.noFluidInputs(); + if (tFluid != null) { + recipeBuilder.fluidOutputs(tFluid); + } else { + recipeBuilder.noFluidOutputs(); + } + recipeBuilder.duration(Math.max(1L, Math.abs(aMaterial.getMass() * 4L * tItemAmount))) + .eut(Math.min(4, tList.size()) * 5) + .addTo(sCentrifugeRecipes); + } } } } - if (aMaterial.contains(SubTag.CRYSTALLISABLE)) { - GT_Values.RA.addAutoclaveRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_Utility.getIntegratedCircuit(1), - Materials.Water.getFluid(200L), - GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L), - 7000, - 2000, - 24, - false); - GT_Values.RA.addAutoclaveRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_Utility.getIntegratedCircuit(2), - GT_ModHandler.getDistilledWater(100L), - GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L), - 9000, - 1500, - 24, - false); - GT_Values.RA.addAutoclaveRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_Utility.getIntegratedCircuit(3), - Materials.Void.getMolten(36L), - GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L), - 10000, - 1200, - 24, - false); + if (aMaterial.contains(SubTag.CRYSTALLISABLE) + && GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(7000) + .fluidInputs(Materials.Water.getFluid(200L)) + .noFluidOutputs() + .duration(1 * MINUTES + 40 * SECONDS) + .eut(24) + .addTo(sAutoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(9000) + .fluidInputs(GT_ModHandler.getDistilledWater(100L)) + .noFluidOutputs() + .duration(1 * MINUTES + 15 * SECONDS) + .eut(24) + .addTo(sAutoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(10000) + .fluidInputs(Materials.Void.getMolten(36L)) + .noFluidOutputs() + .duration(1 * MINUTES) + .eut(24) + .addTo(sAutoclaveRecipes); } switch (aMaterial.mName) { case "NULL": @@ -282,12 +330,50 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr GT_Utility.copyAmount(1L, aStack), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 1L)); break; - case "Diamond": - GT_Values.RA.addImplosionRecipe( - GT_Utility.copyAmount(4L, aStack), - 32, - ItemList.IC2_Industrial_Diamond.get(3L), - GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L)); + case "Diamond": { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4L, aStack), ItemList.Block_Powderbarrel.get(64)) + .itemOutputs( + ItemList.IC2_Industrial_Diamond.get(3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(4L, aStack), + GT_ModHandler.getIC2Item("dynamite", 16, null)) + .itemOutputs( + ItemList.IC2_Industrial_Diamond.get(3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4L, aStack), new ItemStack(Blocks.tnt, 32)) + .itemOutputs( + ItemList.IC2_Industrial_Diamond.get(3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4L, aStack), GT_ModHandler.getIC2Item("industrialTnt", 8)) + .itemOutputs( + ItemList.IC2_Industrial_Diamond.get(3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + } break; case "Opal": case "Olivine": @@ -298,12 +384,50 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr case "Topaz": case "BlueTopaz": case "Tanzanite": - case "Amethyst": - GT_Values.RA.addImplosionRecipe( - GT_Utility.copyAmount(4L, aStack), - 24, - GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), - GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L)); + case "Amethyst": { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4L, aStack), ItemList.Block_Powderbarrel.get(48)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(4L, aStack), + GT_ModHandler.getIC2Item("dynamite", 12, null)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4L, aStack), new ItemStack(Blocks.tnt, 24)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4L, aStack), GT_ModHandler.getIC2Item("industrialTnt", 6)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + } break; case "FoolsRuby": case "GarnetRed": @@ -313,12 +437,50 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr case "Monazite": case "Forcicium": case "Forcillium": - case "Force": - GT_Values.RA.addImplosionRecipe( - GT_Utility.copyAmount(4L, aStack), - 16, - GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), - GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L)); + case "Force": { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4L, aStack), ItemList.Block_Powderbarrel.get(32)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(4L, aStack), + GT_ModHandler.getIC2Item("dynamite", 8, null)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4L, aStack), new ItemStack(Blocks.tnt, 16)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(4L, aStack), GT_ModHandler.getIC2Item("industrialTnt", 4)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + } } } case dustPure, dustImpure, dustRefined -> { @@ -327,63 +489,78 @@ public class ProcessingDust implements gregtech.api.interfaces.IOreRecipeRegistr aMaterial, aMaterial.mOreByProducts); if (aPrefix == OrePrefixes.dustPure) { - if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_GOLD)) - GT_Values.RA.addElectromagneticSeparatorRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), - GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Gold, 1L), - GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Gold, 1L), - new int[] { 10000, 4000, 2000 }, - 400, - 24); - if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_IRON)) - GT_Values.RA.addElectromagneticSeparatorRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), - GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Iron, 1L), - GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Iron, 1L), - new int[] { 10000, 4000, 2000 }, - 400, - 24); + if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_GOLD)) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, 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) + .noFluidInputs() + .noFluidOutputs() + .duration(20 * SECONDS) + .eut(24) + .addTo(sElectroMagneticSeparatorRecipes); + } + if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_IRON)) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, 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) + .noFluidInputs() + .noFluidOutputs() + .duration(20 * SECONDS) + .eut(24) + .addTo(sElectroMagneticSeparatorRecipes); + } if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_NEODYMIUM)) { - GT_Values.RA.addElectromagneticSeparatorRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), - GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Neodymium, 1L), - GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Neodymium, 1L), - new int[] { 10000, 4000, 2000 }, - 400, - 24); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, 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) + .noFluidInputs() + .noFluidOutputs() + .duration(20 * SECONDS) + .eut(24) + .addTo(sElectroMagneticSeparatorRecipes); } } - if (aMaterial.contains(SubTag.CRYSTALLISABLE)) { - GT_Values.RA.addAutoclaveRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_Utility.getIntegratedCircuit(1), - Materials.Water.getFluid(200L), - GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L), - 9000, - 2000, - 24, - false); - GT_Values.RA.addAutoclaveRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_Utility.getIntegratedCircuit(2), - GT_ModHandler.getDistilledWater(100L), - GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L), - 9500, - 1500, - 24, - false); - GT_Values.RA.addAutoclaveRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_Utility.getIntegratedCircuit(3), - Materials.Void.getMolten(36L), - GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L), - 10000, - 1200, - 24, - false); + if (aMaterial.contains(SubTag.CRYSTALLISABLE) + && GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(9000) + .fluidInputs(Materials.Water.getFluid(200L)) + .noFluidOutputs() + .duration(1 * MINUTES + 40 * SECONDS) + .eut(24) + .addTo(sAutoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(9500) + .fluidInputs(GT_ModHandler.getDistilledWater(100L)) + .noFluidOutputs() + .duration(1 * MINUTES + 15 * SECONDS) + .eut(24) + .addTo(sAutoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) + .outputChances(10000) + .fluidInputs(Materials.Void.getMolten(36L)) + .noFluidOutputs() + .duration(1 * MINUTES) + .eut(24) + .addTo(sAutoclaveRecipes); } ItemStack tImpureStack = GT_OreDictUnificator.get( OrePrefixes.dustTiny, diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java index 809ce8894f..0af641d35c 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java @@ -9,7 +9,6 @@ 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.SubTag; @@ -161,8 +160,7 @@ public class ProcessingOre implements gregtech.api.interfaces.IOreRecipeRegistra null, null, GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, tSmeltInto), - ItemList.TE_Slag - .get(1L, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L), tSmeltInto.stackSize * 500, 120, 1500); @@ -172,8 +170,7 @@ public class ProcessingOre implements gregtech.api.interfaces.IOreRecipeRegistra null, null, GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, tSmeltInto), - ItemList.TE_Slag - .get(1L, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L), tSmeltInto.stackSize * 500, 120, 1500); @@ -186,8 +183,7 @@ public class ProcessingOre implements gregtech.api.interfaces.IOreRecipeRegistra null, null, GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, tSmeltInto), - ItemList.TE_Slag - .get(1L, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L), tSmeltInto.stackSize * 500, 120, 1500); @@ -197,8 +193,7 @@ public class ProcessingOre implements gregtech.api.interfaces.IOreRecipeRegistra null, null, GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, tSmeltInto), - ItemList.TE_Slag - .get(1L, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L)), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L), tSmeltInto.stackSize * 500, 120, 1500); diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java index a874d9991d..dd4d950676 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java @@ -3,11 +3,21 @@ package gregtech.loaders.oreprocessing; import static gregtech.api.enums.ConfigCategories.Recipes.harderrecipes; import static gregtech.api.enums.GT_Values.L; import static gregtech.api.enums.GT_Values.NI; -import static gregtech.api.enums.GT_Values.RA; import static gregtech.api.enums.GT_Values.W; 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_Recipe.GT_Recipe_Map.sAlloySmelterRecipes; +import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sAssemblerRecipes; import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sBenderRecipes; +import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCutterRecipes; +import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sExtruderRecipes; +import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sFluidSolidficationRecipes; +import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sImplosionRecipes; +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; @@ -17,10 +27,19 @@ import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import gregtech.api.GregTech_API; -import gregtech.api.enums.*; +import gregtech.api.enums.ConfigCategories; +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.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; @@ -81,18 +100,28 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L)); if (aMaterial.mFuelPower > 0) { - RA.addFuel(GT_Utility.copyAmount(1L, aStack), NI, aMaterial.mFuelPower, aMaterial.mFuelType); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack)) + .noItemOutputs() + .noFluidInputs() + .noFluidOutputs() + .metadata(FUEL_VALUE, aMaterial.mFuelPower) + .metadata(FUEL_TYPE, aMaterial.mFuelType) + .duration(0) + .eut(0) + .addTo(GT_RecipeConstants.Fuel); } if (aMaterial.mStandardMoltenFluid != null && !(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { - - RA.addFluidSolidifierRecipe( - ItemList.Shape_Mold_Plate.get(0L), - aMaterial.getMolten(L), - aMaterial.getPlates(1), - 32, - calculateRecipeEU(aMaterial, 8)); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Plate.get(0L)) + .itemOutputs(aMaterial.getPlates(1)) + .fluidInputs(aMaterial.getMolten(L)) + .noFluidOutputs() + .duration(1 * SECONDS + 12 * TICKS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(sFluidSolidficationRecipes); } GT_ModHandler.addCraftingRecipe( @@ -205,14 +234,16 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist .addTo(sBenderRecipes); } else { - - RA.addAssemblerRecipe( - GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 2L), - GT_Utility.getIntegratedCircuit(2), - Materials.Glue.getFluid(10L), - GT_Utility.copyAmount(1L, aStack), - 64, - 8); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 2L), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(GT_Utility.copyAmount(1L, aStack)) + .fluidInputs(Materials.Glue.getFluid(10L)) + .noFluidOutputs() + .duration(3 * SECONDS + 4 * TICKS) + .eut(8) + .addTo(sAssemblerRecipes); } } @@ -271,21 +302,60 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist .addTo(sBenderRecipes); } else { - - RA.addAssemblerRecipe( - GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 3L), - GT_Utility.getIntegratedCircuit(3), - Materials.Glue.getFluid(20L), - GT_Utility.copyAmount(1L, aStack), - 96, - 8); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 3L), + GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(GT_Utility.copyAmount(1L, aStack)) + .fluidInputs(Materials.Glue.getFluid(20L)) + .noFluidOutputs() + .duration(4 * SECONDS + 16 * TICKS) + .eut(8) + .addTo(sAssemblerRecipes); } - RA.addImplosionRecipe( - GT_Utility.copyAmount(1L, aStack), - 2, - GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L), - GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)); + if (GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L) != null) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), ItemList.Block_Powderbarrel.get(4)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_ModHandler.getIC2Item("dynamite", 1, null)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), new ItemStack(Blocks.tnt, 2)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), GT_ModHandler.getIC2Item("industrialTnt", 1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)) + .noFluidInputs() + .noFluidOutputs() + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(sImplosionRecipes); + } } private void registerPlateQuadruple(final Materials aMaterial, final ItemStack aStack, final boolean aNoSmashing, @@ -295,12 +365,6 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist GT_ModHandler.removeRecipeByOutputDelayed(aStack); - if (!aNoWorking) RA.addCNCRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial, 1L), - (int) Math.max(aMaterialMass * 2L, 1L), - 30); - if (!aNoSmashing) { if (GregTech_API.sRecipeFile.get( @@ -339,14 +403,16 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist .addTo(sBenderRecipes); } else { - - RA.addAssemblerRecipe( - GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 4L), - GT_Utility.getIntegratedCircuit(4), - Materials.Glue.getFluid(30L), - GT_Utility.copyAmount(1L, aStack), - 128, - 8); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 4L), + GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(GT_Utility.copyAmount(1L, aStack)) + .fluidInputs(Materials.Glue.getFluid(30L)) + .noFluidOutputs() + .duration(6 * SECONDS + 8 * TICKS) + .eut(8) + .addTo(sAssemblerRecipes); } } @@ -395,14 +461,16 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist .addTo(sBenderRecipes); } else { - - RA.addAssemblerRecipe( - gregtech.api.util.GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 5L), - ItemList.Circuit_Integrated.getWithDamage(0L, 5L), - Materials.Glue.getFluid(40L), - GT_Utility.copyAmount(1L, aStack), - 160, - 8); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 5L), + GT_Utility.getIntegratedCircuit(5)) + .itemOutputs(GT_Utility.copyAmount(1L, aStack)) + .fluidInputs(Materials.Glue.getFluid(40L)) + .noFluidOutputs() + .duration(8 * SECONDS) + .eut(8) + .addTo(sAssemblerRecipes); } } @@ -434,13 +502,14 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist GT_ModHandler.removeRecipeByOutputDelayed(aStack); if (aMaterial.mStandardMoltenFluid != null) { - - RA.addFluidSolidifierRecipe( - ItemList.Shape_Mold_Casing.get(0L), - aMaterial.getMolten(L / 2), - GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 1L), - 16, - calculateRecipeEU(aMaterial, 8)); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Casing.get(0L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 1L)) + .fluidInputs(aMaterial.getMolten(L / 2)) + .noFluidOutputs() + .duration(16 * TICKS) + .eut(calculateRecipeEU(aMaterial, 8)) + .addTo(sFluidSolidficationRecipes); } if (aMaterial.mUnificatable && aMaterial.mMaterialInto == aMaterial @@ -462,27 +531,77 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist } } - RA.addAlloySmelterRecipe( - GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 2L), - ItemList.Shape_Mold_Casing.get(0L), - GT_Utility.copyAmount(3L, aStack), - 128, - calculateRecipeEU(aMaterial, 15)); - - RA.addCutterRecipe( - GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), - GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 2L), - NI, - (int) Math.max(aMaterial.getMass(), 1L), - calculateRecipeEU(aMaterial, 16)); - - RA.addExtruderRecipe( - GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), - ItemList.Shape_Extruder_Casing.get(0L), - GT_OreDictUnificator.get(OrePrefixes.itemCasing, aMaterial, 2L), - (int) Math.max(aMaterial.getMass(), 1L), - calculateRecipeEU(aMaterial, 45)); + 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(3L, aStack)) + .noFluidInputs() + .noFluidOutputs() + .duration(6 * SECONDS + 8 * TICKS) + .eut(calculateRecipeEU(aMaterial, 15)) + .addTo(sAlloySmelterRecipes); + + 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)) + .noFluidInputs() + .noFluidOutputs() + .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 45)) + .addTo(sExtruderRecipes); + } + + 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)))) + .noFluidOutputs() + .duration(2 * ((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(sCutterRecipes); + + 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)))) + .noFluidOutputs() + .duration(2 * ((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(sCutterRecipes); + 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)))) + .noFluidOutputs() + .duration(((int) Math.max(aMaterial.getMass(), 1L)) * TICKS) + .eut(calculateRecipeEU(aMaterial, 16)) + .addTo(sCutterRecipes); + } GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); } @@ -490,26 +609,31 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist switch (aOreDictName) { case "plateAlloyCarbon" -> { - RA.addAssemblerRecipe( - GT_ModHandler.getIC2Item("generator", 1L), - GT_Utility.copyAmount(4L, aStack), - GT_ModHandler.getIC2Item("windMill", 1L), - 6400, - 8); - GT_ModHandler.addAlloySmelterRecipe( - GT_Utility.copyAmount(1L, aStack), - new ItemStack(Blocks.glass, 3, W), - GT_ModHandler.getIC2Item("reinforcedGlass", 4L), - 400, - 4, - false); - GT_ModHandler.addAlloySmelterRecipe( - GT_Utility.copyAmount(1L, aStack), - Materials.Glass.getDust(3), - GT_ModHandler.getIC2Item("reinforcedGlass", 4L), - 400, - 4, - false); + GT_Values.RA.stdBuilder() + .itemInputs(GT_ModHandler.getIC2Item("generator", 1L), GT_Utility.copyAmount(4L, aStack)) + .itemOutputs(GT_ModHandler.getIC2Item("windMill", 1L)) + .noFluidInputs() + .noFluidOutputs() + .duration(5 * MINUTES + 20 * SECONDS) + .eut(8) + .addTo(sAssemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), new ItemStack(Blocks.glass, 3, W)) + .itemOutputs(GT_ModHandler.getIC2Item("reinforcedGlass", 4L)) + .noFluidInputs() + .noFluidOutputs() + .duration(20 * SECONDS) + .eut(4) + .addTo(sAlloySmelterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1L, aStack), Materials.Glass.getDust(3)) + .itemOutputs(GT_ModHandler.getIC2Item("reinforcedGlass", 4L)) + .noFluidInputs() + .noFluidOutputs() + .duration(20 * SECONDS) + .eut(4) + .addTo(sAlloySmelterRecipes); } case "plateAl