From 3868d14f4508329df7d515af55000d6386a7866d Mon Sep 17 00:00:00 2001 From: TheDarkDnKTv Date: Sun, 14 Mar 2021 08:04:30 +0200 Subject: [PATCH] Gems processor optimized now --- .../gregtechmod/api/util/GT_ModHandler.java | 9 ++- .../gregtechmod/common/RecipeHandler.java | 64 +++++++++++++++++++ .../loaders/oreprocessing/ProcessingDust.java | 49 +++++++------- .../loaders/oreprocessing/ProcessingGem.java | 26 ++++---- 4 files changed, 110 insertions(+), 38 deletions(-) diff --git a/src/main/java/gregtechmod/api/util/GT_ModHandler.java b/src/main/java/gregtechmod/api/util/GT_ModHandler.java index 27856d0..066807d 100644 --- a/src/main/java/gregtechmod/api/util/GT_ModHandler.java +++ b/src/main/java/gregtechmod/api/util/GT_ModHandler.java @@ -724,12 +724,19 @@ public class GT_ModHandler { public static boolean addCompressionRecipe(ItemStack aInput, ItemStack aOutput) { aOutput = GT_OreDictUnificator.get(true, aOutput); if (aInput == null || aOutput == null) return false; - GT_Utility.removeSimpleIC2MachineRecipe(aInput, getCompressorRecipeList(), null); if (!GregTech_API.sRecipeFile.get(GT_ConfigCategories.Machines.compression, aInput, true)) return false; GT_Utility.addSimpleIC2MachineRecipe(aInput, getCompressorRecipeList(), null, aOutput); return true; } + public static boolean addCompressionRecipe(OreDictEntry aInput, int amount, ItemStack aOutput) { + aOutput = GT_OreDictUnificator.get(true, aOutput); + if (aInput == null || aOutput == null) return false; + if (!GregTech_API.sRecipeFile.get(GT_ConfigCategories.Machines.compression, aInput.oreDictName, true)) return false; + GT_Utility.addSimpleIC2MachineRecipe(RecipeEntry.fromStacks(amount, aInput.ores, Match.STRICT), getCompressorRecipeList(), null, aOutput); + return true; + } + /** * @param aValue Scrap = 5000, Scrapbox = 45000 * @param aAmplifiers stacks apply to diff --git a/src/main/java/gregtechmod/common/RecipeHandler.java b/src/main/java/gregtechmod/common/RecipeHandler.java index 0cd34b7..e5048c8 100644 --- a/src/main/java/gregtechmod/common/RecipeHandler.java +++ b/src/main/java/gregtechmod/common/RecipeHandler.java @@ -1,15 +1,24 @@ package gregtechmod.common; import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Objects; +import com.google.common.collect.Multimap; +import com.google.common.collect.Multimaps; + import gregtechmod.api.GregTech_API; import gregtechmod.api.util.GT_Log; import gregtechmod.api.util.GT_Utility; + +import ic2.api.recipe.IRecipeInput; +import ic2.api.recipe.RecipeOutput; + import net.minecraft.inventory.InventoryCrafting; import net.minecraft.item.ItemStack; import net.minecraft.item.crafting.CraftingManager; @@ -25,6 +34,9 @@ public class RecipeHandler { private static List craftingRemove; private static List smeltingRemove; + private static Multimap IC2Remove; + private static Map> IC2Mapping; + private static List onFinishTasks; ////////////////////// @@ -41,6 +53,14 @@ public class RecipeHandler { smeltingRemove.add(matcher); } + public static void scheduleIC2RecipeToRemove(Map recipeMap, IIC2Matcher matcher) { + Objects.requireNonNull(recipeMap); + Objects.requireNonNull(matcher); + int hash = System.identityHashCode(recipeMap); + IC2Mapping.put(hash, recipeMap); + IC2Remove.put(hash, matcher); + } + public static void executeOnFinish(Runnable runnable) { Objects.requireNonNull(runnable); onFinishTasks.add(runnable); @@ -100,6 +120,29 @@ public class RecipeHandler { GT_Log.log.info(String.format("\tCrafting processor finished for %.3f seconds", (System.currentTimeMillis() - time) / 1000.0F)); } + private static void processIC2() { + long time = System.currentTimeMillis(); + + for (Entry> recipeMap : IC2Remove.asMap().entrySet()) { + Collection tasks = new ArrayList<>(recipeMap.getValue()); + Iterator> iter = IC2Mapping.get(recipeMap.getKey()).entrySet().iterator(); + + while (iter.hasNext() && !tasks.isEmpty()) { + Entry entry = iter.next(); + Iterator iter2 = tasks.iterator(); + while (iter2.hasNext()) { + IIC2Matcher matcher = iter2.next(); + if (matcher.matches(entry.getKey(), entry.getValue())) { + iter.remove(); + iter2.remove(); + } + } + } + } + + GT_Log.log.info(String.format("\tIC2 Recipe processor finished for %.3f seconds", (System.currentTimeMillis() - time) / 1000.0F)); + } + /** * Called on POST to proceed all job */ @@ -108,11 +151,14 @@ public class RecipeHandler { processSmelting(); processCrafting(); + processIC2(); proceedTasks(); craftingRemove = null; smeltingRemove = null; onFinishTasks = null; + IC2Mapping = null; + IC2Remove = null; GT_Log.log.info(String.format("Recipe handler finished for %.3f seconds", (System.currentTimeMillis() - time) / 1000.0F)); } @@ -121,6 +167,9 @@ public class RecipeHandler { craftingRemove = new ArrayList<>(); smeltingRemove = new ArrayList<>(); onFinishTasks = new ArrayList<>(); + + IC2Remove = Multimaps.newListMultimap(new HashMap<>(), ArrayList::new); + IC2Mapping = new HashMap<>(); } /** @@ -160,6 +209,21 @@ public class RecipeHandler { } } + /** + * + * @author TheDarkDnKTv + * + */ + @FunctionalInterface + public static interface IIC2Matcher { + + /** + * + * Returns true if recipe matches some criteria + */ + boolean matches(IRecipeInput in, RecipeOutput out); + } + /** Standard implementation, default use case of IRecipeMatcher * @author TheDarkDnKTv * diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDust.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDust.java index 301f6bf..ba2d0f1 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDust.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDust.java @@ -196,18 +196,35 @@ public class ProcessingDust implements IOreRecipeRegistrator { ItemStack tStack = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L); - if (aMaterial.mBlastFurnaceRequired && null != tStack && !aMaterial.contains(SubTag.NO_SMELTING)) { - factory = RecipeMaps.BLAST_FURNANCE.factory() - .minTemperature(aMaterial.mBlastFurnaceTemp).EUt(120) - .duration(Math.max(aMaterial.getMass() / 40, 1) * aMaterial.mBlastFurnaceTemp) - .input(RecipeEntry.fromStacks(entry.ores, Match.STRICT)); - if (aMaterial.mBlastFurnaceTemp > 1750) - factory.output(GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial, tStack, 1)); - else - factory.output(tStack); - factory.buildAndRegister(); + if (!aMaterial.contains(SubTag.NO_SMELTING)) { + if (aMaterial.mBlastFurnaceRequired && null != tStack) { + factory = RecipeMaps.BLAST_FURNANCE.factory() + .minTemperature(aMaterial.mBlastFurnaceTemp).EUt(120) + .duration(Math.max(aMaterial.getMass() / 40, 1) * aMaterial.mBlastFurnaceTemp) + .input(RecipeEntry.fromStacks(entry.ores, Match.STRICT)); + if (aMaterial.mBlastFurnaceTemp > 1750) + factory.output(GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial, tStack, 1)); + else + factory.output(tStack); + factory.buildAndRegister(); + } + } else { + if (!OrePrefixes.block.isIgnored(aMaterial) && null == GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) { + RecipeHandler.scheduleIC2RecipeToRemove(GT_ModHandler.getCompressorRecipeList(), (in, out) -> in.matches(entry.ores.get(0))); + RecipeHandler.executeOnFinish(() -> GT_ModHandler.addCompressionRecipe(entry, 1, GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L))); + } + + if ((OrePrefixes.block.isIgnored(aMaterial) + || null == GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)) + && aMaterial != Materials.GraniteRed && aMaterial != Materials.GraniteBlack + && aMaterial != Materials.Obsidian && aMaterial != Materials.Glowstone + && aMaterial != Materials.Paper) { + RecipeHandler.scheduleIC2RecipeToRemove(GT_ModHandler.getCompressorRecipeList(), (in, out) -> in.matches(GT_Utility.copyAmount(9, entry.ores.get(0)))); + RecipeHandler.executeOnFinish(() -> GT_ModHandler.addCompressionRecipe(entry, 1, GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L))); + } } + for (ItemStack aStack : entry.ores) { if (null != tStack && !aMaterial.contains(SubTag.NO_SMELTING)) { if (aMaterial.mBlastFurnaceRequired) { @@ -219,18 +236,6 @@ public class ProcessingDust implements IOreRecipeRegistrator { } else { RecipeHandler.executeOnFinish(() -> GT_ModHandler.addSmeltingRecipe(aStack, tStack)); } - } else { - if (!OrePrefixes.block.isIgnored(aMaterial) && null == GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L)) { - GT_ModHandler.addCompressionRecipe(GT_Utility.copyAmount(9, aStack), GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)); - } - - if ((OrePrefixes.block.isIgnored(aMaterial) - || null == GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)) - && aMaterial != Materials.GraniteRed && aMaterial != Materials.GraniteBlack - && aMaterial != Materials.Obsidian && aMaterial != Materials.Glowstone - && aMaterial != Materials.Paper) { - GT_ModHandler.addCompressionRecipe(GT_Utility.copyAmount(1, aStack), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)); - } } switch (aMaterial) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGem.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGem.java index 2ca1fdc..9585c5e 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGem.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGem.java @@ -12,7 +12,6 @@ import gregtechmod.api.interfaces.IOreRecipeRegistrator; import gregtechmod.api.recipe.RecipeFactory; import gregtechmod.api.util.GT_ModHandler; import gregtechmod.api.util.GT_OreDictUnificator; -import gregtechmod.api.util.GT_RecipeRegistrator; import gregtechmod.api.util.GT_Utility; import gregtechmod.api.util.OreDictEntry; @@ -84,23 +83,20 @@ public class ProcessingGem implements IOreRecipeRegistrator { .buildAndRegister(); } - for (ItemStack stack : entry.ores) { // FIXME cause real load lag - if (!OrePrefixes.block.isIgnored(aMaterial)) { - GT_ModHandler.addCompressionRecipe(GT_Utility.copyAmount(9, stack), GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)); - } - + if (!OrePrefixes.block.isIgnored(aMaterial)) { + ItemStack a = entry.ores.get(0); + + if (GT_ModHandler.getRecipeOutput(a, a, a, a, a, a, a, a, a) != null) + if (!GregTech_API.sRecipeFile.get(GT_ConfigCategories.Recipes.storageblockcrafting, OrePrefixes.block.get(aMaterial), false)) + RecipeHandler.scheduleCraftingToRemove(new RecipeHandler.InventoryRecipeMatcher(false, a, a, a, a, a, a, a, a, a)); + RecipeHandler.scheduleIC2RecipeToRemove(GT_ModHandler.getCompressorRecipeList(), (in, out) -> in.matches(entry.ores.get(0))); + RecipeHandler.executeOnFinish(() -> GT_ModHandler.addCompressionRecipe(entry, 9, GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L))); + } + + for (ItemStack stack : entry.ores) { if (!aMaterial.contains(SubTag.NO_SMELTING)) { RecipeHandler.executeOnFinish(() -> GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1, stack), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L))); } - - ItemStack tStack; - if (null != (tStack = GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L))) { - GT_RecipeRegistrator.registerUsagesForMaterials(GT_Utility.copyAmount(1, stack), - GT_Utility.copyAmount(1L, new Object[] { tStack }), (String) null, false, true, false); - } else { - GT_RecipeRegistrator.registerUsagesForMaterials(GT_Utility.copyAmount(1, stack), - GT_Utility.copyAmount(1, stack), (String) null, false, true, false); - } } } }