% More Work on the GT Material System implementation.

5 files changed, 477 insertions, 9 deletions

diff --git a/src/Java/miscutil/core/common/CommonProxy.java b/src/Java/miscutil/core/common/CommonProxy.java
index 3197eaffca..1d67860537 100644
--- a/src/Java/miscutil/core/common/CommonProxy.java
+++ b/src/Java/miscutil/core/common/CommonProxy.java
@@ -1,6 +1,9 @@
 package miscutil.core.common;
 
 import static miscutil.core.lib.CORE.DEBUG;
+
+import java.util.Iterator;
+
 import miscutil.core.block.ModBlocks;
 import miscutil.core.creative.AddToCreativeTab;
 import miscutil.core.gui.ModGUI;
@@ -14,13 +17,32 @@ import miscutil.core.tileentities.ModTileEntities;
 import miscutil.core.util.Utils;
 import miscutil.core.util.debug.DEBUG_INIT;
 import miscutil.core.util.player.PlayerCache;
+import miscutil.gregtech.common.Meta_GT_Proxy;
+import net.minecraft.item.ItemStack;
 import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.oredict.OreDictionary;
+import cpw.mods.fml.common.FMLCommonHandler;
 import cpw.mods.fml.common.event.FMLInitializationEvent;
 import cpw.mods.fml.common.event.FMLPostInitializationEvent;
 import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import cpw.mods.fml.common.event.FMLServerStartingEvent;
 
 public class CommonProxy {
+	
+	public CommonProxy(){
+		//Should Register Gregtech Materials I've Made
+		MinecraftForge.EVENT_BUS.register(this);
+		FMLCommonHandler.instance().bus().register(this);
+		if (LoadedMods.Gregtech){
+			for (String tOreName : OreDictionary.getOreNames()) {
+				ItemStack tOreStack;
+				for (Iterator i$ = OreDictionary.getOres(tOreName).iterator(); i$.hasNext(); Meta_GT_Proxy.registerOre(new OreDictionary.OreRegisterEvent(tOreName, tOreStack))) {
+					Utils.LOG_INFO("Iterating Material");
+					tOreStack = (ItemStack) i$.next();
+				}
+			}
+		}
+	}
 
 	public void preInit(FMLPreInitializationEvent e) {
 		Utils.LOG_INFO("Doing some house cleaning.");		
diff --git a/src/Java/miscutil/gregtech/HANDLER_Gregtech.java b/src/Java/miscutil/gregtech/HANDLER_Gregtech.java
index 3fdb5aab63..c00013055d 100644
--- a/src/Java/miscutil/gregtech/HANDLER_Gregtech.java
+++ b/src/Java/miscutil/gregtech/HANDLER_Gregtech.java
@@ -3,9 +3,6 @@ package miscutil.gregtech;
 import gregtech.api.util.GT_Config;
 import miscutil.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
 import miscutil.gregtech.common.blocks.fluid.GregtechFluidHandler;
-import miscutil.gregtech.loaders.Processing_Block;
-import miscutil.gregtech.loaders.Processing_Ingot1;
-import miscutil.gregtech.loaders.Processing_Plate1;
 
 public class HANDLER_Gregtech {
 	
@@ -15,19 +12,30 @@ public class HANDLER_Gregtech {
 		if (mMaterialProperties != null){
 			GT_Materials.init(mMaterialProperties);
 			GregtechFluidHandler.run();
-			new Processing_Ingot1();
-			new Processing_Plate1();
-			new Processing_Block();
+			//new Processing_Ingot1();
+			//new Processing_Plate1();
+			//new Processing_Block();
 		}
 		
 	}
 	
 	public static void init(){
-		
+		/*if (Meta_GT_Proxy.mSortToTheEnd) {
+			new GT_ItemIterator().run();
+			Meta_GT_Proxy.registerUnificationEntries();
+			new GT_FuelLoader().run();
+		}*/
 	}
 	
 	public static void postInit(){
-		
+		/*Meta_GT_Proxy.activateOreDictHandler();
+		if (Meta_GT_Proxy.mSortToTheEnd) {
+			Meta_GT_Proxy.registerUnificationEntries();
+		} else {
+			new GT_ItemIterator().run();
+			Meta_GT_Proxy.registerUnificationEntries();
+			new GT_FuelLoader().run();
+		}*/
 	}
 	
 }
diff --git a/src/Java/miscutil/gregtech/api/objects/GregtechItemData.java b/src/Java/miscutil/gregtech/api/objects/GregtechItemData.java
new file mode 100644
index 0000000000..35c0eb2c74
--- /dev/null
+++ b/src/Java/miscutil/gregtech/api/objects/GregtechItemData.java
@@ -0,0 +1,130 @@
+package miscutil.gregtech.api.objects;
+
+import gregtech.api.objects.GT_ArrayList;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import miscutil.gregtech.api.enums.GregtechOrePrefixes;
+import miscutil.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import net.minecraft.item.ItemStack;
+
+public class GregtechItemData {
+    private static final GregtechMaterialStack[] EMPTY_GT_MaterialStack_ARRAY = new GregtechMaterialStack[0];
+
+    public final List<Object> mExtraData = new GT_ArrayList<Object>(false, 1);
+    public final GregtechOrePrefixes mPrefix;
+    public final GregtechMaterialStack mMaterial;
+    public final GregtechMaterialStack[] mByProducts;
+    public boolean mBlackListed = false;
+    public ItemStack mUnificationTarget = null;
+
+    public GregtechItemData(GregtechOrePrefixes aPrefix, GT_Materials aMaterial, boolean aBlackListed) {
+        mPrefix = aPrefix;
+        mMaterial = aMaterial == null ? null : new GregtechMaterialStack(aMaterial, aPrefix.mMaterialAmount);
+        mBlackListed = aBlackListed;
+        mByProducts = aPrefix.mSecondaryMaterial == null || aPrefix.mSecondaryMaterial.mMaterial == null ? EMPTY_GT_MaterialStack_ARRAY : new GregtechMaterialStack[]{aPrefix.mSecondaryMaterial.clone()};
+    }
+
+    public GregtechItemData(GregtechOrePrefixes aPrefix, GT_Materials aMaterial) {
+        this(aPrefix, aMaterial, false);
+    }
+
+    public GregtechItemData(GregtechMaterialStack aMaterial, GregtechMaterialStack... aByProducts) {
+        mPrefix = null;
+        mMaterial = aMaterial.mMaterial == null ? null : aMaterial.clone();
+        mBlackListed = true;
+        if (aByProducts == null) {
+            mByProducts = EMPTY_GT_MaterialStack_ARRAY;
+        } else {
+            GregtechMaterialStack[] tByProducts = aByProducts.length < 1 ? EMPTY_GT_MaterialStack_ARRAY : new GregtechMaterialStack[aByProducts.length];
+            int j = 0;
+            for (int i = 0; i < aByProducts.length; i++)
+                if (aByProducts[i] != null && aByProducts[i].mMaterial != null)
+                    tByProducts[j++] = aByProducts[i].clone();
+            mByProducts = j > 0 ? new GregtechMaterialStack[j] : EMPTY_GT_MaterialStack_ARRAY;
+            for (int i = 0; i < mByProducts.length; i++) mByProducts[i] = tByProducts[i];
+        }
+    }
+
+    public GregtechItemData(GT_Materials aMaterial, long aAmount, GregtechMaterialStack... aByProducts) {
+        this(new GregtechMaterialStack(aMaterial, aAmount), aByProducts);
+    }
+
+    public GregtechItemData(GT_Materials aMaterial, long aAmount, GT_Materials aByProduct, long aByProductAmount) {
+        this(new GregtechMaterialStack(aMaterial, aAmount), new GregtechMaterialStack(aByProduct, aByProductAmount));
+    }
+
+    public GregtechItemData(GregtechItemData... aData) {
+        mPrefix = null;
+        mBlackListed = true;
+
+        ArrayList<GregtechMaterialStack> aList = new ArrayList<GregtechMaterialStack>(), rList = new ArrayList<GregtechMaterialStack>();
+
+        for (GregtechItemData tData : aData)
+            if (tData != null) {
+                if (tData.hasValidMaterialData() && tData.mMaterial.mAmount > 0) aList.add(tData.mMaterial.clone());
+                for (GregtechMaterialStack tMaterial : tData.mByProducts)
+                    if (tMaterial.mAmount > 0) aList.add(tMaterial.clone());
+            }
+
+        for (GregtechMaterialStack aMaterial : aList) {
+            boolean temp = true;
+            for (GregtechMaterialStack tMaterial : rList)
+                if (aMaterial.mMaterial == tMaterial.mMaterial) {
+                    tMaterial.mAmount += aMaterial.mAmount;
+                    temp = false;
+                    break;
+                }
+            if (temp) rList.add(aMaterial.clone());
+        }
+
+        Collections.sort(rList, new Comparator<GregtechMaterialStack>() {
+            @Override
+            public int compare(GregtechMaterialStack a, GregtechMaterialStack b) {
+                return a.mAmount == b.mAmount ? 0 : a.mAmount > b.mAmount ? -1 : +1;
+            }
+        });
+
+        if (rList.isEmpty()) {
+            mMaterial = null;
+        } else {
+            mMaterial = rList.get(0);
+            rList.remove(0);
+        }
+
+        mByProducts = rList.toArray(new GregtechMaterialStack[rList.size()]);
+    }
+
+    public boolean hasValidPrefixMaterialData() {
+        return mPrefix != null && mMaterial != null && mMaterial.mMaterial != null;
+    }
+
+    public boolean hasValidPrefixData() {
+        return mPrefix != null;
+    }
+
+    public boolean hasValidMaterialData() {
+        return mMaterial != null && mMaterial.mMaterial != null;
+    }
+
+    public ArrayList<GregtechMaterialStack> getAllGT_MaterialStacks() {
+        ArrayList<GregtechMaterialStack> rList = new ArrayList();
+        if (hasValidMaterialData()) rList.add(mMaterial);
+        rList.addAll(Arrays.asList(mByProducts));
+        return rList;
+    }
+
+    public GregtechMaterialStack getByProduct(int aIndex) {
+        return aIndex >= 0 && aIndex < mByProducts.length ? mByProducts[aIndex] : null;
+    }
+
+    @Override
+    public String toString() {
+        if (mPrefix == null || mMaterial == null || mMaterial.mMaterial == null) return "";
+        return mPrefix.name() + mMaterial.mMaterial.name();
+    }
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/gregtech/api/util/GregtechOreDictUnificator.java b/src/Java/miscutil/gregtech/api/util/GregtechOreDictUnificator.java
index 60b8be6dcd..6f24217110 100644
--- a/src/Java/miscutil/gregtech/api/util/GregtechOreDictUnificator.java
+++ b/src/Java/miscutil/gregtech/api/util/GregtechOreDictUnificator.java
@@ -12,6 +12,7 @@ import gregtech.api.objects.GT_ItemStack;
 import gregtech.api.util.GT_Log;
 import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_Utility;
+import gregtech.common.GT_Proxy.OreDictEventContainer;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -227,7 +228,7 @@ public class GregtechOreDictUnificator {
         return false;
     }
 
-    public static boolean registerOre(OrePrefixes aPrefix, Object aMaterial, ItemStack aStack) {
+    public static boolean registerOre(GregtechOrePrefixes aPrefix, Object aMaterial, ItemStack aStack) {
         return registerOre(aPrefix.get(aMaterial), aStack);
     }
 
@@ -357,4 +358,9 @@ public class GregtechOreDictUnificator {
         if (GT_Utility.isStringValid(aName)) rList.addAll(OreDictionary.getOres(aName));
         return rList;
     }
+
+	public static void registerRecipes(OreDictEventContainer tOre) {
+		// TODO Auto-generated method stub
+		
+	}
 }
diff --git a/src/Java/miscutil/gregtech/common/Meta_GT_Proxy.java b/src/Java/miscutil/gregtech/common/Meta_GT_Proxy.java
index 059a13d914..14e16c06d2 100644
--- a/src/Java/miscutil/gregtech/common/Meta_GT_Proxy.java
+++ b/src/Java/miscutil/gregtech/common/Meta_GT_Proxy.java
@@ -1,19 +1,88 @@
 package miscutil.gregtech.common;
 
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ConfigCategories;
 import gregtech.api.enums.Dyes;
 import gregtech.api.enums.GT_Values;
 import gregtech.api.util.GT_LanguageManager;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+
+import miscutil.core.lib.CORE;
+import miscutil.gregtech.api.enums.GregtechOrePrefixes;
 import miscutil.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
 import miscutil.gregtech.api.objects.GregtechFluid;
+import miscutil.gregtech.api.util.GregtechOreDictUnificator;
+import miscutil.gregtech.api.util.GregtechRecipeRegistrator;
+import miscutil.gregtech.common.items.MetaGeneratedGregtechItems;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fluids.FluidContainerRegistry;
 import net.minecraftforge.fluids.FluidRegistry;
 import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 
 public class Meta_GT_Proxy {
 
+	//Silly Vars
+	private static final Collection<String> mIgnoredItems = new HashSet(Arrays.asList(new String[]{"itemGhastTear", "itemFlint", "itemClay", "itemBucketSaltWater",
+			"itemBucketFreshWater", "itemBucketWater", "itemRock", "itemReed", "itemArrow", "itemSaw", "itemKnife", "itemHammer", "itemChisel", "itemRubber",
+			"itemEssence", "itemIlluminatedPanel", "itemSkull", "itemRawRubber", "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 static final Collection<String> mIgnoredNames = new HashSet(Arrays.asList(new String[]{"grubBee", "chainLink", "candyCane", "bRedString", "bVial",
+			"bFlask", "anorthositeSmooth", "migmatiteSmooth", "slateSmooth", "travertineSmooth", "limestoneSmooth", "orthogneissSmooth", "marbleSmooth",
+			"honeyDrop", "lumpClay", "honeyEqualssugar", "flourEqualswheat", "bluestoneInsulated", "blockWaterstone", "blockSand", "blockTorch",
+			"blockPumpkin", "blockClothRock", "blockStainedHardenedClay", "blockQuartzPillar", "blockQuartzChiselled", "blockSpawner", "blockCloth", "mobHead",
+			"mobEgg", "enderFlower", "enderChest", "clayHardened", "dayGemMaterial", "nightGemMaterial", "snowLayer", "bPlaceholder", "hardenedClay",
+			"eternalLifeEssence", "sandstone", "wheatRice", "transdimBlock", "bambooBasket", "lexicaBotania", "livingwoodTwig", "redstoneCrystal",
+			"pestleAndMortar", "glowstone", "whiteStone", "stoneSlab", "transdimBlock", "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", "clay", "enrichedUranium", "camoPaste",
+			"antiBlock", "burntQuartz", "salmonRaw", "blockHopper", "blockEnderObsidian", "blockIcestone", "blockMagicWood", "blockEnderCore", "blockHeeEndium",
+			"oreHeeEndPowder", "oreHeeStardust", "oreHeeIgneousRock", "oreHeeInstabilityOrb", "crystalPureFluix", "shardNether", "gemFluorite",
+			"stickObsidian", "caveCrystal", "shardCrystal", "dyeCrystal","shardFire","shardWater","shardAir","shardEarth","ingotRefinedIron","blockMarble","ingotUnstable"}));
+	private static final Collection<String> mInvalidNames = new HashSet(Arrays.asList(new String[]{"diamondShard", "redstoneRoot", "obsidianStick", "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", "redalloyBundled", "bluestoneBundled", "infusedteslatiteInsulated",
+			"redalloyInsulated", "infusedteslatiteBundled"}));
+	public static boolean mOreDictActivated = false;
+	public static boolean mSortToTheEnd = true;
+	public final static HashSet<ItemStack> mRegisteredOres = new HashSet(10000);
+	public final static Collection<GregtechOreDictEventContainer> mEvents = new HashSet();
+
 	public static Fluid addFluid(String aName, String aLocalized, GT_Materials aMaterial, int aState, int aTemperatureK) {
 		return addFluid(aName, aLocalized, aMaterial, aState, aTemperatureK, null, null, 0);
 	}
@@ -80,5 +149,238 @@ public class Meta_GT_Proxy {
 		}
 		return rFluid;
 	}
+
+	@SubscribeEvent
+	public static void registerOre(OreDictionary.OreRegisterEvent aEvent) {
+		ModContainer tContainer = Loader.instance().activeModContainer();
+		String aMod = tContainer == null ? "UNKNOWN" : tContainer.getModId();
+		String aOriginalMod = aMod;
+		if (GregtechOreDictUnificator.isRegisteringOres()) {
+			aMod = CORE.MODID;
+		} else if (aMod.equals(CORE.MODID)) {
+			aMod = "UNKNOWN";
+		}
+		if ((aEvent == null) || (aEvent.Ore == null) || (aEvent.Ore.getItem() == null) || (aEvent.Name == null) || (aEvent.Name.isEmpty())
+				|| (aEvent.Name.replaceAll("_", "").length() - aEvent.Name.length() == 9)) {
+			if (aOriginalMod.equals(CORE.MODID)) {
+				aOriginalMod = "UNKNOWN";
+			}
+			GT_Log.ore
+			.println(aOriginalMod
+					+ " did something very bad! The registration is too invalid to even be shown properly. This happens only if you register null, invalid Items, empty Strings or even nonexisting Events to the OreDict.");
+			throw new IllegalArgumentException(
+					aOriginalMod
+					+ " did something very bad! The registration is too invalid to even be shown properly. This happens only if you register null, invalid Items, empty Strings or even nonexisting Events to the OreDict.");
+		}
+		try {
+			aEvent.Ore.stackSize = 1;
+
+			String tModToName = aMod + " -> " + aEvent.Name;
+			if ((mOreDictActivated) || (GregTech_API.sPostloadStarted) || ((mSortToTheEnd) && (GregTech_API.sLoadFinished))) {
+				tModToName = aOriginalMod + " --Late--> " + aEvent.Name;
+			}
+			if (((aEvent.Ore.getItem() instanceof ItemBlock)) || (GT_Utility.getBlockFromStack(aEvent.Ore) != Blocks.air)) {
+				GregtechOreDictUnificator.addToBlacklist(aEvent.Ore);
+			}
+			mRegisteredOres.add(aEvent.Ore);			
+			if (mIgnoredNames.contains(aEvent.Name)) {
+				GT_Log.ore.println(tModToName + " is getting ignored via hardcode.");
+				return;
+			}
+			if ((aEvent.Name.contains("|")) || (aEvent.Name.contains("*")) || (aEvent.Name.contains(":")) || (aEvent.Name.contains("."))
+					|| (aEvent.Name.contains("$"))) {
+				GT_Log.ore.println(tModToName + " is using a private Prefix and is therefor getting ignored properly.");
+				return;
+			}
+			if (aEvent.Name.contains(" ")) {
+				GT_Log.ore.println(tModToName + " is getting re-registered because the OreDict Name containing invalid spaces.");
+				GregtechOreDictUnificator.registerOre(aEvent.Name.replaceAll(" ", ""), GT_Utility.copyAmount(1L, new Object[]{aEvent.Ore}));
+				aEvent.Ore.setStackDisplayName("Invalid OreDictionary Tag");
+				return;
+			}
+			if (mInvalidNames.contains(aEvent.Name)) {
+				GT_Log.ore.println(tModToName + " is wrongly registered and therefor getting ignored.");
+
+				return;
+			}
+			GregtechOrePrefixes aPrefix = GregtechOrePrefixes.getOrePrefix(aEvent.Name);
+			GT_Materials aMaterial = GT_Materials._NULL;			
+			if (aPrefix == null) {
+				if (aEvent.Name.toLowerCase().equals(aEvent.Name)) {
+					GT_Log.ore.println(tModToName + " is invalid due to being solely lowercased.");
+					return;
+				}
+				if (aEvent.Name.toUpperCase().equals(aEvent.Name)) {
+					GT_Log.ore.println(tModToName + " is invalid due to being solely uppercased.");
+					return;
+				}
+				if (Character.isUpperCase(aEvent.Name.charAt(0))) {
+					GT_Log.ore.println(tModToName + " is invalid due to the first character being uppercased.");
+				}
+			} else {
+				if (aPrefix.mDontUnificateActively) {
+					GregtechOreDictUnificator.addToBlacklist(aEvent.Ore);
+				}
+				if (aPrefix != aPrefix.mPrefixInto) {
+					String tNewName = aEvent.Name.replaceFirst(aPrefix.toString(), aPrefix.mPrefixInto.toString());
+					if (!GregtechOreDictUnificator.isRegisteringOres()) {
+						GT_Log.ore.println(tModToName + " uses a depricated Prefix, and is getting re-registered as " + tNewName);
+					}
+					GregtechOreDictUnificator.registerOre(tNewName, aEvent.Ore);
+					return;
+				}
+				String tName = aEvent.Name.replaceFirst(aPrefix.toString(), "");
+				if (tName.length() > 0) {
+					char firstChar = tName.charAt(0);
+					if (Character.isUpperCase(firstChar) || Character.isLowerCase(firstChar) || firstChar == '_') {
+						if (aPrefix.mIsMaterialBased) {
+							aMaterial = GT_Materials.get(tName);
+							if (aMaterial != aMaterial.mMaterialInto) {
+								GregtechOreDictUnificator.registerOre(aPrefix, aMaterial.mMaterialInto, aEvent.Ore);
+								if (!GregtechOreDictUnificator.isRegisteringOres()) {
+									GT_Log.ore.println(tModToName + " uses a deprecated Material and is getting re-registered as "
+											+ aPrefix.get(aMaterial.mMaterialInto));
+								}
+								return;
+							}
+							if (!aPrefix.isIgnored(aMaterial)) {
+								aPrefix.add(GT_Utility.copyAmount(1L, new Object[]{aEvent.Ore}));
+							}
+							if (aMaterial != GT_Materials._NULL) {
+								GT_Materials tReRegisteredMaterial;
+								for (Iterator i$ = aMaterial.mOreReRegistrations.iterator(); i$.hasNext(); GregtechOreDictUnificator.registerOre(aPrefix,
+										tReRegisteredMaterial, aEvent.Ore)) {
+									tReRegisteredMaterial = (GT_Materials) i$.next();
+								}
+								aMaterial.add(GT_Utility.copyAmount(1L, new Object[]{aEvent.Ore}));								
+								switch (aPrefix) {								
+								case gem:								
+									break;
+								case plate:
+									break;								
+								case stick:
+									if (!GregtechRecipeRegistrator.sRodMaterialList.contains(aMaterial)) {
+										GregtechRecipeRegistrator.sRodMaterialList.add(aMaterial);
+									}
+									break;
+								case dust:
+									break;
+								case ingot:								
+									break;
+								}
+								if (aPrefix.mIsUnificatable && !aMaterial.mUnificatable) {
+									return;
+								}
+							} else {
+								for (Dyes tDye : Dyes.VALUES) {
+									if (aEvent.Name.endsWith(tDye.name().replaceFirst("dye", ""))) {
+										GregtechOreDictUnificator.addToBlacklist(aEvent.Ore);
+										GT_Log.ore.println(tModToName + " Oh man, why the fuck would anyone need a OreDictified Color for this, that is even too much for GregTech... do not report this, this is just a random Comment about how ridiculous this is.");
+										return;
+									}
+								}
+								//								System.out.println("Material Name: "+aEvent.Name+ " !!!Unknown Material detected!!! Please report to GregTech Intergalactical for additional compatiblity. This is not an Error, an Issue nor a Lag Source, it is just an Information, which you should pass to me.");
+								//								GT_Log.ore.println(tModToName + " uses an unknown Material. Report this to GregTech.");
+								return;
+							}
+						} else {
+							aPrefix.add(GT_Utility.copyAmount(1L, new Object[]{aEvent.Ore}));
+						}
+					}
+				} else if (aPrefix.mIsSelfReferencing) {
+					aPrefix.add(GT_Utility.copyAmount(1L, new Object[]{aEvent.Ore}));
+				} else {
+					GT_Log.ore.println(tModToName + " uses a Prefix as full OreDict Name, and is therefor invalid.");
+					aEvent.Ore.setStackDisplayName("Invalid OreDictionary Tag");
+					return;
+				}
+			}
+			GT_Log.ore.println(tModToName);
+			GregtechOreDictEventContainer tOre = new GregtechOreDictEventContainer(aEvent, aPrefix, aMaterial, aMod);
+			if ((!mOreDictActivated) || (!GregTech_API.sUnificationEntriesRegistered)) {
+				mEvents.add(tOre);
+			} else {
+				mEvents.clear();
+			}
+			if (mOreDictActivated) {
+				registerRecipes(tOre);
+			}
+		} catch (Throwable e) {
+			e.printStackTrace(GT_Log.err);
+		}
+	}
+
+	private static final void registerRecipes(GregtechOreDictEventContainer tOre) {
+		if ((tOre.mEvent.Ore == null) || (tOre.mEvent.Ore.getItem() == null)) {
+			return;
+		}
+		if (tOre.mEvent.Ore.stackSize != 1) {
+			tOre.mEvent.Ore.stackSize = 1;
+		}
+		if (tOre.mPrefix != null) {
+			if (!tOre.mPrefix.isIgnored(tOre.mMaterial)) {
+				tOre.mPrefix.processOre((GT_Materials) (tOre.mMaterial == null ? GT_Materials._NULL : tOre.mMaterial), tOre.mEvent.Name, tOre.mModID,
+						GT_Utility.copyAmount(1L, new Object[]{tOre.mEvent.Ore}));
+			}
+		} else {
+			//			System.out.println("Thingy Name: "+ aOre.mEvent.Name+ " !!!Unknown 'Thingy' detected!!! This Object seems to probably not follow a valid OreDictionary Convention, or I missed a Convention. Please report to GregTech Intergalactical for additional compatiblity. This is not an Error, an Issue nor a Lag Source, it is just an Information, which you should pass to me.");
+		}
+	}
 	
+	public static void registerUnificationEntries() {
+		GregTech_API.sUnification.mConfig.save();
+		GregTech_API.sUnification.mConfig.load();
+		GregtechOreDictUnificator.resetUnificationEntries();
+		for (GregtechOreDictEventContainer tOre : mEvents) {
+			if ((!(tOre.mEvent.Ore.getItem() instanceof MetaGeneratedGregtechItems)) && (tOre.mPrefix != null) && (tOre.mPrefix.mIsUnificatable)
+					&& (tOre.mMaterial != null)) {
+				 if (GregtechOreDictUnificator.isBlacklisted(tOre.mEvent.Ore)) {
+					GregtechOreDictUnificator.addAssociation(tOre.mPrefix, tOre.mMaterial, tOre.mEvent.Ore, true);
+				} else {
+					GregtechOreDictUnificator.addAssociation(tOre.mPrefix, tOre.mMaterial, tOre.mEvent.Ore, false);
+					GregtechOreDictUnificator.set(tOre.mPrefix, tOre.mMaterial, tOre.mEvent.Ore, (tOre.mModID != null) && (GregTech_API.sUnification.get(ConfigCategories.specialunificationtargets + "." + tOre.mModID, tOre.mEvent.Name, false)), true);
+				}
+			}
+		}
+		for (GregtechOreDictEventContainer tOre : mEvents) {
+			if (((tOre.mEvent.Ore.getItem() instanceof MetaGeneratedGregtechItems)) && (tOre.mPrefix != null) && (tOre.mPrefix.mIsUnificatable)
+					&& (tOre.mMaterial != null)) {
+				if (GregtechOreDictUnificator.isBlacklisted(tOre.mEvent.Ore)) {
+					GregtechOreDictUnificator.addAssociation(tOre.mPrefix, tOre.mMaterial, tOre.mEvent.Ore, true);
+				} else {
+					GregtechOreDictUnificator.addAssociation(tOre.mPrefix, tOre.mMaterial, tOre.mEvent.Ore, false);
+					GregtechOreDictUnificator.set(tOre.mPrefix, tOre.mMaterial, tOre.mEvent.Ore, (tOre.mModID != null) &&
+							(GregTech_API.sUnification.get(ConfigCategories.specialunificationtargets + "." + tOre.mModID, tOre.mEvent.Name, false)), true);
+				}
+			}
+		}
+		GregTech_API.sUnificationEntriesRegistered = true;
+		GregTech_API.sUnification.mConfig.save();
+		GT_Recipe.reInit();
+	}
+
+	public static void activateOreDictHandler() {
+		mOreDictActivated = true;
+		GregtechOreDictEventContainer tEvent;
+		for (Iterator i$ = mEvents.iterator(); i$.hasNext(); registerRecipes(tEvent)) {
+			tEvent = (GregtechOreDictEventContainer) i$.next();
+		}
+	}
+
+
+	//Dunno
+	public static class GregtechOreDictEventContainer {
+		public final OreDictionary.OreRegisterEvent mEvent;
+		public final GregtechOrePrefixes mPrefix;
+		public final GT_Materials mMaterial;
+		public final String mModID;
+
+		public GregtechOreDictEventContainer(OreDictionary.OreRegisterEvent aEvent, GregtechOrePrefixes aPrefix, GT_Materials aMaterial, String aModID) {
+			this.mEvent = aEvent;
+			this.mPrefix = aPrefix;
+			this.mMaterial = aMaterial;
+			this.mModID = ((aModID == null) || (aModID.equals("UNKNOWN")) ? null : aModID);
+		}
+	}
+
 }