Merge pull request #627 from D-Cysteine/add-cracked-cells

Add cracked fluid cells

5 files changed, 211 insertions, 143 deletions

diff --git a/src/main/java/gregtech/api/enums/OrePrefixes.java b/src/main/java/gregtech/api/enums/OrePrefixes.java
index 3aaea29f28..606d12c832 100644
--- a/src/main/java/gregtech/api/enums/OrePrefixes.java
+++ b/src/main/java/gregtech/api/enums/OrePrefixes.java
@@ -1,6 +1,7 @@
 package gregtech.api.enums;
 
 import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableList;
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.TC_Aspects.TC_AspectStack;
 import gregtech.api.interfaces.ICondition;
@@ -319,8 +320,22 @@ public enum OrePrefixes {
     bars("Bars", "", "", false, false, false, false, false, false, false, false, false, false, 0, -1, 64, -1),
     bar("Bars", "", "", false, false, false, false, false, false, false, false, false, false, 0, -1, 64, -1),
 	toolHeadMallet("Mallet Heads", "", " Mallet Head", true, true, false, false, false, false, true, true, false, false, B[6], M * 6, 16, 127), // Reverse Head consisting out of 6 Ingots.
-	handleMallet("Mallet Handle", "", " Handle", true, true, false, false, false, false, true, true, false, false, B[1] | B[2], M / 2, 64, 126); // Reverse Stick made of half an Ingot. Introduced by Eloraam
-	
+	handleMallet("Mallet Handle", "", " Handle", true, true, false, false, false, false, true, true, false, false, B[1] | B[2], M / 2, 64, 126), // Reverse Stick made of half an Ingot. Introduced by Eloraam
+
+    // Cracked fluids
+    cellHydroCracked1("Cells", "Lightly Hydro-Cracked ", " Cell", true, true, true, true, false, false, false, true, false, false, 0, M * 1, 64, 30),
+    cellHydroCracked2("Cells", "Moderately Hydro-Cracked ", " Cell", true, true, true, true, false, false, false, true, false, false, 0, M * 1, 64, 30),
+    cellHydroCracked3("Cells", "Severely Hydro-Cracked ", " Cell", true, true, true, true, false, false, false, true, false, false, 0, M * 1, 64, 30),
+    cellSteamCracked1("Cells", "Lightly Steam-Cracked ", " Cell", true, true, true, true, false, false, false, true, false, false, 0, M * 1, 64, 30),
+    cellSteamCracked2("Cells", "Moderately Steam-Cracked ", " Cell", true, true, true, true, false, false, false, true, false, false, 0, M * 1, 64, 30),
+    cellSteamCracked3("Cells", "Severely Steam-Cracked ", " Cell", true, true, true, true, false, false, false, true, false, false, 0, M * 1, 64, 30);
+
+    public static final ImmutableList<OrePrefixes> CELL_TYPES =
+            ImmutableList.of(
+                    cell, cellMolten, cellPlasma,
+                    cellHydroCracked1, cellHydroCracked2, cellHydroCracked3,
+                    cellSteamCracked1, cellSteamCracked2, cellSteamCracked3);
+
     public static volatile int VERSION = 509;
 
     static {
@@ -528,9 +543,7 @@ public enum OrePrefixes {
         cableGt01.mSecondaryMaterial = new MaterialStack(Materials.Rubber, plate.mMaterialAmount);
         bucket.mSecondaryMaterial = new MaterialStack(Materials.Iron, ingot.mMaterialAmount * 3);
         bucketClay.mSecondaryMaterial = new MaterialStack(Materials.Clay, dust.mMaterialAmount * 5);
-        cell.mSecondaryMaterial = new MaterialStack(Materials.Tin, plate.mMaterialAmount * 2);
-        cellPlasma.mSecondaryMaterial = new MaterialStack(Materials.Tin, plate.mMaterialAmount * 2);
-        cellMolten.mSecondaryMaterial = new MaterialStack(Materials.Tin, plate.mMaterialAmount * 2);
+        CELL_TYPES.forEach(prefix -> prefix.mSecondaryMaterial = new MaterialStack(Materials.Tin, plate.mMaterialAmount * 2));
         oreRedgranite.mSecondaryMaterial = new MaterialStack(Materials.GraniteRed, dust.mMaterialAmount);
         oreBlackgranite.mSecondaryMaterial = new MaterialStack(Materials.GraniteBlack, dust.mMaterialAmount);
         oreNetherrack.mSecondaryMaterial = new MaterialStack(Materials.Netherrack, dust.mMaterialAmount);
@@ -983,7 +996,6 @@ public enum OrePrefixes {
                 return mLocalizedMaterialPre + OrePrefixes.gem.getDefaultLocalNameFormatForItem(aMaterial);
             case crateGtPlate:
                 return mLocalizedMaterialPre + OrePrefixes.plate.getDefaultLocalNameFormatForItem(aMaterial);
-            case cellMolten:
         }
         switch (aMaterial.mName) {
             case "Glass":
diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java
index 48d1bd8a18..57f7073e24 100644
--- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java
+++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java
@@ -245,16 +245,17 @@ public abstract class GT_MetaTileEntity_BasicGenerator extends GT_MetaTileEntity
     public boolean solidFuelOverride(ItemStack stack) {
         //this could be used for a coal generator for example aswell...
         ItemData association = GT_OreDictUnificator.getAssociation(stack);
-        //if it is a gregtech Item, make sure its not a VOLUMETRIC_FLASK, cell, motlen cell or plasma cell, else do vanilla checks
-        return association != null ? !OrePrefixes.cell.equals(association.mPrefix) &&
-                !OrePrefixes.cellMolten.equals(association.mPrefix) &&
-                !OrePrefixes.cellPlasma.equals(association.mPrefix) &&
-                !GT_Utility.areStacksEqual(ItemList.VOLUMETRIC_FLASK.get(1L), stack, true) :
-                stack != null && //when the stack is null its not a solid
-                stack.getItem() != null && //when the item in the stack is null its not a solid
-                !(stack.getItem() instanceof IFluidContainerItem) && //when the item is a fluid container its not a solid...
-                !(stack.getItem() instanceof IFluidHandler) &&  //when the item is a fluid handler its not a solid...
-                !stack.getItem().getUnlocalizedName().contains("bucket"); //since we cant really check for buckets...
+        //if it is a gregtech Item, make sure its not a VOLUMETRIC_FLASK or any type of cell, else do vanilla checks
+        if (association != null) {
+            return !OrePrefixes.CELL_TYPES.contains(association.mPrefix) &&
+                    !GT_Utility.areStacksEqual(ItemList.VOLUMETRIC_FLASK.get(1L), stack, true);
+        } else {
+            return stack != null && //when the stack is null its not a solid
+                    stack.getItem() != null && //when the item in the stack is null its not a solid
+                    !(stack.getItem() instanceof IFluidContainerItem) && //when the item is a fluid container its not a solid...
+                    !(stack.getItem() instanceof IFluidHandler) &&  //when the item is a fluid handler its not a solid...
+                    !stack.getItem().getUnlocalizedName().contains("bucket"); //since we cant really check for buckets...
+        }
     }
 
     public abstract int getPollution();
diff --git a/src/main/java/gregtech/api/util/GT_ModHandler.java b/src/main/java/gregtech/api/util/GT_ModHandler.java
index ac9f7bd3d4..a910723069 100644
--- a/src/main/java/gregtech/api/util/GT_ModHandler.java
+++ b/src/main/java/gregtech/api/util/GT_ModHandler.java
@@ -2008,7 +2008,22 @@ public class GT_ModHandler {
 
     public static int getCapsuleCellContainerCount(ItemStack aStack) {
         if (aStack == null) return 0;
-        return GT_Utility.areStacksEqual(GT_Utility.getContainerForFilledItem(aStack, true), ItemList.Cell_Empty.get(1)) || OrePrefixes.cell.contains(aStack) || OrePrefixes.cellMolten.contains(aStack) || OrePrefixes.cellPlasma.contains(aStack) || GT_Utility.areStacksEqual(aStack, getIC2Item("waterCell", 1, W)) ? 1 : 0;
+
+        if (GT_Utility.areStacksEqual(GT_Utility.getContainerForFilledItem(aStack, true), ItemList.Cell_Empty.get(1))) {
+            return 1;
+        }
+
+        if (GT_Utility.areStacksEqual(aStack, getIC2Item("waterCell", 1, W))) {
+            return 1;
+        }
+
+        for (OrePrefixes cellType : OrePrefixes.CELL_TYPES) {
+            if (cellType.contains(aStack)) {
+                return 1;
+            }
+        }
+
+        return 0;
     }
 
     public static class RecipeBits {
diff --git a/src/main/java/gregtech/common/GT_Proxy.java b/src/main/java/gregtech/common/GT_Proxy.java
index 51aadf574e..bff044b4c3 100644
--- a/src/main/java/gregtech/common/GT_Proxy.java
+++ b/src/main/java/gregtech/common/GT_Proxy.java
@@ -1780,50 +1780,60 @@ public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler {
     }
 
     public void addAutoGeneratedHydroCrackedFluids(Materials aMaterial){
-    	Fluid[] crackedFluids = new Fluid[3];
-    	String[] prefixes = {"lightlyhydrocracked.", "moderatelyhydrocracked.", "severelyhydrocracked."};
-    	String[] localPrefixes = {"Lightly Hydro-Cracked ", "Moderately Hydro-Cracked ", "Severely Hydro-Cracked "};
-    	GT_Fluid uncrackedFluid = null;
-    	if (aMaterial.mFluid != null) {
-    		uncrackedFluid = (GT_Fluid) aMaterial.mFluid;
-    	} else if (aMaterial.mGas != null) {
-    		uncrackedFluid = (GT_Fluid) aMaterial.mGas;
-    	}
-    	for (int i = 0; i < 3; i++) {
-    		crackedFluids[i] = addFluid(prefixes[i] + aMaterial.mName.toLowerCase(Locale.ENGLISH), uncrackedFluid.mTextureName, 
-    				localPrefixes[i] + aMaterial.mDefaultLocalName, null, aMaterial.mRGBa, 2, 775, null, null, 0);
-    		int hydrogenAmount = 2 * i + 2;
-    		GT_Values.RA.addCrackingRecipe(i + 1, new FluidStack(uncrackedFluid, 1000), Materials.Hydrogen.getGas(hydrogenAmount * 1000), 
-    				new FluidStack(crackedFluids[i], 1000), 40 + 20 * i, 120 + 60 * i);
-    		GT_Values.RA.addChemicalRecipe(Materials.Hydrogen.getCells(hydrogenAmount), GT_Utility.getIntegratedCircuit(i + 1), new FluidStack(uncrackedFluid, 1000), 
-    				new FluidStack(crackedFluids[i], 800), Materials.Empty.getCells(hydrogenAmount), 160 + 80 * i, 30);
-    		GT_Values.RA.addChemicalRecipe(aMaterial.getCells(1), GT_Utility.getIntegratedCircuit(i + 1), Materials.Hydrogen.getGas(hydrogenAmount * 1000), 
-    				new FluidStack(crackedFluids[i], 800), Materials.Empty.getCells(1), 160 + 80 * i, 30);
-    	}
-    	aMaterial.setHydroCrackedFluids(crackedFluids);
+        Fluid[] crackedFluids = new Fluid[3];
+        String[] namePrefixes = { "lightlyhydrocracked.", "moderatelyhydrocracked.", "severelyhydrocracked." };
+        OrePrefixes[] orePrefixes = { OrePrefixes.cellHydroCracked1, OrePrefixes.cellHydroCracked2, OrePrefixes.cellHydroCracked3 };
+        GT_Fluid uncrackedFluid = null;
+        if (aMaterial.mFluid != null) {
+            uncrackedFluid = (GT_Fluid) aMaterial.mFluid;
+        } else if (aMaterial.mGas != null) {
+            uncrackedFluid = (GT_Fluid) aMaterial.mGas;
+        }
+        for (int i = 0; i < 3; i++) {
+            crackedFluids[i] = addFluid(
+                    namePrefixes[i] + aMaterial.mName.toLowerCase(Locale.ENGLISH), uncrackedFluid.mTextureName,
+                    orePrefixes[i].mLocalizedMaterialPre + aMaterial.mDefaultLocalName,
+                    null, aMaterial.mRGBa, 2, 775,
+                    GT_OreDictUnificator.get(orePrefixes[i], aMaterial, 1L),
+                    ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+
+            int hydrogenAmount = 2 * i + 2;
+            GT_Values.RA.addCrackingRecipe(i + 1, new FluidStack(uncrackedFluid, 1000), Materials.Hydrogen.getGas(hydrogenAmount * 1000),
+                    new FluidStack(crackedFluids[i], 1000), 40 + 20 * i, 120 + 60 * i);
+            GT_Values.RA.addChemicalRecipe(Materials.Hydrogen.getCells(hydrogenAmount), GT_Utility.getIntegratedCircuit(i + 1), new FluidStack(uncrackedFluid, 1000),
+                    new FluidStack(crackedFluids[i], 800), Materials.Empty.getCells(hydrogenAmount), 160 + 80 * i, 30);
+            GT_Values.RA.addChemicalRecipe(aMaterial.getCells(1), GT_Utility.getIntegratedCircuit(i + 1), Materials.Hydrogen.getGas(hydrogenAmount * 1000),
+                    new FluidStack(crackedFluids[i], 800), Materials.Empty.getCells(1), 160 + 80 * i, 30);
+        }
+        aMaterial.setHydroCrackedFluids(crackedFluids);
     }
     
     public void addAutoGeneratedSteamCrackedFluids(Materials aMaterial){
-    	Fluid[] crackedFluids = new Fluid[3];
-    	String[] prefixes = {"lightlysteamcracked.", "moderatelysteamcracked.", "severelysteamcracked."};
-    	String[] localPrefixes = {"Lightly Steam-Cracked ", "Moderately Steam-Cracked ", "Severely Steam-Cracked "};
-    	GT_Fluid uncrackedFluid = null;
-    	if (aMaterial.mFluid != null) {
-    		uncrackedFluid = (GT_Fluid) aMaterial.mFluid;
-    	} else if (aMaterial.mGas != null) {
-    		uncrackedFluid = (GT_Fluid) aMaterial.mGas;
-    	}
-    	for (int i = 0; i < 3; i++) {
-    		crackedFluids[i] = addFluid(prefixes[i] + aMaterial.mName.toLowerCase(Locale.ENGLISH), uncrackedFluid.mTextureName, 
-    				localPrefixes[i] + aMaterial.mDefaultLocalName, null, aMaterial.mRGBa, 2, 775, null, null, 0);
-    		GT_Values.RA.addCrackingRecipe(i + 1, new FluidStack(uncrackedFluid, 1000), GT_ModHandler.getSteam(1000), 
-    				new FluidStack(crackedFluids[i], 1000), 40 + 20 * i, 240 + 120 * i);
-    		GT_Values.RA.addChemicalRecipe(GT_ModHandler.getIC2Item("steamCell", 1L), GT_Utility.getIntegratedCircuit(i + 1), new FluidStack(uncrackedFluid, 1000), 
-    				new FluidStack(crackedFluids[i], 800), Materials.Empty.getCells(1), 160 + 80 * i, 30);
-    		GT_Values.RA.addChemicalRecipe(aMaterial.getCells(1), GT_Utility.getIntegratedCircuit(i + 1), GT_ModHandler.getSteam(1000), 
-    				new FluidStack(crackedFluids[i], 800), Materials.Empty.getCells(1), 160 + 80 * i, 30);
-    	}
-    	aMaterial.setSteamCrackedFluids(crackedFluids);
+        Fluid[] crackedFluids = new Fluid[3];
+        String[] namePrefixes = { "lightlysteamcracked.", "moderatelysteamcracked.", "severelysteamcracked." };
+        OrePrefixes[] orePrefixes = { OrePrefixes.cellSteamCracked1, OrePrefixes.cellSteamCracked2, OrePrefixes.cellSteamCracked3 };
+        GT_Fluid uncrackedFluid = null;
+        if (aMaterial.mFluid != null) {
+            uncrackedFluid = (GT_Fluid) aMaterial.mFluid;
+        } else if (aMaterial.mGas != null) {
+            uncrackedFluid = (GT_Fluid) aMaterial.mGas;
+        }
+        for (int i = 0; i < 3; i++) {
+            crackedFluids[i] = addFluid(
+                    namePrefixes[i] + aMaterial.mName.toLowerCase(Locale.ENGLISH), uncrackedFluid.mTextureName,
+                    orePrefixes[i].mLocalizedMaterialPre + aMaterial.mDefaultLocalName,
+                    null, aMaterial.mRGBa, 2, 775,
+                    GT_OreDictUnificator.get(orePrefixes[i], aMaterial, 1L),
+                    ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+
+            GT_Values.RA.addCrackingRecipe(i + 1, new FluidStack(uncrackedFluid, 1000), GT_ModHandler.getSteam(1000),
+                    new FluidStack(crackedFluids[i], 1000), 40 + 20 * i, 240 + 120 * i);
+            GT_Values.RA.addChemicalRecipe(GT_ModHandler.getIC2Item("steamCell", 1L), GT_Utility.getIntegratedCircuit(i + 1), new FluidStack(uncrackedFluid, 1000),
+                    new FluidStack(crackedFluids[i], 800), Materials.Empty.getCells(1), 160 + 80 * i, 30);
+            GT_Values.RA.addChemicalRecipe(aMaterial.getCells(1), GT_Utility.getIntegratedCircuit(i + 1), GT_ModHandler.getSteam(1000),
+                    new FluidStack(crackedFluids[i], 800), Materials.Empty.getCells(1), 160 + 80 * i, 30);
+        }
+        aMaterial.setSteamCrackedFluids(crackedFluids);
     }
     
     public Fluid addFluid(String aName, String aLocalized, Materials aMaterial, int aState, int aTemperatureK) {
diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_99.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_99.java
index 2b94d96cb0..1c27310d99 100644
--- a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_99.java
+++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_99.java
@@ -1,5 +1,6 @@
 package gregtech.common.items;
 
+import com.google.common.collect.ImmutableList;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 import gregtech.api.GregTech_API;
@@ -24,145 +25,174 @@ import static gregtech.api.enums.OrePrefixes.cellMolten;
 public class GT_MetaGenerated_Item_99 extends GT_MetaGenerated_Item {
     public static GT_MetaGenerated_Item_99 INSTANCE;
 
-    private BitSet enabled=new BitSet();
+    /**
+     * Ore prefixes appear in this list in the order in which they will be assigned ID blocks.
+     *
+     * <p>In order to avoid breaking existing worlds, the entries in this list must not be re-ordered! The only safe
+     * modification that can be made to this list is adding new entries to the end.
+     */
+    private static final ImmutableList<OrePrefixes> CRACKED_CELL_TYPES =
+            ImmutableList.of(
+                    OrePrefixes.cellHydroCracked1, OrePrefixes.cellHydroCracked2, OrePrefixes.cellHydroCracked3,
+                    OrePrefixes.cellSteamCracked1, OrePrefixes.cellSteamCracked2, OrePrefixes.cellSteamCracked3);
+    private static final int NUM_CRACKED_CELL_TYPES = CRACKED_CELL_TYPES.size();
 
-    private void register(Materials tMaterial,int i){
-        ItemStack tStack = new ItemStack(this, 1, i);
-        enabled.set(i);
-        GT_LanguageManager.addStringLocalization(getUnlocalizedName(tStack) + ".name", getDefaultLocalizationFormat(cellMolten, tMaterial, i));
-        GT_LanguageManager.addStringLocalization(getUnlocalizedName(tStack) + ".tooltip", tMaterial.getToolTip(cellMolten.mMaterialAmount / M));
-        if (cellMolten.mIsUnificatable) {
-            GT_OreDictUnificator.set(cellMolten, tMaterial, tStack);
-        } else {
-            GT_OreDictUnificator.registerOre(cellMolten.get(tMaterial), tStack);
-        }
-    }
-    //x32
+    /**
+     * Assignment of metadata IDs:
+     *        0 -    999: Molten cells
+     *   10_000 - 15_999: Cracked fluid cells (# IDs used is NUM_CRACKED_CELL_TYPES * 1_000; update this if you add any)
+     */
+    private BitSet enabled = new BitSet();
 
     public GT_MetaGenerated_Item_99() {
-        super("metaitem.99", (short) 1000, (short) 0);
+        super("metaitem.99", (short) (10_000 + NUM_CRACKED_CELL_TYPES * 1_000), (short) 0);
 
         INSTANCE = this;
 
-        for (Materials tMaterial:GregTech_API.sGeneratedMaterials) {
-            if (tMaterial == null || tMaterial.mMetaItemSubID<0 || tMaterial.mMetaItemSubID>=1000) continue;
-            //if (tMaterial.getcells(1)==null) {
+        for (Materials tMaterial : GregTech_API.sGeneratedMaterials) {
+            if (tMaterial == null || tMaterial.mMetaItemSubID < 0 || tMaterial.mMetaItemSubID >= 1_000) {
+                continue;
+            }
+
             if ((tMaterial.contains(SubTag.SMELTING_TO_FLUID)) && (!tMaterial.contains(SubTag.NO_SMELTING)) && !tMaterial.contains(SubTag.SMELTING_TO_GEM)) {
-                register(tMaterial,tMaterial.mMetaItemSubID);
-                if (tMaterial.mSmeltInto != tMaterial) {
-                    register(tMaterial.mSmeltInto,tMaterial.mSmeltInto.mMetaItemSubID);
+                registerMolten(tMaterial, tMaterial.mMetaItemSubID);
+                if (tMaterial.mSmeltInto != tMaterial
+                        && tMaterial.mSmeltInto.mMetaItemSubID >= 0 && tMaterial.mSmeltInto.mMetaItemSubID < 1_000) {
+                    registerMolten(tMaterial.mSmeltInto, tMaterial.mSmeltInto.mMetaItemSubID);
                 }
             }
-            //}
+
+            if (tMaterial.canBeCracked()) {
+                registerCracked(tMaterial, tMaterial.mMetaItemSubID);
+            }
         }
+
+        // We're not going to use these BitSets, so clear them to save memory.
         mEnabledItems.clear();
         mVisibleItems.clear();
     }
 
-	/* ---------- OVERRIDEABLE FUNCTIONS ---------- */
+    private void registerMolten(Materials tMaterial,int i){
+        ItemStack tStack = new ItemStack(this, 1, i);
+        enabled.set(i);
 
-    /**
-     * @return the Color Modulation the Material is going to be rendered with.
-     */
-    @Override
-    public short[] getRGBa(ItemStack aStack) {
-        Materials tMaterial = GregTech_API.sGeneratedMaterials[getDamage(aStack)];
-        return tMaterial == null ? Materials._NULL.mMoltenRGBa : tMaterial.mMoltenRGBa;
+        GT_LanguageManager.addStringLocalization(getUnlocalizedName(tStack) + ".name", cellMolten.getDefaultLocalNameFormatForItem(tMaterial));
+        GT_LanguageManager.addStringLocalization(getUnlocalizedName(tStack) + ".tooltip", tMaterial.getToolTip(cellMolten.mMaterialAmount / M));
+
+        if (cellMolten.mIsUnificatable) {
+            GT_OreDictUnificator.set(cellMolten, tMaterial, tStack);
+        } else {
+            GT_OreDictUnificator.registerOre(cellMolten.get(tMaterial), tStack);
+        }
     }
 
-	/* ---------- OVERRIDEABLE FUNCTIONS ---------- */
+    private void registerCracked(Materials tMaterial, int i) {
+        int offset = 10_000;
+        for (OrePrefixes prefix : CRACKED_CELL_TYPES) {
+            ItemStack tStack = new ItemStack(this, 1, offset + i);
+            enabled.set(offset + i);
 
-    /**
-     * @param aPrefix   the OreDict Prefix
-     * @param aMaterial the Material
-     * @param aMetaData a Index from [0 - 31999]
-     * @return the Localized Name when default LangFiles are used.
-     */
-    @Deprecated
-    public String getDefaultLocalization(OrePrefixes aPrefix, Materials aMaterial, int aMetaData) {
-        return aPrefix.getDefaultLocalNameForItem(aMaterial);
+            GT_LanguageManager.addStringLocalization(getUnlocalizedName(tStack) + ".name", prefix.getDefaultLocalNameFormatForItem(tMaterial));
+            GT_LanguageManager.addStringLocalization(getUnlocalizedName(tStack) + ".tooltip", tMaterial.getToolTip(prefix.mMaterialAmount / M));
+
+            if (prefix.mIsUnificatable) {
+                GT_OreDictUnificator.set(prefix, tMaterial, tStack);
+            } else {
+                GT_OreDictUnificator.registerOre(prefix.get(tMaterial), tStack);
+            }
+
+            offset += 1_000;
+        }
     }
 
-    /**
-     * @param aPrefix   the OreDict Prefix
-     * @param aMaterial the Material
-     * @param aMetaData a Index from [0 - 31999]
-     * @return the Localized Name Format when default LangFiles are used.
-     */
-    public String getDefaultLocalizationFormat(OrePrefixes aPrefix, Materials aMaterial, int aMetaData) {
-        return aPrefix.getDefaultLocalNameFormatForItem(aMaterial);
+    /** Returns null for item damage out of bounds. */
+    private Materials getMaterial(int damage) {
+        if (damage < 0) {
+            return null;
+        }
+        return GregTech_API.sGeneratedMaterials[damage % 1_000];
     }
 
-    /**
-     * @param aPrefix         always != null
-     * @param aMaterial       always != null
-     * @param aDoShowAllItems this is the Configuration Setting of the User, if he wants to see all the Stuff like Tiny Dusts or Crushed Ores as well.
-     * @return if this Item should be visible in NEI or Creative
-     */
-    public boolean doesShowInCreative(OrePrefixes aPrefix, Materials aMaterial, boolean aDoShowAllItems) {
-        return true;
+    /** Returns null for item damage out of bounds. */
+    private OrePrefixes getOrePrefix(int damage) {
+        if (damage < 0) {
+            return null;
+        } else if (damage < 1_000) {
+            return cellMolten;
+        } else if (damage >= 10_000 && damage < 10_000 + (NUM_CRACKED_CELL_TYPES * 1_000)) {
+            return CRACKED_CELL_TYPES.get((damage / 1_000) - 10);
+        }
+        return null;
     }
 
-	/* ---------- INTERNAL OVERRIDES ---------- */
+    @Override
+    public short[] getRGBa(ItemStack aStack) {
+        OrePrefixes prefix = getOrePrefix(aStack.getItemDamage());
+        Materials material = getMaterial(aStack.getItemDamage());
+        if (material == null) {
+            material = Materials._NULL;
+        }
+
+        if (prefix == cellMolten) {
+            return material.mMoltenRGBa;
+        } else {
+            return material.mRGBa;
+        }
+    }
 
     @Override
     public String getItemStackDisplayName(ItemStack aStack) {
         String aName = super.getItemStackDisplayName(aStack);
-        int aDamage = aStack.getItemDamage();
-        if (aDamage < 1000 && aDamage >= 0)
-            return Materials.getLocalizedNameForItem(aName, aDamage);
+        Materials material = getMaterial(aStack.getItemDamage());
+        if (material != null) {
+            return material.getLocalizedNameForItem(aName);
+        }
         return aName;
     }
 
     @Override
     public ItemStack getContainerItem(ItemStack aStack) {
-        int aDamage = aStack.getItemDamage();
-        if (aDamage < 1000 && aDamage >= 0) {
-            return cellMolten.mContainerItem;
+        OrePrefixes prefix = getOrePrefix(aStack.getItemDamage());
+        if (prefix != null) {
+            return prefix.mContainerItem;
         }
         return null;
     }
 
     @Override
     @SideOnly(Side.CLIENT)
-    public final void getSubItems(Item var1, CreativeTabs aCreativeTab, List aList) {
-        for (int i = 0; i < 1000; i++) {
-            Materials aMaterial = GregTech_API.sGeneratedMaterials[i];
-            if (aMaterial != null && enabled.get(i)) {
-                ItemStack tStack = new ItemStack(this, 1, i);
-                isItemStackUsable(tStack);
-                aList.add(tStack);
-            }
-        }
-        super.getSubItems(var1, aCreativeTab, aList);
+    public void getSubItems(Item var1, CreativeTabs aCreativeTab, List aList) {
+        enabled.stream()
+                .mapToObj(i -> new ItemStack(this, 1, i))
+                .forEach(aList::add);
     }
 
     @Override
     public final IIcon getIconFromDamage(int aMetaData) {
-        if (aMetaData < 0) return null;
-        if (aMetaData < 1000) {
-            Materials tMaterial = GregTech_API.sGeneratedMaterials[aMetaData];
-            if (tMaterial == null) return null;
-            IIconContainer tIcon = getIconContainer(aMetaData);
-            if (tIcon != null) return tIcon.getIcon();
-            return null;
+        IIconContainer iconContainer = getIconContainer(aMetaData);
+        if (iconContainer != null) {
+            return iconContainer.getIcon();
         }
         return null;
     }
 
     @Override
     public IIconContainer getIconContainer(int aMetaData) {
-        if (aMetaData < 0) return null;
-        if (aMetaData < 1000) {
-            Materials tMaterial = GregTech_API.sGeneratedMaterials[aMetaData];
-            if (tMaterial == null) return null;
-            return tMaterial.mIconSet.mTextures[cellMolten.mTextureIndex];
+        Materials material = getMaterial(aMetaData);
+        OrePrefixes prefix = getOrePrefix(aMetaData);
+        if (material != null && prefix != null) {
+            return material.mIconSet.mTextures[prefix.mTextureIndex];
         }
         return null;
     }
 
     @Override
     public int getItemStackLimit(ItemStack aStack) {
-        return cellMolten.mDefaultStackSize;
+        OrePrefixes prefix = getOrePrefix(aStack.getItemDamage());
+        if (prefix != null) {
+            return prefix.mDefaultStackSize;
+        } else {
+            return 64;
+        }
     }
 }