diff options
Diffstat (limited to 'src/main/java/gregtech/loaders/oreprocessing')
50 files changed, 9593 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/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..dcdbda4508 --- /dev/null +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java @@ -0,0 +1,448 @@ +package gregtech.loaders.oreprocessing; + +import static gregtech.api.enums.GT_Values.RA; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.electrolyzerRecipes; +import static gregtech.api.recipe.RecipeMaps.extractorRecipes; +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 java.util.ArrayList; + +import net.minecraft.item.ItemStack; + +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")) { + RA.stdBuilder() + .itemInputs(ItemList.Cell_Empty.get(1L)) + .itemOutputs(aStack) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + } + } else { + if (aMaterial.mFuelPower > 0) { + GT_RecipeBuilder recipeBuilder = 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 = RA.stdBuilder(); + if (tCapsuleCount > 0L) { + recipeBuilder.itemInputs( + GT_Utility.copyAmount(tItemAmount, aStack), + |