From d9f473283fa606662f57bbafdd49be37728b0eb0 Mon Sep 17 00:00:00 2001 From: Connor-Colenso <52056774+Connor-Colenso@users.noreply.github.com> Date: Wed, 25 Jan 2023 05:22:14 +0000 Subject: EOH materials + Allow materials to pick their processing tier (#1671) * Begin addition of tiered material manipulation * Dwarf matter * Add hardcoded EU tiers for wider usage. * New material images etc * Nugget processing tiers * Move iron nugget to wrought iron smelting to the correct place * Add white dwarf shapes * Add white dwarf shapes * Additional retiering options for EU consumption on material part generation * White dwarf matter complete * Tier neutronium processing at ZPM * Spotless * More adjustments * Renaming files * Add new overlays for magneto material and more name adjustments * Add no recipes subtag * Spotless + name adjustment * Undo isCustom to maintain potential public variable references in addons. * Undo isCustom to maintain potential public variable references in addons. * Fix fluid registry corruption. * Add rotor EU override * Add rotor EU override * Make neutronium mass more reasonable * Add proper time adjustments to rotor (probably an old oversight) * Adjust enums to use VP rather than recalculate * Fix typos on EU usage * spotlessApply (#1672) Co-authored-by: Connor-Colenso <52056774+Connor-Colenso@users.noreply.github.com> Co-authored-by: GitHub GTNH Actions <> * Change setProcessingMaterialTierEU to accept long. * Small fix * Add space and time materials * Add new forge hammer support * Update tooltip * Expand laser engraver slots. * spotlessApply (#1673) Co-authored-by: Connor-Colenso <52056774+Connor-Colenso@users.noreply.github.com> Co-authored-by: GitHub GTNH Actions <> * Reserve texture page. * Modernise GT circuit usage * Add oversight in assembler frame recipe * Add missing MHDCSM overlay textures * Remove small and tiny MHDCSM dusts * Fix error in ingot texture * Fix NO_RECIPES not applying to frame boxes * Restore missing ingot * Add rod handles for materials * Fix frame box auto generating with NO_RECIPEs tag * recipe * Spotless * Add MOD_ID_GTPP as modid * spotlessApply (#1675) Co-authored-by: Connor-Colenso <52056774+Connor-Colenso@users.noreply.github.com> Co-authored-by: GitHub GTNH Actions <> * Remove smelting spacetime from furnace (why does this exist?) * Recipes + new storage blocks for materials * Bedrockium LuV -> EV * SpaceTime UMV -> UIV * TranscendentMetal UIV -> UEV * MagnetoThingy and dward mats UXV -> UMV * update buildscript * yeet magic number that could be * spotlessApply * Make the nanite tier 3, colen request * Up nanite tier * Comment * Change name * Change name Co-authored-by: GTNH-Colen <54497873+GTNH-Colen@users.noreply.github.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: adam riondy Co-authored-by: boubou19 --- .../loaders/oreprocessing/ProcessingBlock.java | 52 +- .../loaders/oreprocessing/ProcessingBolt.java | 15 +- .../loaders/oreprocessing/ProcessingFoil.java | 4 +- .../loaders/oreprocessing/ProcessingGear.java | 58 +- .../loaders/oreprocessing/ProcessingGem.java | 30 +- .../loaders/oreprocessing/ProcessingIngot.java | 159 ++- .../loaders/oreprocessing/ProcessingNugget.java | 25 +- .../loaders/oreprocessing/ProcessingPipe.java | 263 ++-- .../loaders/oreprocessing/ProcessingPlate.java | 337 ++--- .../loaders/oreprocessing/ProcessingRotor.java | 58 +- .../loaders/oreprocessing/ProcessingScrew.java | 19 +- .../loaders/oreprocessing/ProcessingShaping.java | 178 ++- .../loaders/oreprocessing/ProcessingStick.java | 40 +- .../loaders/oreprocessing/ProcessingStickLong.java | 49 +- .../loaders/oreprocessing/ProcessingToolHead.java | 381 ++--- .../loaders/oreprocessing/ProcessingWire.java | 175 +-- .../loaders/postload/GT_MachineRecipeLoader.java | 1507 +++++++++----------- .../loaders/postload/chains/GT_NaniteChain.java | 79 +- .../postload/chains/GT_PCBFactoryRecipes.java | 6 +- .../preload/GT_Loader_Item_Block_And_Fluid.java | 30 +- .../preload/GT_Loader_MetaTileEntities.java | 1 - .../java/gregtech/loaders/preload/GT_PreLoad.java | 3 +- 22 files changed, 1787 insertions(+), 1682 deletions(-) (limited to 'src/main/java/gregtech/loaders') diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java index 86630cbe08..c893d75674 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java @@ -16,17 +16,19 @@ public class ProcessingBlock implements gregtech.api.interfaces.IOreRecipeRegist public void registerOre( OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) { if (aMaterial != Materials.Clay && aMaterial != Materials.Basalt) { - GT_Values.RA.addCutterRecipe( - GT_Utility.copyAmount(1L, aStack), - aMaterial == MaterialsBotania.Livingrock - || aMaterial == MaterialsBotania.Livingwood - || aMaterial == MaterialsBotania.Dreamwood - ? GT_Utility.getIntegratedCircuit(3) - : null, - GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 9L), - null, - (int) Math.max(aMaterial.getMass() * 10L, 1L), - 30); + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + GT_Values.RA.addCutterRecipe( + GT_Utility.copyAmount(1L, aStack), + aMaterial == MaterialsBotania.Livingrock + || aMaterial == MaterialsBotania.Livingwood + || aMaterial == MaterialsBotania.Dreamwood + ? GT_Utility.getIntegratedCircuit(3) + : null, + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 9L), + null, + (int) Math.max(aMaterial.getMass() * 10L, 1L), + 30); + } } ItemStack tStack1 = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L); @@ -45,14 +47,17 @@ public class ProcessingBlock implements gregtech.api.interfaces.IOreRecipeRegist GT_ModHandler.removeRecipeDelayed( tStack3, tStack3, tStack3, tStack3, tStack3, tStack3, tStack3, tStack3, tStack3); } + if (aMaterial.mStandardMoltenFluid != null) { if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { - GT_Values.RA.addFluidSolidifierRecipe( - ItemList.Shape_Mold_Block.get(0L), - aMaterial.getMolten(1296L), - GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L), - 288, - 8); + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Block.get(0L), + aMaterial.getMolten(1296L), + GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L), + 288, + 8); + } } } if (GregTech_API.sRecipeFile.get( @@ -89,10 +94,15 @@ public class ProcessingBlock implements gregtech.api.interfaces.IOreRecipeRegist if (tStack1 != null) GT_ModHandler.addShapelessCraftingRecipe(tStack1, new Object[] {OrePrefixes.block.get(aMaterial)}); } - if (!OrePrefixes.block.isIgnored(aMaterial)) - GT_ModHandler.addCompressionRecipe( - GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 9L), - GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)); + + if (!OrePrefixes.block.isIgnored(aMaterial)) { + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + GT_ModHandler.addCompressionRecipe( + GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 9L), + GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)); + } + } + switch (aMaterial.mName) { case "Mercury": System.err.println( diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java index 17ba07917f..1234d3fc53 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java @@ -3,6 +3,7 @@ package gregtech.loaders.oreprocessing; import gregtech.api.enums.Materials; import gregtech.api.enums.OrePrefixes; import gregtech.api.enums.SubTag; +import gregtech.api.enums.Tier; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_Utility; import gregtech.common.GT_Proxy; @@ -16,12 +17,14 @@ public class ProcessingBolt implements gregtech.api.interfaces.IOreRecipeRegistr @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)) { - GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(2L, aStack), GT_Proxy.tBits, new Object[] { - "s ", " X", 'X', OrePrefixes.stick.get(aMaterial) - }); + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + if ((aMaterial.mUnificatable) + && (aMaterial.mMaterialInto == aMaterial) + && !aMaterial.contains(SubTag.NO_WORKING)) { + GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(2L, aStack), GT_Proxy.tBits, new Object[] { + "s ", " X", 'X', OrePrefixes.stick.get(aMaterial) + }); + } } } } diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java index 7a85572b5b..ae25bcee98 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java @@ -1,5 +1,7 @@ package gregtech.loaders.oreprocessing; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + import gregtech.api.GregTech_API; import gregtech.api.enums.GT_Values; import gregtech.api.enums.Materials; @@ -22,7 +24,7 @@ public class ProcessingFoil implements IOreRecipeRegistrator { GT_Utility.copyAmount(1L, GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 4L)), GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, 4L), (int) Math.max(aMaterial.getMass(), 1L), - 24); + calculateRecipeEU(aMaterial, 24)); GregTech_API.registerCover( aStack, TextureFactory.of(aMaterial.mIconSet.mTextures[70], aMaterial.mRGBa, false), null); } diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingGear.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGear.java index d05d2188b7..f5f9a1688a 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingGear.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGear.java @@ -1,5 +1,7 @@ package gregtech.loaders.oreprocessing; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + import gregtech.api.enums.*; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; @@ -27,7 +29,7 @@ public class ProcessingGear implements gregtech.api.interfaces.IOreRecipeRegistr aMaterial.getMolten(576L), GT_OreDictUnificator.get(aPrefix, aMaterial, 1L), 128, - 8); + calculateRecipeEU(aMaterial, 8)); } if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial) @@ -62,18 +64,20 @@ public class ProcessingGear implements gregtech.api.interfaces.IOreRecipeRegistr }); break; default: - 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) - }); + if (aMaterial.getProcessingMaterialTierEU() < Tier.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) + }); + } } } break; @@ -85,7 +89,7 @@ public class ProcessingGear implements gregtech.api.interfaces.IOreRecipeRegistr aMaterial.getMolten(144L), GT_Utility.copyAmount(1L, aStack), 16, - 8); + calculateRecipeEU(aMaterial, 8)); } if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial) @@ -104,18 +108,20 @@ public class ProcessingGear implements gregtech.api.interfaces.IOreRecipeRegistr new Object[] {"P ", " f", 'P', OrePrefixes.stoneSmooth}); break; default: - 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) - }); + if (aMaterial.getProcessingMaterialTierEU() < Tier.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) + }); + } } } break; diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java index 411309f396..507a015950 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java @@ -1,5 +1,7 @@ package gregtech.loaders.oreprocessing; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + import gregtech.api.GregTech_API; import gregtech.api.enums.*; import gregtech.api.util.GT_ModHandler; @@ -54,46 +56,48 @@ public class ProcessingGem GT_Utility.copyAmount(1L, aStack), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), (int) Math.max(aMaterialMass, 1L), - 16); + calculateRecipeEU(aMaterial, 16)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(1L, aStack), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), (int) Math.max(aMaterialMass * 2L, 1L), - 24); + calculateRecipeEU(aMaterial, 24)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(2L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L), (int) Math.max(aMaterialMass * 2L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(3L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L), (int) Math.max(aMaterialMass * 3L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(4L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int) Math.max(aMaterialMass * 4L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(5L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L), (int) Math.max(aMaterialMass * 5L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(9L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L), (int) Math.max(aMaterialMass * 9L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); } if (aNoWorking) { - GT_Values.RA.addLatheRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L), - GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 2L), - (int) Math.max(aMaterialMass, 1L), - 16); + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + GT_Values.RA.addLatheRecipe( + GT_Utility.copyAmount(1L, aStack), + GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 2L), + (int) Math.max(aMaterialMass, 1L), + calculateRecipeEU(aMaterial, 16)); + } } else { if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) { GT_ModHandler.addCraftingRecipe( diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java index 88995c0e0b..bd98e6a162 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingIngot.java @@ -1,5 +1,7 @@ package gregtech.loaders.oreprocessing; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + import gregtech.api.GregTech_API; import gregtech.api.enums.*; import gregtech.api.util.GT_ModHandler; @@ -42,7 +44,7 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist aMaterial.getMolten(144L), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), 32, - 8); + calculateRecipeEU(aMaterial, 8)); } } GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); @@ -71,47 +73,49 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist } if (!aNoSmashing) { - GT_Values.RA.addForgeHammerRecipe( - GT_Utility.copyAmount(3L, aStack), - GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 2L), - (int) Math.max(aMaterialMass, 1L), - 16); + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + GT_Values.RA.addForgeHammerRecipe( + GT_Utility.copyAmount(3L, aStack), + GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 2L), + (int) Math.max(aMaterialMass, 1L), + calculateRecipeEU(aMaterial, 16)); + } GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(1L, aStack), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), (int) Math.max(aMaterialMass, 1L), - 24); + calculateRecipeEU(aMaterial, 24)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(2L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L), (int) Math.max(aMaterialMass * 2L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(3L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L), (int) Math.max(aMaterialMass * 3L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(4L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int) Math.max(aMaterialMass * 4L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(5L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L), (int) Math.max(aMaterialMass * 5L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(9L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L), (int) Math.max(aMaterialMass * 9L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(1L, aStack), GT_Utility.getIntegratedCircuit(10), GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, 4L), (int) Math.max(aMaterialMass * 2L, 1L), - 24); + calculateRecipeEU(aMaterial, 24)); } break; @@ -121,19 +125,23 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist GT_Utility.copyAmount(1L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L), (int) Math.max(aMaterialMass, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(2L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int) Math.max(aMaterialMass * 2L, 1L), - 96); - if (aSpecialRecipeReq - && GregTech_API.sRecipeFile.get( - ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) { - GT_ModHandler.addCraftingRecipe( - GT_OreDictUnificator.get(OrePrefixes.ingotDouble, aMaterial, 1L), - GT_Proxy.tBits, - new Object[] {"I", "I", "h", 'I', OrePrefixes.ingot.get(aMaterial)}); + calculateRecipeEU(aMaterial, 96)); + + // Enable crafting with hammer if tier is < IV. + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + if (aSpecialRecipeReq + && GregTech_API.sRecipeFile.get( + ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.ingotDouble, aMaterial, 1L), + GT_Proxy.tBits, + new Object[] {"I", "I", "h", 'I', OrePrefixes.ingot.get(aMaterial)}); + } } } break; @@ -143,27 +151,29 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist GT_Utility.copyAmount(1L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L), (int) Math.max(aMaterialMass, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); GT_Values.RA.addBenderRecipe( GT_Utility.copyAmount(3L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L), (int) Math.max(aMaterialMass * 3L, 1L), - 96); - if (aSpecialRecipeReq - && GregTech_API.sRecipeFile.get( - ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) { - 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) - }); + calculateRecipeEU(aMaterial, 96)); + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + if (aSpecialRecipeReq + && GregTech_API.sRecipeFile.get( + ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) { + 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) + }); + } } } break; @@ -173,22 +183,26 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist GT_Utility.copyAmount(1L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int) Math.max(aMaterialMass, 1L), - 96); - if (aSpecialRecipeReq - && GregTech_API.sRecipeFile.get( - ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) { - 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) - }); + calculateRecipeEU(aMaterial, 96)); + + // If tier < IV add manual crafting. + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + if (aSpecialRecipeReq + && GregTech_API.sRecipeFile.get( + ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) { + 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) + }); + } } } break; @@ -198,22 +212,25 @@ public class ProcessingIngot implements gregtech.api.interfaces.IOreRecipeRegist GT_Utility.copyAmount(1L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L), (int) Math.max(aMaterialMass, 1L), - 96); - if (aSpecialRecipeReq - && GregTech_API.sRecipeFile.get( - ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) { - 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) - }); + calculateRecipeEU(aMaterial, 96)); + + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + if (aSpecialRecipeReq + && GregTech_API.sRecipeFile.get( + ConfigCategories.Tools.hammermultiingot, aMaterial.toString(), true)) { + 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) + }); + } } } break; diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java index b1a73e19b5..7e2dfbd439 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java @@ -1,5 +1,7 @@ package gregtech.loaders.oreprocessing; +import static gregtech.api.util.GT_Utility.calculateRecipeEU; + import gregtech.api.enums.*; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; @@ -15,10 +17,7 @@ public class ProcessingNugget implements gregtech.api.interfaces.IOreRecipeRegis @Override public void registerOre( OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) { - if (aMaterial == Materials.Iron) - GT_ModHandler.addSmeltingRecipe( - GT_Utility.copyAmount(1L, aStack), - GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.WroughtIron, 1L)); + GT_Values.RA.addAlloySmelterRecipe( GT_Utility.copyAmount(9L, aStack), aMaterial.contains(SubTag.SMELTING_TO_GEM) @@ -29,7 +28,8 @@ public class ProcessingNugget implements gregtech.api.interfaces.IOreRecipeRegis aMaterial.mSmeltInto, 1L), 200, - 2); + calculateRecipeEU(aMaterial, 2)); + if (aMaterial.mStandardMoltenFluid != null) if (!(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { GT_Values.RA.addFluidSolidifierRecipe( @@ -37,8 +37,9 @@ public class ProcessingNugget implements gregtech.api.interfaces.IOreRecipeRegis aMaterial.getMolten(16L), GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial, 1L), 16, - 4); + calculateRecipeEU(aMaterial, 4)); } + GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); GT_RecipeRegistrator.registerReverseMacerating( aStack, aMaterial, aPrefix.mMaterialAmount, null, null, null, false); @@ -48,11 +49,13 @@ public class ProcessingNugget implements gregtech.api.interfaces.IOreRecipeRegis ItemList.Shape_Mold_Nugget.get(0L), GT_Utility.copyAmount(9L, aStack), 100, - 1); - GT_ModHandler.addCraftingRecipe( - GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial, 9L), - GT_ModHandler.RecipeBits.BUFFERED, - new Object[] {"sI ", 'I', OrePrefixes.ingot.get(aMaterial)}); + calculateRecipeEU(aMaterial, 1)); + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + GT_ModHandler.addCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial, 9L), + GT_ModHandler.RecipeBits.BUFFERED, + new Object[] {"sI ", 'I', OrePrefixes.ingot.get(aMaterial)}); + } } } } diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPipe.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPipe.java index 709a6c36b3..f39e04d61e 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPipe.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPipe.java @@ -25,137 +25,142 @@ public class ProcessingPipe implements gregtech.api.interfaces.IOreRecipeRegistr @Override public void registerOre( OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) { - switch (aPrefix) { - case pipeHuge: - case pipeLarge: - case pipeMedium: - case pipeSmall: - case pipeTiny: - 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)}); - break; - case pipeRestrictiveHuge: - case pipeRestrictiveLarge: - case pipeRestrictiveMedium: - case pipeRestrictiveSmall: - case pipeRestrictiveTiny: - gregtech.api.enums.GT_Values.RA.addAssemblerRecipe( - GT_OreDictUnificator.get(aOreDictName.replaceFirst("Restrictive", ""), null, 1L, false, true), - GT_OreDictUnificator.get( - OrePrefixes.ring, - Materials.Steel, - aPrefix.mSecondaryMaterial.mAmount / OrePrefixes.ring.mMaterialAmount), - GT_Utility.copyAmount(1L, aStack), - (int) (aPrefix.mSecondaryMaterial.mAmount * 400L / OrePrefixes.ring.mMaterialAmount), - 4); - break; - case pipeQuadruple: - GT_ModHandler.addCraftingRecipe( - GT_Utility.copyAmount(1, aStack), - GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, - new Object[] { - "PP ", - "PP ", - " ", - 'P', + // These are only generated if a materials tier is < IV. + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + switch (aPrefix) { + case pipeHuge: + case pipeLarge: + case pipeMedium: + case pipeSmall: + case pipeTiny: + 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)}); + break; + case pipeRestrictiveHuge: + case pipeRestrictiveLarge: + case pipeRestrictiveMedium: + case pipeRestrictiveSmall: + case pipeRestrictiveTiny: + gregtech.api.enums.GT_Values.RA.addAssemblerRecipe( GT_OreDictUnificator.get( - aOreDictName.replaceFirst("Quadruple", "Medium"), null, 1L, false, true) - }); - gregtech.api.enums.GT_Values.RA.addAssemblerRecipe( - GT_OreDictUnificator.get( - aOreDictName.replaceFirst("Quadruple", "Medium"), null, 4L, false, true), - ItemList.Circuit_Integrated.getWithDamage(0, 4), - GT_Utility.copyAmount(1L, aStack), - 40, - 8); - break; - case pipeNonuple: - GT_ModHandler.addCraftingRecipe( - GT_Utility.copyAmount(1, aStack), - GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, - new Object[] { - "PPP", - "PPP", - "PPP", - 'P', + aOreDictName.replaceFirst("Restrictive", ""), null, 1L, false, true), GT_OreDictUnificator.get( - aOreDictName.replaceFirst("Nonuple", "Small"), null, 1L, false, true) - }); - gregtech.api.enums.GT_Values.RA.addAssemblerRecipe( - GT_OreDictUnificator.get(aOreDictName.replaceFirst("Nonuple", "Small"), null, 9L, false, true), - ItemList.Circuit_Integrated.getWithDamage(0, 9), - GT_Utility.copyAmount(1L, aStack), - 60, - 8); - break; - default: - break; + OrePrefixes.ring, + Materials.Steel, + aPrefix.mSecondaryMaterial.mAmount / OrePrefixes.ring.mMaterialAmount), + GT_Utility.copyAmount(1L, aStack), + (int) (aPrefix.mSecondaryMaterial.mAmount * 400L / OrePrefixes.ring.mMaterialAmount), + 4); + break; + case pipeQuadruple: + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(1, aStack), + GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[] { + "PP ", + "PP ", + " ", + 'P', + GT_OreDictUnificator.get( + aOreDictName.replaceFirst("Quadruple", "Medium"), null, 1L, false, true) + }); + gregtech.api.enums.GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get( + aOreDictName.replaceFirst("Quadruple", "Medium"), null, 4L, false, true), + ItemList.Circuit_Integrated.getWithDamage(0, 4), + GT_Utility.copyAmount(1L, aStack), + 40, + 8); + break; + case pipeNonuple: + 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) + }); + gregtech.api.enums.GT_Values.RA.addAssemblerRecipe( + GT_OreDictUnificator.get( + aOreDictName.replaceFirst("Nonuple", "Small"), null, 9L, false, true), + ItemList.Circuit_Integrated.getWithDamage(0, 9), + GT_Utility.copyAmount(1L, aStack), + 60, + 8); + break; + default: + break; + } } } } diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java index c96d49ae46..2ec37ed6e9 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingPlate.java @@ -7,16 +7,11 @@ 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_Utility.calculateRecipeEU; import static gregtech.common.GT_Proxy.tBits; import gregtech.api.GregTech_API; -import gregtech.api.enums.ConfigCategories; -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.ToolDictNames; +import gregtech.api.enums.*; import gregtech.api.render.TextureFactory; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; @@ -100,7 +95,6 @@ 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); } @@ -108,7 +102,11 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist && !(aMaterial == Materials.AnnealedCopper || aMaterial == Materials.WroughtIron)) { RA.addFluidSolidifierRecipe( - ItemList.Shape_Mold_Plate.get(0L), aMaterial.getMolten(L), aMaterial.getPlates(1), 32, 8); + ItemList.Shape_Mold_Plate.get(0L), + aMaterial.getMolten(L), + aMaterial.getPlates(1), + 32, + calculateRecipeEU(aMaterial, 8)); } GT_ModHandler.addCraftingRecipe( @@ -129,61 +127,65 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist if (!aNoSmashing && GregTech_API.sRecipeFile.get(ConfigCategories.Tools.hammerplating, aMaterial.toString(), true)) { - 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.getProcessingMaterialTierEU() < Tier.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)) && (GregTech_API.sRecipeFile.get(ConfigCategories.Tools.mortar, aMaterial.mName, true))) { - 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)}); + if (aMaterial.getProcessingMaterialTierEU() < Tier.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)}); + } } } } @@ -201,7 +203,7 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist GT_Utility.copyAmount(2L, aStack), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int) Math.max(aMaterialMass * 2L, 1L), - 96); + calculateRecipeEU(aMaterial, 96)); if (GregTech_API.sRecipeFile.get( gregtech.api.enums.ConfigCategories.Tools.hammerdoubleplate, @@ -210,35 +212,39 @@ public class ProcessingPlate implements gregtech.api.interfaces.IOreRecipeRegist Object aPlateStack = OrePrefixes.plate.get(aMaterial); - GT_ModHandler.addCraftingRecipe( - GT_Utility.copyAmount(1L, aStack), DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED, new Object[] { - "I", - "B", - "h", // craftingToolHardHammer - 'I', - aPlateStack, - 'B', - aPlateStack - }); + if (aMaterial.getProcessingMaterialTierEU() < Tier.IV) { + GT_ModHandler.addCraftingRecipe( + GT_Utility.copyAmount(1L, aStack), DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED, new Object[] { + "I", + "B", + "h", // craftingToolHardHammer + 'I', + aPlateStack, + 'B', + aPlateStack + }); + } // Only added if IC2 Forge Hammer is enabled in Recipes.cfg: B:ic2forgehammer_true=false - GT_ModHandler.addShapelessCraftingRecipe( - GT_Utility.copyAmount(1L, aStack), DO_NOT_CHECK_FOR_COLLISIONS | BUFFERED, new Object[] { - gregtech.api.enums.ToolDictNames.craftingToolForgeHammer, aPlateStack, aPlateStack - }); +