diff --git a/src/main/java/gregtechmod/api/enums/Materials.java b/src/main/java/gregtechmod/api/enums/Materials.java index 8bbe202..83f43a6 100644 --- a/src/main/java/gregtechmod/api/enums/Materials.java +++ b/src/main/java/gregtechmod/api/enums/Materials.java @@ -861,8 +861,11 @@ public enum Materials { } public static Materials get(String aMaterialName) { - Object tObject = GT_Utility.getFieldContent(Materials.class, aMaterialName, false, false); - if (tObject != null && tObject instanceof Materials) return (Materials)tObject; + try { + Materials result = Materials.valueOf(aMaterialName); + if (result != null) return result; + } catch (IllegalArgumentException e) {} + return exceptions.containsKey(aMaterialName) ? exceptions.get(aMaterialName) : _NULL; } diff --git a/src/main/java/gregtechmod/api/enums/OrePrefixes.java b/src/main/java/gregtechmod/api/enums/OrePrefixes.java index dcbd43e..5697cff 100644 --- a/src/main/java/gregtechmod/api/enums/OrePrefixes.java +++ b/src/main/java/gregtechmod/api/enums/OrePrefixes.java @@ -302,7 +302,7 @@ public enum OrePrefixes { public final boolean mIsUnificatable, mIsMaterialBased, mIsSelfReferencing, mIsContainer, mDontUnificateActively; public OrePrefixes mPrefixInto = this; private final ArrayList mNotGeneratedItems = new ArrayList(), mIgnoredMaterials = new ArrayList(); - private final ArrayList mOreProcessing = new ArrayList(); + public final ArrayList mOreProcessing = new ArrayList(); /** * Used to determine the amount of Material this Prefix contains. @@ -353,8 +353,11 @@ public enum OrePrefixes { } public static OrePrefixes getPrefix(String aPrefixName, OrePrefixes aReplacement) { - Object tObject = GT_Utility.getFieldContent(OrePrefixes.class, aPrefixName, false, false); - if (tObject != null && tObject instanceof OrePrefixes) return (OrePrefixes)tObject; + try { + OrePrefixes value = OrePrefixes.valueOf(aPrefixName); + if (value != null) return value; + } catch (IllegalArgumentException e) {} + return aReplacement; } diff --git a/src/main/java/gregtechmod/api/util/GT_ModHandler.java b/src/main/java/gregtechmod/api/util/GT_ModHandler.java index 0e7b5ce..f10a8ed 100644 --- a/src/main/java/gregtechmod/api/util/GT_ModHandler.java +++ b/src/main/java/gregtechmod/api/util/GT_ModHandler.java @@ -14,7 +14,6 @@ import ic2.api.recipe.RecipeOutput; import java.lang.reflect.Method; import java.util.*; import java.util.Map.Entry; - import net.minecraft.block.Block; import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.player.EntityPlayer; @@ -334,12 +333,16 @@ public class GT_ModHandler { * Just simple Furnace smelting. Unbelievable how Minecraft fails at making a simple ItemStack->ItemStack mapping... */ @SuppressWarnings("deprecation") - public static boolean addSmeltingRecipe(ItemStack aInput, ItemStack aOutput) { + public static synchronized boolean addSmeltingRecipe(ItemStack aInput, ItemStack aOutput) { aOutput = GT_OreDictUnificator.get(true, aOutput); if (aInput == null || aOutput == null) return false; if (aInput.getItem().hasContainerItem()) return false; if (!GregTech_API.sRecipeFile.get(GT_ConfigCategories.Machines.smelting, aInput, true)) return false; - FurnaceRecipes.smelting().func_151394_a(aInput.copy(), aOutput.copy(), 0.0F); + Map recipes = FurnaceRecipes.smelting().getSmeltingList(); + synchronized (recipes) { + FurnaceRecipes.smelting().func_151394_a(aInput.copy(), aOutput.copy(), 0.0F); + } + return true; } @@ -490,7 +493,7 @@ public class GT_ModHandler { /** * Adds Several Pulverizer-Type Recipes. */ - public static boolean addPulverisationRecipe(ItemStack aInput, ItemStack aOutput1, ItemStack aOutput2, int aChance, boolean aOverwrite) { + public static synchronized boolean addPulverisationRecipe(ItemStack aInput, ItemStack aOutput1, ItemStack aOutput2, int aChance, boolean aOverwrite) { aOutput1 = GT_OreDictUnificator.get(true, aOutput1); aOutput2 = GT_OreDictUnificator.get(true, aOutput2); if (aInput == null || aOutput1 == null) return false; @@ -538,15 +541,15 @@ public class GT_ModHandler { /** * Adds a Recipe to the Sawmills of GregTech and ThermalCraft */ - public static boolean addSawmillRecipe(ItemStack aInput1, ItemStack aOutput1, ItemStack aOutput2) { + public static synchronized boolean addSawmillRecipe(ItemStack aInput1, ItemStack aOutput1, ItemStack aOutput2) { return addSawmillRecipe(aInput1, aOutput1, aOutput2, 160); } - public static boolean addSawmillRecipe(ItemStack aInput1, ItemStack aOutput1, ItemStack aOutput2, int aRF) { + public static synchronized boolean addSawmillRecipe(ItemStack aInput1, ItemStack aOutput1, ItemStack aOutput2, int aRF) { return addSawmillRecipe(aInput1, aOutput1, aOutput2, aRF, 100); } - public static boolean addSawmillRecipe(ItemStack aInput1, ItemStack aOutput1, ItemStack aOutput2, int aRF, int aChance) { + public static synchronized boolean addSawmillRecipe(ItemStack aInput1, ItemStack aOutput1, ItemStack aOutput2, int aRF, int aChance) { aOutput1 = GT_OreDictUnificator.get(true, aOutput1); aOutput2 = GT_OreDictUnificator.get(true, aOutput2); if (aInput1 == null || aOutput1 == null) return false; @@ -692,7 +695,7 @@ public class GT_ModHandler { /** * @param aValue Scrap = 5000, Scrapbox = 45000, Diamond Dust 125000 */ - public static boolean addIC2MatterAmplifier(ItemStack aAmplifier, int aValue) { + public static synchronized boolean addIC2MatterAmplifier(ItemStack aAmplifier, int aValue) { if (aAmplifier == null || aValue <= 0) return false; if (!GregTech_API.sRecipeFile.get(GT_ConfigCategories.Machines.massfabamplifier, aAmplifier, true)) return false; try { @@ -909,7 +912,7 @@ public class GT_ModHandler { /** * Removes a Smelting Recipe */ - public static boolean removeFurnaceSmelting(ItemStack aInput) { + public static synchronized boolean removeFurnaceSmelting(ItemStack aInput) { if (aInput != null) { FurnaceRecipes.smelting().getSmeltingList().remove(aInput); return true; @@ -961,7 +964,7 @@ public class GT_ModHandler { * @param aOutput The output of the Recipe. * @return if it has removed at least one Recipe. */ - public static boolean removeRecipeByOutput(ItemStack aOutput) { + public static synchronized boolean removeRecipeByOutput(ItemStack aOutput) { if (aOutput == null) return false; boolean rReturn = false; @SuppressWarnings("unchecked") @@ -1126,9 +1129,9 @@ public class GT_ModHandler { * Gives you a list of the Outputs from a Crafting Recipe * If you have multiple Mods, which add Bronze Armor for example */ - @SuppressWarnings("unchecked") - public static ArrayList getRecipeOutputs(ItemStack... aRecipe) { - return getRecipeOutputs(CraftingManager.getInstance().getRecipeList(), false, aRecipe); + @SuppressWarnings("unchecked") + public static synchronized List getRecipeOutputs(ItemStack... aRecipe) { + return getRecipeOutputs(CraftingManager.getInstance().getRecipeList(), false, aRecipe); } /** @@ -1153,7 +1156,9 @@ public class GT_ModHandler { temp = false; try { temp = aList.get(i).matches(aCrafting, GregTech_API.sDummyWorld); - } catch(Throwable e) {GT_Log.log.catching(e);} + } catch(Throwable e) { + if (!(e instanceof NullPointerException)) GT_Log.log.catching(e); + } if (temp) { ItemStack tOutput = aList.get(i).getCraftingResult(aCrafting); if (tOutput == null || tOutput.stackSize <= 0) { @@ -1192,9 +1197,9 @@ public class GT_ModHandler { /** * Used in my own Furnace. */ - public static ItemStack getSmeltingOutput(ItemStack aInput, boolean aRemoveInput, ItemStack aOutputSlot) { + public static synchronized ItemStack getSmeltingOutput(ItemStack aInput, boolean aRemoveInput, ItemStack aOutputSlot) { if (aInput == null) return null; - ItemStack rStack = GT_OreDictUnificator.get(FurnaceRecipes.smelting().getSmeltingResult(aInput)); + ItemStack rStack = GT_OreDictUnificator.get(getSmeltingResult(aInput)); if (rStack != null && (aOutputSlot == null || (GT_Utility.areStacksEqual(rStack, aOutputSlot) && rStack.stackSize + aOutputSlot.stackSize <= aOutputSlot.getMaxStackSize()))) { if (aRemoveInput) aInput.stackSize--; return rStack; @@ -1202,6 +1207,21 @@ public class GT_ModHandler { return null; } + public static synchronized ItemStack getSmeltingResult(ItemStack aInput) { + @SuppressWarnings("unchecked") + Map recipes = FurnaceRecipes.smelting().getSmeltingList(); + synchronized (recipes) { + for (Entry entry : recipes.entrySet()) { + ItemStack value = entry.getKey(); + if (value.getItem() == aInput.getItem() && (aInput.getItemDamage() == 32767 || value.getItemDamage() == aInput.getItemDamage())) { + return entry.getValue(); + } + } + } + + return null; + } + /** * Used in my own Machines. Decreases StackSize of the Input if wanted. * diff --git a/src/main/java/gregtechmod/api/util/GT_OreDictUnificator.java b/src/main/java/gregtechmod/api/util/GT_OreDictUnificator.java index f4f3204..11e6ae5 100644 --- a/src/main/java/gregtechmod/api/util/GT_OreDictUnificator.java +++ b/src/main/java/gregtechmod/api/util/GT_OreDictUnificator.java @@ -107,29 +107,29 @@ public class GT_OreDictUnificator { isAddingOre--; } - public static ItemStack getFirstOre(Object aName, long aAmount) { + public static synchronized ItemStack getFirstOre(Object aName, long aAmount) { if (GT_Utility.isStringInvalid(aName)) return null; if (GT_Utility.isStackValid(sName2OreMap.get(aName.toString()))) return GT_Utility.copyAmount(aAmount, sName2OreMap.get(aName.toString())); return GT_Utility.copyAmount(aAmount, getOres(aName).toArray(new ItemStack[0])); } - public static ItemStack get(Object aName, long aAmount) { + public static synchronized ItemStack get(Object aName, long aAmount) { return get(aName, null, aAmount, true, true); } - public static ItemStack get(Object aName, ItemStack aReplacement, long aAmount) { + public static synchronized ItemStack get(Object aName, ItemStack aReplacement, long aAmount) { return get(aName, aReplacement, aAmount, true, true); } - public static ItemStack get(OrePrefixes aPrefix, Object aMaterial, long aAmount) { + public static synchronized ItemStack get(OrePrefixes aPrefix, Object aMaterial, long aAmount) { return get(aPrefix, aMaterial, null, aAmount); } - public static ItemStack get(OrePrefixes aPrefix, Object aMaterial, ItemStack aReplacement, long aAmount) { + public static synchronized ItemStack get(OrePrefixes aPrefix, Object aMaterial, ItemStack aReplacement, long aAmount) { return get(aPrefix.get(aMaterial), aReplacement, aAmount, false, true); } - public static ItemStack get(Object aName, ItemStack aReplacement, long aAmount, boolean aMentionPossibleTypos, boolean aNoInvalidAmounts) { + public static synchronized ItemStack get(Object aName, ItemStack aReplacement, long aAmount, boolean aMentionPossibleTypos, boolean aNoInvalidAmounts) { if (aNoInvalidAmounts && aAmount < 1) return null; if (!sName2OreMap.containsKey(aName.toString()) && aMentionPossibleTypos) GT_Log.log.error("Unknown Key for Unification, Typo? " + aName); return GT_Utility.copyAmount(aAmount, sName2OreMap.get(aName.toString()), getFirstOre(aName, aAmount), aReplacement); @@ -246,14 +246,14 @@ public class GT_OreDictUnificator { /** * @return a Copy of the OreDictionary.getOres() List */ - public static ArrayList getOres(OrePrefixes aPrefix, Object aMaterial) { + public static synchronized ArrayList getOres(OrePrefixes aPrefix, Object aMaterial) { return getOres(aPrefix.get(aMaterial)); } /** * @return a Copy of the OreDictionary.getOres() List */ - public static ArrayList getOres(Object aOreName) { + public static synchronized ArrayList getOres(Object aOreName) { String aName = aOreName==null?"":aOreName.toString(); ArrayList rList = new ArrayList(); if (GT_Utility.isStringValid(aName)) rList.addAll(OreDictionary.getOres(aName)); diff --git a/src/main/java/gregtechmod/api/util/GT_RecipeRegistrator.java b/src/main/java/gregtechmod/api/util/GT_RecipeRegistrator.java index bfd8c6b..f8161dc 100644 --- a/src/main/java/gregtechmod/api/util/GT_RecipeRegistrator.java +++ b/src/main/java/gregtechmod/api/util/GT_RecipeRegistrator.java @@ -123,7 +123,6 @@ public class GT_RecipeRegistrator { * @param aBackSmelting allows to reverse smelt into aMat (false for Gems) * @param aBackMacerating allows to reverse macerate into aOutput */ - @SuppressWarnings("null") // And again it is too stupid to get, that it can't be null at that point... public static void registerUsagesForMaterials(ItemStack aMat, ItemStack aOutput, String aPlate, boolean aBackSmelting, boolean aBackMacerating, boolean aRecipeReplacing) { if (aMat == null || aOutput == null) return; aMat = GT_Utility.copy(aMat); @@ -155,13 +154,15 @@ public class GT_RecipeRegistrator { Items.feather.setDamage(sMt1, Items.feather.getDamage(aMat)); for (ItemStack[] tRecipe : sShapes1) { - int tAmount1 = 0; - for (ItemStack tMat : tRecipe) { - if (tMat == sMt1) tAmount1++; - } - for (ItemStack tCrafted : GT_ModHandler.getRecipeOutputs(tRecipe)) { - if (aBackMacerating) GT_ModHandler.addPulverisationRecipe(tCrafted, GT_Utility.copyAmount(tAmount1, aOutput), null, 0, false); - if (aBackSmelting) GT_ModHandler.addSmeltingAndAlloySmeltingRecipe(tCrafted, GT_Utility.copyAmount(tAmount1, tUnificated)); + if (tRecipe != null) { + int tAmount1 = 0; + for (ItemStack tMat : tRecipe) { + if (tMat == sMt1) tAmount1++; + } + for (ItemStack tCrafted : GT_ModHandler.getRecipeOutputs(tRecipe)) { + if (aBackMacerating) GT_ModHandler.addPulverisationRecipe(tCrafted, GT_Utility.copyAmount(tAmount1, aOutput), null, 0, false); + if (aBackSmelting) GT_ModHandler.addSmeltingAndAlloySmeltingRecipe(tCrafted, GT_Utility.copyAmount(tAmount1, tUnificated)); + } } } diff --git a/src/main/java/gregtechmod/api/util/OreDictEntry.java b/src/main/java/gregtechmod/api/util/OreDictEntry.java new file mode 100644 index 0000000..9465eda --- /dev/null +++ b/src/main/java/gregtechmod/api/util/OreDictEntry.java @@ -0,0 +1,25 @@ +package gregtechmod.api.util; + +import java.util.Objects; + +import net.minecraft.item.ItemStack; + +public class OreDictEntry { + public final ItemStack ore; + public final String oreDictName; + public final String modName; + + private OreDictEntry(ItemStack ore, String modName, String oreDictName) { + this.ore = ore; + this.modName = modName; + this.oreDictName = oreDictName; + } + + public static OreDictEntry create(ItemStack ore, String modName, String oreDictName) { + Objects.requireNonNull(ore); + Objects.requireNonNull(ore.getItem()); + if (GT_Utility.isStringInvalid(modName) || GT_Utility.isStringInvalid(oreDictName)) throw new IllegalArgumentException("Invalid string"); + + return new OreDictEntry(ore, modName, oreDictName); + } +} diff --git a/src/main/java/gregtechmod/common/GT_OreDictHandler.java b/src/main/java/gregtechmod/common/GT_OreDictHandler.java index 6607f93..f66505e 100644 --- a/src/main/java/gregtechmod/common/GT_OreDictHandler.java +++ b/src/main/java/gregtechmod/common/GT_OreDictHandler.java @@ -15,13 +15,18 @@ import gregtechmod.api.util.GT_OreDictUnificator; import gregtechmod.api.util.GT_Recipe; import gregtechmod.api.util.GT_RecipeRegistrator; import gregtechmod.api.util.GT_Utility; +import gregtechmod.api.util.OreDictEntry; + import java.util.ArrayList; import java.util.Arrays; -import java.util.HashMap; -import java.util.Iterator; import java.util.List; -import java.util.Map; -import java.util.Map.Entry; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.Multimap; +import com.google.common.util.concurrent.ThreadFactoryBuilder; + import cpw.mods.fml.common.Loader; import cpw.mods.fml.common.ModContainer; import cpw.mods.fml.common.ProgressManager; @@ -37,7 +42,7 @@ import net.minecraftforge.oredict.OreDictionary.OreRegisterEvent; public class GT_OreDictHandler { public static final GT_OreDictHandler instance = new GT_OreDictHandler(); - private final Map mEvents = new HashMap<>(); + private final List mEvents = new ArrayList<>(); private final List mIgnoredItems = Arrays.asList(new String[]{"itemRawRubber", "itemSilicon", "itemBacon", "itemJetpackAccelerator", "itemLazurite", "itemIridium", "itemTear", "itemClaw", "itemFertilizer", "itemTar", "itemSlimeball", "itemCoke", "itemBeeswax", "itemBeeQueen", "itemForcicium", "itemForcillium", "itemRoyalJelly", "itemHoneydew", "itemHoney", "itemPollen", "itemReedTypha", "itemSulfuricAcid", "itemPotash", "itemCompressedCarbon", "itemBitumen", "itemBioFuel", "itemCokeSugar", "itemCokeCactus", "itemCharcoalSugar", "itemCharcoalCactus", "itemSludge", "itemEnrichedAlloy", "itemQuicksilver", "itemMercury", "itemOsmium", "itemUltimateCircuit", "itemEnergizedStar", "itemAntimatterMolecule", "itemAntimatterGlob", "itemCoal", "itemBoat", "itemHerbalMedicineCake", "itemCakeSponge", "itemFishandPumpkinCakeSponge", "itemSoulCleaver", "itemInstantCake", "itemWhippingCream", "itemGlisteningWhippingCream", "itemCleaver", "itemHerbalMedicineWhippingCream", "itemStrangeWhippingCream", "itemBlazeCleaver", "itemBakedCakeSponge", "itemMagmaCake", "itemGlisteningCake", "itemOgreCleaver", "itemFishandPumpkinCake", "itemMagmaWhippingCream", "itemMultimeter", "itemSuperconductor"}); private final List mIgnoredNames = Arrays.asList(new String[]{"whiteStone", "stoneSlab", "clayBowl", "clayPlate", "ceramicBowl", "ceramicPlate", "ovenRack", "clayCup", "ceramicCup", "batteryBox", "transmutationStone", "torchRedstoneActive", "coal", "charcoal", "cloth", "cobblestoneSlab", "stoneBrickSlab", "cobblestoneWall", "stoneBrickWall", "cobblestoneStair", "stoneBrickStair", "blockCloud", "blockDirt", "blockTyrian", "blockCarpet", "blockFft", "blockLavastone", "blockHolystone", "blockConcrete", "sunnariumPart", "brSmallMachineCyaniteProcessor", "meteoriteCoal", "blockCobble", "pressOreProcessor", "crusherOreProcessor", "grinderOreProcessor", "blockRubber", "blockHoney", "blockHoneydew", "blockPeat", "blockRadioactive", "blockSlime", "blockCocoa", "blockSugarCane", "blockLeather", "blockClayBrick", "solarPanelHV", "cableRedNet", "stoneBowl", "crafterWood", "taintedSoil", "brickXyEngineering", "breederUranium", "wireMill", "chunkLazurite", "aluminumNatural", "aluminiumNatural", "naturalAluminum", "naturalAluminium", "antimatterMilligram", "antimatterGram", "strangeMatter", "coalGenerator", "electricFurnace", "unfinishedTank", "valvePart", "aquaRegia", "leatherSeal", "leatherSlimeSeal", "hambone", "slimeball", "enrichedUranium", "camoPaste"}); private final List mInvalidNames = Arrays.asList(new String[]{"bloodstoneOre", "universalCable", "bronzeTube", "ironTube", "netherTube", "obbyTube", "infiniteBattery", "eliteBattery", "advancedBattery", "10kEUStore", "blueDye", "MonazitOre", "quartzCrystal", "whiteLuminiteCrystal", "darkStoneIngot", "invisiumIngot", "demoniteOrb", "enderGem", "starconiumGem", "osmoniumIngot", "tapaziteGem", "zectiumIngot", "foolsRubyGem", "rubyGem", "meteoriteGem", "adamiteShard", "sapphireGem", "copperIngot", "ironStick", "goldStick", "diamondStick", "reinforcedStick", "draconicStick", "emeraldStick", "copperStick", "tinStick", "silverStick", "bronzeStick", "steelStick", "leadStick", "manyullynStick", "arditeStick", "cobaltStick", "aluminiumStick", "alumiteStick", "oilsandsOre", "copperWire", "superconductorWire", "sulfuricAcid", "conveyorBelt", "ironWire", "aluminumWire", "aluminiumWire", "silverWire", "tinWire", "dustSiliconSmall", "AluminumOre", "plateHeavyT2", "blockWool", "alloyPlateEnergizedHardened", "gasWood", "alloyPlateEnergized", "SilverOre", "LeadOre", "TinOre", "CopperOre", "silverOre", "leadOre", "tinOre", "copperOre", "bauxiteOre", "HSLivingmetalIngot", "oilMoving", "oilStill", "oilBucket", "petroleumOre", "dieselFuel", "diamondNugget", "planks", "wood", "stick", "sticks", "naquadah", "obsidianRod", "stoneRod", "thaumiumRod", "steelRod", "netherrackRod", "woodRod", "ironRod", "cactusRod", "flintRod", "copperRod", "cobaltRod", "alumiteRod", "blueslimeRod", "arditeRod", "manyullynRod", "bronzeRod", "boneRod", "slimeRod"}); @@ -482,7 +487,7 @@ public class GT_OreDictHandler { } GT_Log.ore.println(e); - this.mEvents.put(aEvent, aOriginalMod); + this.mEvents.add(OreDictEntry.create(aEvent.Ore, aOriginalMod, aEvent.Name)); if(this.mActivated) { this.registerRecipes(aEvent, aOriginalMod); } @@ -513,26 +518,73 @@ public class GT_OreDictHandler { public void activateHandler() { mActivated = true; long time = System.currentTimeMillis(); - ProgressBar bar = ProgressManager.push("Handling OreDict", mEvents.size(), false); - Iterator> iter = mEvents.entrySet().iterator(); + GT_Log.log.info("Splitting tasks"); + Multimap tasks = this.splitTasks(); + ExecutorService service = Executors.newFixedThreadPool(4, new ThreadFactoryBuilder().setDaemon(true).setNameFormat("GT-OreDictHandler-%d").build()); + ProgressBar bar = ProgressManager.push("Handling OreDict", tasks.keySet().size(), false); - while (iter.hasNext()) { - Entry temp = iter.next(); - String oreName = temp.getKey().Ore.getItem().getUnlocalizedName(); - - try { - oreName = temp.getKey().Ore.getDisplayName(); - } catch (Throwable e) {} - - bar.step(oreName); - this.registerRecipes(temp.getKey(), temp.getValue()); + for (OrePrefixes prefix : tasks.keySet()) { + service.submit(() -> { + try { + bar.step("prefix: " + prefix.toString()); + this.processTask(prefix, new ArrayList<>(tasks.get(prefix))); + } catch (Throwable e) { + GT_Log.log.throwing(e); + } + }); } - + + service.shutdown(); + while (!service.isTerminated()) { + try { + Thread.sleep(100); + } catch (InterruptedException e) {} + } + ProgressManager.pop(bar); mEvents.clear(); GT_Log.log.warn(String.format("Time spent for oredict iterating: %.3f seconds", (System.currentTimeMillis() - time) / 1000.0D)); } + private void processTask(OrePrefixes prefix, List items) { + for (OreDictEntry entry : items) { + Materials aMaterial = (prefix == null) ? Materials._NULL : OrePrefixes.getMaterial(entry.oreDictName, prefix); + if (prefix != null) { + if (!prefix.isIgnored(aMaterial)) { + long time = System.currentTimeMillis(); + prefix.processOre(aMaterial, entry.oreDictName, entry.modName, GT_Utility.copyAmount(1, entry.ore)); + double timeDiff = (System.currentTimeMillis() - time) / 1000.0D; + if (timeDiff > 0.8) GT_Log.log.warn(String.format("Too long execution for processor '%s': executed for: %.3f, tasks: %d", prefix.toString(), timeDiff, prefix.mOreProcessing.size())); + } + } + + } + } + + private Multimap splitTasks() { + Multimap tasks = ArrayListMultimap.create(); + + for (OreDictEntry entry : mEvents) { + OrePrefixes prefix = OrePrefixes.getOrePrefix(entry.oreDictName); + if (prefix != null) { + tasks.put(prefix, entry); + } else { + StringBuilder app = new StringBuilder(); + app.append("Thingy Name: "); + app.append(entry.modName); + app.append(":"); + app.append(entry.oreDictName); + app.append(" !!!Unknown 'Thingy' detected!!! "); + app.append("This Object seems to probably not follow a valid OreDictionary Convention, or I missed a Convention. "); + app.append("Please report to GregTech Intergalactical for additional compatiblity. "); + app.append("This is not an Error, it's just an Information."); + GT_Log.log.warn(app.toString()); + } + } + + return tasks; + } + public void registerRecipes(final OreDictionary.OreRegisterEvent aEvent, final String aMod) { if (aEvent.Ore == null || aEvent.Ore.getItem() == null) { return; @@ -557,34 +609,34 @@ public class GT_OreDictHandler { GregTech_API.sUnification.mConfig.save(); GregTech_API.sUnification.mConfig.load(); - for (Map.Entry tEvent : this.mEvents.entrySet()) { - if (tEvent.getKey().Ore.getItem() instanceof GT_MetaGenerated_Item) { - final OrePrefixes tPrefix = OrePrefixes.getOrePrefix(tEvent.getKey().Name); + for (OreDictEntry tEvent : this.mEvents) { + if (tEvent.ore.getItem() instanceof GT_MetaGenerated_Item) { + final OrePrefixes tPrefix = OrePrefixes.getOrePrefix(tEvent.oreDictName); if (tPrefix == null || !tPrefix.mIsUnificatable) { continue; } - GT_OreDictUnificator.addAssociation(tEvent.getKey().Name, tEvent.getKey().Ore); - if (GT_OreDictUnificator.isBlacklisted(tEvent.getKey().Ore)) { + GT_OreDictUnificator.addAssociation(tEvent.oreDictName, tEvent.ore); + if (GT_OreDictUnificator.isBlacklisted(tEvent.ore)) { continue; } - if (!tEvent.getValue().equals("UNKNOWN_MOD_ID") && GregTech_API.sUnification.get(GT_ConfigCategories.specialunificationtargets + "." + tEvent.getValue(), tEvent.getKey().Name, false)) { - GT_OreDictUnificator.set(tEvent.getKey().Name, tEvent.getKey().Ore, true, true); + if (!tEvent.modName.equals("UNKNOWN_MOD_ID") && GregTech_API.sUnification.get(GT_ConfigCategories.specialunificationtargets + "." + tEvent.modName, tEvent.oreDictName, false)) { + GT_OreDictUnificator.set(tEvent.oreDictName, tEvent.ore, true, true); } else { - GT_OreDictUnificator.set(tEvent.getKey().Name, tEvent.getKey().Ore, false, true); + GT_OreDictUnificator.set(tEvent.oreDictName, tEvent.ore, false, true); } } else { - final OrePrefixes tPrefix = OrePrefixes.getOrePrefix(tEvent.getKey().Name); + final OrePrefixes tPrefix = OrePrefixes.getOrePrefix(tEvent.oreDictName); if (tPrefix == null || !tPrefix.mIsUnificatable) { continue; } - GT_OreDictUnificator.addAssociation(tEvent.getKey().Name, tEvent.getKey().Ore); - if (GT_OreDictUnificator.isBlacklisted(tEvent.getKey().Ore)) { + GT_OreDictUnificator.addAssociation(tEvent.oreDictName, tEvent.ore); + if (GT_OreDictUnificator.isBlacklisted(tEvent.ore)) { continue; } - if (!tEvent.getValue().equals("UNKNOWN_MOD_ID") && GregTech_API.sUnification.get(GT_ConfigCategories.specialunificationtargets + "." + tEvent.getValue(), tEvent.getKey().Name, false)) { - GT_OreDictUnificator.set(tEvent.getKey().Name, tEvent.getKey().Ore, true, true); + if (!tEvent.modName.equals("UNKNOWN_MOD_ID") && GregTech_API.sUnification.get(GT_ConfigCategories.specialunificationtargets + "." + tEvent.modName, tEvent.oreDictName, false)) { + GT_OreDictUnificator.set(tEvent.oreDictName, tEvent.ore, true, true); } else { - GT_OreDictUnificator.set(tEvent.getKey().Name, tEvent.getKey().Ore, false, true); + GT_OreDictUnificator.set(tEvent.oreDictName, tEvent.ore, false, true); } } } diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot1.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot1.java index 235b83d..41848f7 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot1.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot1.java @@ -40,9 +40,10 @@ public class ProcessingIngot1 implements IOreRecipeRegistrator { GT_ModHandler.addCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.stick, (Object)aMaterial, 1L), new Object[]{"F", "I", Character.valueOf('F'), GT_ToolDictNames.craftingToolFile, Character.valueOf('I'), aOreDictName}); GregTech_API.sRecipeAdder.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.stick, (Object)aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustSmall, (Object)aMaterial, 2L), Math.max(aMaterial.getMass() * 5, 1), 16); - if(!aMaterial.contains(SubTag.NO_SMELTING) && GT_ModHandler.getSmeltingOutput(aStack, false, (ItemStack)null) == null && GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)aMaterial, 1L) != null && !GT_ModHandler.addSmeltingRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)aMaterial, 9L))) { - GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)aMaterial, 9L), new Object[]{aOreDictName}); - } + + if(!aMaterial.contains(SubTag.NO_SMELTING) && GT_ModHandler.getSmeltingOutput(aStack, false, (ItemStack)null) == null && GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)aMaterial, 1L) != null && !GT_ModHandler.addSmeltingRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)aMaterial, 9L))) { + GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)aMaterial, 9L), new Object[]{aOreDictName}); + } ItemStack tStack; if(null != (tStack = GT_OreDictUnificator.get(OrePrefixes.dust, (Object)aMaterial, 1L))) { @@ -58,6 +59,5 @@ public class ProcessingIngot1 implements IOreRecipeRegistrator { if(aMaterial == Materials.Mercury) { GT_Log.log.error("Quicksilver Ingots?, Don\'t tell me there is an Armor made of that highly toxic and very likely to be melting Material!"); } - } } diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLog.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLog.java index d9b7718..5fc18c8 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLog.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLog.java @@ -32,6 +32,7 @@ public class ProcessingLog implements IOreRecipeRegistrator { GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.dust, (Object)Materials.Wood, 6L), GT_OreDictUnificator.get(OrePrefixes.dust, (Object)Materials.Wood, 1L), 80, false); } + if(GregTech_API.sRecipeFile.get(GT_ConfigCategories.Recipes.disabledrecipes, "wood2charcoalsmelting", false) && GT_Utility.areStacksEqual(GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(1L, new Object[]{aStack}), false, (ItemStack)null), new ItemStack(Items.coal, 1, 1))) { GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1L, new Object[]{aStack})); }