Attempting to Rewrite the entire material system for future use (Also makes life easier if I do something similar in 1.10)

17 files changed, 1172 insertions, 64 deletions

diff --git a/.classpath b/.classpath
index 629c1f68b7..43fa82df64 100644
--- a/.classpath
+++ b/.classpath
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry excluding="conduits/|miscutil/enderio/conduit/GregTech/|miscutil/gregtech/enums/Materials2.java|miscutil/gregtech/objects/GregMaterialStack.java|miscutil/core/util/Log.java|miscutil/enderio/|miscutil/core/item/tool/bloodsteel/|miscutil/core/block/reactor/|miscutil/gregtech/common/tools/GT_Tool_Turbine_Large.java|miscutil/gregtech/common/tools/GT_Tool_Turbine_Normal.java|miscutil/gregtech/common/tools/GT_Tool_Turbine_Small.java|miscutil/gregtech/api/enums/GregtechTextures.java|miscutil/gregtech/api/enums/GregtechTextureSet.java|libshapedraw/api/|miscutil/core/xmod/forestry/bees/multiblock/|miscutil/core/multiblock/|miscutil/core/xmod/forestry/bees/alveary/gui/old/FR_GuiID.java|miscutil/core/xmod/forestry/bees/alveary/gui/old/FR_GuiIDRegistry.java|miscutil/core/xmod/forestry/bees/alveary/gui/old/ContainerAlvearyFrameHousing.java|miscutil/core/xmod/forestry/core/|miscutil/core/xmod/forestry/bees/alveary/gui/old/|gtPlusPlus/xmod/gregtech/loaders/Processing_Block.java|gtPlusPlus/xmod/gregtech/loaders/Processing_Ingot1.java|gtPlusPlus/xmod/gregtech/loaders/Processing_Plate1.java" kind="src" path="src/Java"/>
+	<classpathentry excluding="conduits/|miscutil/enderio/conduit/GregTech/|miscutil/gregtech/enums/Materials2.java|miscutil/gregtech/objects/GregMaterialStack.java|miscutil/core/util/Log.java|miscutil/enderio/|miscutil/core/item/tool/bloodsteel/|miscutil/core/block/reactor/|miscutil/gregtech/common/tools/GT_Tool_Turbine_Large.java|miscutil/gregtech/common/tools/GT_Tool_Turbine_Normal.java|miscutil/gregtech/common/tools/GT_Tool_Turbine_Small.java|miscutil/gregtech/api/enums/GregtechTextures.java|miscutil/gregtech/api/enums/GregtechTextureSet.java|libshapedraw/api/|miscutil/core/xmod/forestry/bees/multiblock/|miscutil/core/multiblock/|miscutil/core/xmod/forestry/bees/alveary/gui/old/FR_GuiID.java|miscutil/core/xmod/forestry/bees/alveary/gui/old/FR_GuiIDRegistry.java|miscutil/core/xmod/forestry/bees/alveary/gui/old/ContainerAlvearyFrameHousing.java|miscutil/core/xmod/forestry/core/|miscutil/core/xmod/forestry/bees/alveary/gui/old/|gtPlusPlus/xmod/gregtech/loaders/Processing_Block.java|gtPlusPlus/xmod/gregtech/loaders/Processing_Ingot1.java|gtPlusPlus/xmod/gregtech/loaders/Processing_Plate1.java|gtPlusPlus/core/lib/MaterialInfo.java" kind="src" path="src/Java"/>
 	<classpathentry kind="src" path="src/resources"/>
 	<classpathentry combineaccessrules="false" kind="src" path="/Forge"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
diff --git a/src/Java/gtPlusPlus/core/block/ModBlocks.java b/src/Java/gtPlusPlus/core/block/ModBlocks.java
index ceb8880299..de4520fee9 100644
--- a/src/Java/gtPlusPlus/core/block/ModBlocks.java
+++ b/src/Java/gtPlusPlus/core/block/ModBlocks.java
@@ -1,7 +1,7 @@
 package gtPlusPlus.core.block;
 
 import gtPlusPlus.core.block.general.LightGlass;
-import gtPlusPlus.core.block.general.fluids.FluidRegistryHandler;
+import gtPlusPlus.core.fluids.FluidRegistryHandler;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.xmod.gregtech.common.blocks.GregtechMetaCasingBlocks;
@@ -25,10 +25,7 @@ public final class ModBlocks {
 	public static Block MatterFabricatorEffectBlock;
 
 	public static Fluid fluidJackDaniels = new Fluid("fluidJackDaniels");
-	public static Block blockFluidJackDaniels; 
-	public static Block blockGtFrameStaballoy;
-	public static Block blockGtFrameTantalloy60;
-	public static Block blockGtFrameTantalloy61;
+	public static Block blockFluidJackDaniels;
 
 
 
diff --git a/src/Java/gtPlusPlus/core/fluids/BlockFluidBase.java b/src/Java/gtPlusPlus/core/fluids/BlockFluidBase.java
new file mode 100644
index 0000000000..ad8d78edb1
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/fluids/BlockFluidBase.java
@@ -0,0 +1,54 @@
+package gtPlusPlus.core.fluids;
+
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.lib.CORE;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.BlockFluidClassic;
+import net.minecraftforge.fluids.Fluid;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockFluidBase extends BlockFluidClassic {
+
+    @SideOnly(Side.CLIENT)
+    protected IIcon stillIcon;
+    @SideOnly(Side.CLIENT)
+    protected IIcon flowingIcon;
+    
+    protected int colour;
+    
+    public BlockFluidBase(Fluid fluid, Material material, int colour) {
+            super(fluid, material);
+            this.colour = colour;
+            setCreativeTab(AddToCreativeTab.tabMisc);
+    }
+    
+    @Override
+    public IIcon getIcon(int side, int meta) {
+            return (side == 0 || side == 1)? stillIcon : flowingIcon;
+    }
+    
+    @SideOnly(Side.CLIENT)
+    @Override
+    public void registerBlockIcons(IIconRegister register) {
+            stillIcon = register.registerIcon(CORE.MODID+":fluids/fluid.molten.autogenerated");
+            flowingIcon = register.registerIcon(CORE.MODID+":fluids/fluid.molten.autogenerated");
+    }
+    
+    @Override
+    public boolean canDisplace(IBlockAccess world, int x, int y, int z) {
+            if (world.getBlock(x,  y,  z).getMaterial().isLiquid()) return false;
+            return super.canDisplace(world, x, y, z);
+    }
+    
+    @Override
+    public boolean displaceIfPossible(World world, int x, int y, int z) {
+            if (world.getBlock(x,  y,  z).getMaterial().isLiquid()) return false;
+            return super.displaceIfPossible(world, x, y, z);
+    }
+    
+}		
diff --git a/src/Java/gtPlusPlus/core/block/general/fluids/FluidRegistryHandler.java b/src/Java/gtPlusPlus/core/fluids/FluidRegistryHandler.java
index bda2aae35b..1df2b406b8 100644
--- a/src/Java/gtPlusPlus/core/block/general/fluids/FluidRegistryHandler.java
+++ b/src/Java/gtPlusPlus/core/fluids/FluidRegistryHandler.java
@@ -1,7 +1,8 @@
-package gtPlusPlus.core.block.general.fluids;
+package gtPlusPlus.core.fluids;
 
 import static gtPlusPlus.core.block.ModBlocks.blockFluidJackDaniels;
 import static gtPlusPlus.core.block.ModBlocks.fluidJackDaniels;
+import gtPlusPlus.core.block.general.fluids.BlockFluidJackDaniels;
 import gtPlusPlus.core.lib.CORE;
 import net.minecraft.block.material.Material;
 import net.minecraftforge.fluids.FluidRegistry;
diff --git a/src/Java/gtPlusPlus/core/fluids/GenericFluid.java b/src/Java/gtPlusPlus/core/fluids/GenericFluid.java
new file mode 100644
index 0000000000..f67fda744e
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/fluids/GenericFluid.java
@@ -0,0 +1,40 @@
+package gtPlusPlus.core.fluids;
+
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class GenericFluid extends Fluid{
+
+	protected String fluidName;
+	public Fluid fluidFactory;
+	public Block blockFactory;
+	public short[] rgba;
+	
+	public GenericFluid(String fluidName, int luminosity, int density, int temperature, int viscosity, boolean isGas, short[] rgba) {
+		super(fluidName);
+		fluidFactory = this;
+		this.rgba = rgba;
+		fluidFactory.setLuminosity(luminosity);
+		fluidFactory.setDensity(density);
+		fluidFactory.setTemperature(temperature);
+		fluidFactory.setViscosity(viscosity);
+		fluidFactory.setGaseous(isGas);
+		fluidFactory.setUnlocalizedName("fluid"+fluidName);
+		FluidRegistry.registerFluid(fluidFactory);			
+		blockFactory = new BlockFluidBase(fluidFactory, Material.water, Utils.rgbtoHexValue(rgba[0], rgba[1], rgba[2])).setBlockName("fluidblock"+fluidName);
+		GameRegistry.registerBlock(blockFactory, CORE.MODID + "_" + blockFactory.getUnlocalizedName().substring(5));
+		//fluidFactory.setUnlocalizedName(blockFactory.getUnlocalizedName());
+		
+	}
+	
+	@Override
+	public int getColor() {
+        return Math.max(0, Math.min(255, this.rgba[0])) << 16 | Math.max(0, Math.min(255, this.rgba[1])) << 8 | Math.max(0, Math.min(255, this.rgba[2]));
+    }
+
+}
diff --git a/src/Java/gtPlusPlus/core/handler/MaterialHandler.java b/src/Java/gtPlusPlus/core/handler/MaterialHandler.java
new file mode 100644
index 0000000000..52d95817e5
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/handler/MaterialHandler.java
@@ -0,0 +1,29 @@
+package gtPlusPlus.core.handler;
+
+import gregtech.api.enums.Materials;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.materials.MaterialUtils;
+
+//Finally Wrote a proper material class, sigh.
+public class MaterialHandler implements Runnable{
+
+	int arrayPos = 0;
+	boolean[] oneOfEachElementArray;
+	Material[] AllGregtechMaterials;	
+	
+	
+	@Override
+	public void run() {		
+		//Register GT Base Materials First
+		Utils.LOG_INFO("Adding All basic elements to the Material Dictionary.");
+		for (Materials x: Materials.values()){
+			if (x.getProtons() <= 100 && !oneOfEachElementArray[arrayPos]){
+				AllGregtechMaterials[arrayPos] = MaterialUtils.generateMaterialFromGtENUM(x);
+				oneOfEachElementArray[arrayPos] = true;
+				arrayPos++;
+			}
+		}		
+	}	
+	
+}
diff --git a/src/Java/gtPlusPlus/core/lib/MaterialInfo.java b/src/Java/gtPlusPlus/core/lib/MaterialInfo.java
index fdd7ccfa76..455becc2d1 100644
--- a/src/Java/gtPlusPlus/core/lib/MaterialInfo.java
+++ b/src/Java/gtPlusPlus/core/lib/MaterialInfo.java
@@ -15,36 +15,67 @@ import net.minecraft.item.ItemStack;
 public enum MaterialInfo {
 		
 	ENERGYCRYSTAL(GTplusplus.randomDust_A, 8, GTplusplus.randomDust_B, 8, GTplusplus.randomDust_C, 8, GTplusplus.randomDust_D, 8, "dustEnergyCrystal", 1, noItem, 0),
+	
 	BLOODSTEEL(noItem, 0, noItem, 0, noItem, 0, noItem, 0, noItem, 0, noItem, 0),
+	
 	STABALLOY("dustTitanium", 1, "dustUranium", 8, noItem, 0, noItem, 0, "dustStaballoy", 1, noItem, 0),
+	
 	TANTALLOY60("dustTungsten", 1, "dustTantalum", 8, "dustTinyTitanium", 5, noItem, 0,	"dustTantalloy60", 1, noItem, 0),
+	
 	TANTALLOY61("dustTungsten", 1, "dustSmallTitanium", 3,	"dustSmallYttrium", 2, "dustTantalum", 9,	"dustTantalloy61", 1, noItem, 0),
+	
 	QUANTUM(noItem, 0, noItem, 0,	noItem, 0, noItem, 0, noItem, 0, noItem, 0),
+	
 	TUMBAGA("dustGold", 6, "dustCopper", 3,	noItem, 0, noItem, 0, "dustTumbaga", 2, noItem, 0),
+	
 	POTIN("dustBronze", 3, "dustTin", 2, "dustLead", 4, noItem, 0, "dustPotin", 3, noItem, 0),	
+	
 	BEDROCKIUM(noItem, 0, noItem, 0, noItem, 0, noItem, 0, noItem, 0, noItem, 0),
+	
 	INCONEL625("dustNickel", 5, "dustChrome", 2, "dustWroughtIron", 1, "dustMolybdenum", 1, "dustInconel625", 4, "dustTinyDarkAsh", 1),
+	
 	INCONEL690("dustNickel", 5, "dustChrome", 2, "dustNiobium", 1, "dustMolybdenum", 1, "dustInconel690", 2, "dustTinyDarkAsh", 1),
+	
 	INCONEL792("dustNickel", 5, "dustChrome", 1, "dustAluminium", 2, "dustNiobium", 1, "dustInconel792", 2, "dustTinyDarkAsh", 1),
+	
 	TUNGSTENCARBIDE("dustTungsten", 16, "dustCarbon", 16, noItem, 0, noItem, 0, "dustTungstenCarbide", 4, noItem, 0),
+	
 	SILICONCARBIDE("dustSilicon", 16, "dustCarbon", 16, noItem, 0, noItem, 0, "dustSiliconCarbide", 4, noItem, 0),
+	
 	ZERON100("dustChrome", 5, "dustSmallNickel", 6, "dustSmallMolybdenum", 3, "dustSteel", 14, "dustZeron100", 5, noItem, 0),
+	
 	MARAGING250("dustSteel", 4, "dustNickel", 2, "dustCobalt", 1, "dustTinyTitanium", 1, "dustMaragingSteel250", 6, noItem, 0),
+	
 	MARAGING300("dustSteel", 5, "dustNickel", 2, "dustCobalt", 2, "dustSmallTitanium", 1, "dustMaragingSteel300", 5, noItem, 0),
+	
 	MARAGING350("dustSteel", 6, "dustNickel", 3, "dustCobalt", 3, "dustTitanium", 1, "dustMaragingSteel350", 4, noItem, 0),
+	
 	STELLITE("dustCobalt", 4, "dustChrome", 4, "dustManganese", 2, "dustTitanium", 1, "dustStellite", 2, noItem, 0),
+	
 	TALONITE("dustCobalt", 4, "dustChrome", 4, "dustPhosphorus", 1, "dustMolybdenum", 1, "dustTalonite", 2, noItem, 0),
+	
 	HASTELLOY_W("dustSmallCobalt", 1, "dustSmallChrome", 4, "dustMolybdenum", 2, "dustNickel", 6, "dustHastelloyW", 2, noItem, 0),
+	
 	HASTELLOY_X("dustTinyCobalt", 6, "dustChrome", 2, "dustMolybdenum", 1, "dustNickel", 5, "dustHastelloyX", 2, noItem, 0),
+	
 	HASTELLOY_C276("dustSmallCobalt", 1, "dustSmallChrome", 14, "dustSmallMolybdenum", 14, "dustNickel", 5, "dustHastelloyC276", 2, noItem, 0),
+	
 	INCOLOY020("dustIron", 4, "dustChrome", 2, "dustTinyCarbon", 2, "dustSmallCopper", 4, "dustIncoloy020", 1, noItem, 0),
+	
 	INCOLOYDS("dustIron", 4, "dustChrome", 2, "dustTinyTitanium", 2, "dustSmallManganese", 1, "dustIncoloyDS", 1, noItem, 0),
+	
 	INCOLOYMA956("dustIron", 6, "dustChrome", 2, "dustSmallAluminium", 5, "dustTinyYttrium", 1, "dustIncoloyMA956", 1, noItem, 0),
+	
 	TANTALUMCARBIDE("dustTantalum", 4, "dustCarbon", 2, noItem, 0, noItem, 0, "dustTantalumCarbide", 1, noItem, 0),
+	
 	ZIRCONIUM(noItem, 0, noItem, 0, noItem, 0, noItem, 0, "dustZirconium", 1, noItem, 0),
+	
 	ZIRCONIUMCARBIDE("dustZirconium", 2, "dustCarbon", 2, noItem, 0, noItem, 0, "dustZirconiumCarbide", 1, noItem, 0),
+	
 	NIOMBIUMCARBIDE("dustNiobium", 2, "dustCarbon", 2, noItem, 0, noItem, 0, "dustNiobiumCarbide", 1, noItem, 0), 
+	
 	HASTELLOY_N("dustIron", 1, "dustSmallChrome", 7, "dustSmallMolybdenum", 12, "dustNickel", 4, "dustHastelloyN", 1, noItem, 0),
+	
 	URANIUM233(noItem, 0, noItem, 0, noItem, 0, noItem, 0, noItem, 0, noItem, 0);
 	
 	
diff --git a/src/Java/gtPlusPlus/core/material/ALLOY.java b/src/Java/gtPlusPlus/core/material/ALLOY.java
new file mode 100644
index 0000000000..c0d393ee58
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/material/ALLOY.java
@@ -0,0 +1,485 @@
+package gtPlusPlus.core.material;
+
+
+public class ALLOY {
+
+	public static final Material ENERGYCRYSTAL = new Material(
+			"name", //Material Name
+			new short[]{228, 255, 0, 0}, //Material Colour
+			5660, //Melting Point in C
+			0, //Boiling Point in C
+			100, //Protons
+			100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.GOLD, 50),
+					new MaterialStack(ELEMENT.SILVER, 50)
+			});
+
+	public static final Material BLOODSTEEL = new Material(
+			"Blood Steel", //Material Name
+			new short[]{142, 28, 0, 0}, //Material Colour
+			2500, //Melting Point in C
+			0, //Boiling Point in C
+			100, //Protons
+			100, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.GOLD, 50),
+					new MaterialStack(ELEMENT.SILVER, 50)
+			});
+
+	public static final Material STABALLOY = new Material(
+			"Staballoy", //Material Name
+			new short[]{68, 75, 66, 0}, //Material Colour
+			3450, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.URANIUM.getProtons()*9)+ELEMENT.TITANIUM.getProtons())/10, //Protons
+			((ELEMENT.URANIUM.getNeutrons()*9)+ELEMENT.TITANIUM.getNeutrons())/10, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.URANIUM, 90),
+					new MaterialStack(ELEMENT.TITANIUM, 10)
+			});
+
+	public static final Material TANTALLOY_60 = new Material(
+			"Tantalloy-60", //Material Name
+			new short[]{66, 75, 166, 0}, //Material Colour
+			3025, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.TUNGSTEN.getProtons()*1)+(ELEMENT.TANTALUM.getProtons()*8)+(ELEMENT.TITANIUM.getProtons()*1))/10, //Protons
+			((ELEMENT.TUNGSTEN.getNeutrons()*1)+(ELEMENT.TANTALUM.getNeutrons()*8)+(ELEMENT.TITANIUM.getNeutrons()*1))/10, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.TUNGSTEN, 7),
+					new MaterialStack(ELEMENT.TANTALUM, 90),
+					new MaterialStack(ELEMENT.TANTALUM, 2)
+			});
+
+	public static final Material TANTALLOY_61 = new Material(
+			"Tantalloy-61", //Material Name
+			new short[]{122, 135, 196, 0}, //Material Colour
+			3030, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.TUNGSTEN.getProtons()*1)+(ELEMENT.TANTALUM.getProtons()*7)+(ELEMENT.TITANIUM.getProtons()*1)+(ELEMENT.YTTRIUM.getProtons()*1))/10, //Protons
+			((ELEMENT.TUNGSTEN.getNeutrons()*1)+(ELEMENT.TANTALUM.getNeutrons()*7)+(ELEMENT.TITANIUM.getNeutrons()*1)+(ELEMENT.YTTRIUM.getNeutrons()*1))/10, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.TUNGSTEN, 10),
+					new MaterialStack(ELEMENT.TANTALUM, 70),
+					new MaterialStack(ELEMENT.TITANIUM, 10),
+					new MaterialStack(ELEMENT.YTTRIUM, 10)
+			});
+
+	public static final Material QUANTUM = new Material(
+			"Quantum", //Material Name
+			new short[]{128, 128, 128, 0}, //Material Colour
+			9999, //Melting Point in C
+			0, //Boiling Point in C
+			100, //Protons
+			100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			null);
+
+	public static final Material BRONZE = new Material(
+			"Bronze", //Material Name
+			new short[]{128, 128, 128, 0}, //Material Colour
+			((ELEMENT.TIN.getMeltingPoint_C()*1)+(ELEMENT.COPPER.getMeltingPoint_C()*3))/4, //Melting point in C
+			0, //Boiling Point in C
+			((ELEMENT.TIN.getProtons()*1)+(ELEMENT.COPPER.getProtons()*3))/4, //Protons
+			((ELEMENT.TIN.getNeutrons()*1)+(ELEMENT.COPPER.getNeutrons()*3))/4, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.COPPER, 75),
+					new MaterialStack(ELEMENT.TIN, 25)
+			});
+
+	public static final Material TUMBAGA = new Material(
+			"Tumbaga", //Material Name
+			new short[]{255,178,15, 0}, //Material Colour
+			((ELEMENT.GOLD.getMeltingPoint_C()*7)+(ELEMENT.COPPER.getMeltingPoint_C()*3))/10, //Melting point in C
+			0, //Boiling Point in C
+			((ELEMENT.GOLD.getProtons()*7)+(ELEMENT.COPPER.getProtons()*3))/10, //Protons
+			((ELEMENT.GOLD.getNeutrons()*7)+(ELEMENT.COPPER.getNeutrons()*3))/10, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.GOLD, 70),
+					new MaterialStack(ELEMENT.COPPER, 30)
+			});
+
+	public static final Material POTIN = new Material(
+			"Potin", //Material Name
+			new short[]{201,151,129, 0}, //Material Colour
+			((ELEMENT.LEAD.getMeltingPoint_C()*4)+(ALLOY.BRONZE.getMeltingPoint_C()*4)+(ELEMENT.TIN.getMeltingPoint_C()*2))/10, //Melting point in C
+			0, //Boiling Point in C
+			((ELEMENT.LEAD.getProtons()*4)+(ALLOY.BRONZE.getProtons()*4)+(ELEMENT.TIN.getProtons()*2))/10, //Protons
+			((ELEMENT.LEAD.getNeutrons()*4)+(ALLOY.BRONZE.getNeutrons()*4)+(ELEMENT.TIN.getNeutrons()*2))/10, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.LEAD, 40),
+					new MaterialStack(ALLOY.BRONZE, 40),
+					new MaterialStack(ELEMENT.TIN, 20)
+			});
+
+	public static final Material BEDROCKIUM = new Material(
+			"Bedrockium", //Material Name
+			new short[]{32, 32, 32, 0}, //Material Colour
+			7735, //Melting Point in C
+			0, //Boiling Point in C
+			100, //Protons
+			100, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			null);
+
+	public static final Material INCONEL_625 = new Material(
+			"Inconel-625", //Material Name
+			new short[]{128, 200, 128, 0}, //Material Colour
+			1425, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.NICKEL.getProtons()*6)+(ELEMENT.CHROMIUM.getProtons()*2)+(ELEMENT.IRON.getProtons()*1)+(ELEMENT.MOLYBDENUM.getProtons()*1))/10, //Protons
+			((ELEMENT.NICKEL.getNeutrons()*6)+(ELEMENT.CHROMIUM.getNeutrons()*2)+(ELEMENT.IRON.getNeutrons()*1)+(ELEMENT.MOLYBDENUM.getNeutrons()*1))/10, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.NICKEL, 60),
+					new MaterialStack(ELEMENT.CHROMIUM, 20),
+					new MaterialStack(ELEMENT.IRON, 10),
+					new MaterialStack(ELEMENT.MOLYBDENUM, 10)
+			});
+
+	public static final Material INCONEL_690 = new Material(
+			"Inconel-690", //Material Name
+			new short[]{118, 220, 138, 0}, //Material Colour
+			1425, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.NICKEL.getProtons()*6)+(ELEMENT.CHROMIUM.getProtons()*2)+(ELEMENT.NIOBIUM.getProtons()*1)+(ELEMENT.MOLYBDENUM.getProtons()*1))/10, //Protons
+			((ELEMENT.NICKEL.getNeutrons()*6)+(ELEMENT.CHROMIUM.getNeutrons()*2)+(ELEMENT.NIOBIUM.getNeutrons()*1)+(ELEMENT.MOLYBDENUM.getNeutrons()*1))/10, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.NICKEL, 60),
+					new MaterialStack(ELEMENT.CHROMIUM, 20),
+					new MaterialStack(ELEMENT.NIOBIUM, 10),
+					new MaterialStack(ELEMENT.MOLYBDENUM, 10)
+			});
+
+	public static final Material INCONEL_792 = new Material(
+			"Inconel-792", //Material Name
+			new short[]{108, 240, 118, 0}, //Material Colour
+			1425, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.NICKEL.getProtons()*6)+(ELEMENT.CHROMIUM.getProtons()*1)+(ELEMENT.IRON.getProtons()*1)+(ELEMENT.ALUMINIUM.getProtons()*2))/10, //Protons
+			((ELEMENT.NICKEL.getNeutrons()*6)+(ELEMENT.CHROMIUM.getNeutrons()*1)+(ELEMENT.IRON.getNeutrons()*1)+(ELEMENT.ALUMINIUM.getNeutrons()*2))/10, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.NICKEL, 60),
+					new MaterialStack(ELEMENT.CHROMIUM, 10),
+					new MaterialStack(ELEMENT.NIOBIUM, 10),
+					new MaterialStack(ELEMENT.ALUMINIUM, 20)
+			});
+	
+	public static final Material STEEL = new Material(
+			"Steel", //Material Name
+			new short[]{180, 180, 20, 0}, //Material Colour
+			((ELEMENT.CARBON.getMeltingPoint_C()*5)+(ELEMENT.IRON.getMeltingPoint_C()*95))/100, //Melting point in C
+			0, //Boiling Point in C
+			((ELEMENT.CARBON.getProtons()*5)+(ELEMENT.IRON.getProtons()*95))/100, //Protons
+			((ELEMENT.CARBON.getNeutrons()*5)+(ELEMENT.IRON.getNeutrons()*95))/100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.CARBON, 05),
+					new MaterialStack(ELEMENT.IRON, 95)
+			});
+
+	public static final Material ZERON_100 = new Material(
+			"Zeron-100", //Material Name
+			new short[]{180, 180, 20, 0}, //Material Colour
+			(((ELEMENT.CHROMIUM.getMeltingPoint_C()*25)+(ELEMENT.NICKEL.getMeltingPoint_C()*6)+(ELEMENT.COBALT.getMeltingPoint_C()*9)+(ALLOY.STEEL.getMeltingPoint_C()*60))/100), //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.CHROMIUM.getProtons()*25)+(ELEMENT.NICKEL.getProtons()*6)+(ELEMENT.COBALT.getProtons()*9)+(ALLOY.STEEL.getProtons()*60))/100, //Protons
+			((ELEMENT.CHROMIUM.getNeutrons()*25)+(ELEMENT.NICKEL.getNeutrons()*6)+(ELEMENT.COBALT.getNeutrons()*9)+(ALLOY.STEEL.getNeutrons()*60))/100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.CHROMIUM, 25),
+					new MaterialStack(ELEMENT.NICKEL, 6),
+					new MaterialStack(ELEMENT.COBALT, 9),
+					new MaterialStack(ALLOY.STEEL, 60)
+					});
+
+	public static final Material MARAGING250 = new Material(
+			"Maraging Steel 250", //Material Name
+			new short[]{140, 140, 140, 0}, //Material Colour
+			1413, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.TITANIUM.getProtons()*5)+(ELEMENT.NICKEL.getProtons()*16)+(ELEMENT.COBALT.getProtons()*9)+(ALLOY.STEEL.getProtons()*70))/100, //Protons
+			((ELEMENT.TITANIUM.getNeutrons()*5)+(ELEMENT.NICKEL.getNeutrons()*16)+(ELEMENT.COBALT.getNeutrons()*9)+(ALLOY.STEEL.getNeutrons()*70))/100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.TITANIUM, 5),
+					new MaterialStack(ELEMENT.NICKEL, 16),
+					new MaterialStack(ELEMENT.COBALT, 9),
+					new MaterialStack(ALLOY.STEEL, 70)
+			});
+
+	public static final Material MARAGING300 = new Material(
+			"Maraging Steel 300", //Material Name
+			new short[]{150, 150, 150, 0}, //Material Colour
+			1413, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.TITANIUM.getProtons()*10)+(ELEMENT.NICKEL.getProtons()*21)+(ELEMENT.COBALT.getProtons()*14)+(ALLOY.STEEL.getProtons()*55))/100, //Protons
+			((ELEMENT.TITANIUM.getNeutrons()*10)+(ELEMENT.NICKEL.getNeutrons()*21)+(ELEMENT.COBALT.getNeutrons()*14)+(ALLOY.STEEL.getNeutrons()*55))/100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.TITANIUM, 10),
+					new MaterialStack(ELEMENT.NICKEL, 21),
+					new MaterialStack(ELEMENT.COBALT, 14),
+					new MaterialStack(ALLOY.STEEL, 55)
+			});
+
+	public static final Material MARAGING350 = new Material(
+			"Maraging Steel 350", //Material Name
+			new short[]{160, 160, 160, 0}, //Material Colour
+			1413, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.TITANIUM.getProtons()*15)+(ELEMENT.NICKEL.getProtons()*21)+(ELEMENT.COBALT.getProtons()*9)+(ALLOY.STEEL.getProtons()*55))/100, //Protons
+			((ELEMENT.TITANIUM.getNeutrons()*15)+(ELEMENT.NICKEL.getNeutrons()*21)+(ELEMENT.COBALT.getNeutrons()*9)+(ALLOY.STEEL.getNeutrons()*55))/100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.TITANIUM, 15),
+					new MaterialStack(ELEMENT.NICKEL, 21),
+					new MaterialStack(ELEMENT.COBALT, 9),
+					new MaterialStack(ALLOY.STEEL, 55)
+			});
+
+	public static final Material STELLITE = new Material(
+			"Stellite", //Material Name
+			new short[]{129, 75, 120, 0}, //Material Colour
+			1310, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.TITANIUM.getProtons()*10)+(ELEMENT.CHROMIUM.getProtons()*35)+(ELEMENT.COBALT.getProtons()*35)+(ELEMENT.MANGANESE.getProtons()*20))/100, //Protons
+			((ELEMENT.TITANIUM.getNeutrons()*10)+(ELEMENT.CHROMIUM.getNeutrons()*35)+(ELEMENT.COBALT.getNeutrons()*35)+(ELEMENT.MANGANESE.getNeutrons()*20))/100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.COBALT, 35),
+					new MaterialStack(ELEMENT.CHROMIUM, 35),
+					new MaterialStack(ELEMENT.MANGANESE, 20),
+					new MaterialStack(ELEMENT.TITANIUM, 10)
+			});
+
+	public static final Material TALONITE = new Material(
+			"Talonite", //Material Name
+			new short[]{228, 75, 120, 0}, //Material Colour
+			1454, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.MOLYBDENUM.getProtons()*10)+(ELEMENT.CHROMIUM.getProtons()*30)+(ELEMENT.COBALT.getProtons()*40)+(ELEMENT.PHOSPHORUS.getProtons()*20))/100, //Protons
+			((ELEMENT.MOLYBDENUM.getNeutrons()*10)+(ELEMENT.CHROMIUM.getNeutrons()*30)+(ELEMENT.COBALT.getNeutrons()*40)+(ELEMENT.PHOSPHORUS.getNeutrons()*20))/100, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.COBALT, 40),
+					new MaterialStack(ELEMENT.CHROMIUM, 30),
+					new MaterialStack(ELEMENT.PHOSPHORUS, 20),
+					new MaterialStack(ELEMENT.MOLYBDENUM, 10)
+			});
+
+	public static final Material HASTELLOY_W = new Material(
+			"Hastelloy-W", //Material Name
+			new short[]{218, 165, 32, 0}, //Material Colour
+			1350, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.IRON.getProtons()*6)+(ELEMENT.MOLYBDENUM.getProtons()*24)+(ELEMENT.CHROMIUM.getProtons()*5)+(ELEMENT.NICKEL.getProtons()*65))/100, //Protons
+			((ELEMENT.IRON.getNeutrons()*6)+(ELEMENT.MOLYBDENUM.getNeutrons()*24)+(ELEMENT.CHROMIUM.getNeutrons()*5)+(ELEMENT.NICKEL.getNeutrons()*65))/100, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.IRON, 06),
+					new MaterialStack(ELEMENT.MOLYBDENUM, 24),
+					new MaterialStack(ELEMENT.CHROMIUM, 5),
+					new MaterialStack(ELEMENT.NICKEL, 65)
+			});
+
+	public static final Material HASTELLOY_X = new Material(
+			"Hastelloy-X", //Material Name
+			new short[]{255, 193, 37, 0}, //Material Colour
+			1350, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.IRON.getProtons()*18)+(ELEMENT.MOLYBDENUM.getProtons()*9)+(ELEMENT.CHROMIUM.getProtons()*22)+(ELEMENT.NICKEL.getProtons()*51))/100, //Protons
+			((ELEMENT.IRON.getNeutrons()*18)+(ELEMENT.MOLYBDENUM.getNeutrons()*9)+(ELEMENT.CHROMIUM.getNeutrons()*22)+(ELEMENT.NICKEL.getNeutrons()*51))/100, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.IRON, 18),
+					new MaterialStack(ELEMENT.MOLYBDENUM, 9),
+					new MaterialStack(ELEMENT.CHROMIUM, 22),
+					new MaterialStack(ELEMENT.NICKEL, 51)
+			});
+
+	public static final Material HASTELLOY_N = new Material(
+			"Hastelloy-N", //Material Name
+			new short[]{236, 213, 48, 0}, //Material Colour
+			1350, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.IRON.getProtons()*5)+(ELEMENT.MOLYBDENUM.getProtons()*16)+(ELEMENT.CHROMIUM.getProtons()*7)+(ELEMENT.NICKEL.getProtons()*72))/100, //Protons
+			((ELEMENT.IRON.getNeutrons()*5)+(ELEMENT.MOLYBDENUM.getNeutrons()*16)+(ELEMENT.CHROMIUM.getNeutrons()*7)+(ELEMENT.NICKEL.getNeutrons()*72))/100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.IRON, 05),
+					new MaterialStack(ELEMENT.MOLYBDENUM, 16),
+					new MaterialStack(ELEMENT.CHROMIUM, 7),
+					new MaterialStack(ELEMENT.NICKEL, 72)
+			});
+
+	public static final Material HASTELLOY_C276 = new Material(
+			"Hastelloy-C276", //Material Name
+			new short[]{238, 180, 34, 0}, //Material Colour
+			1350, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.COBALT.getProtons()*2)+(ELEMENT.MOLYBDENUM.getProtons()*16)+(ELEMENT.CHROMIUM.getProtons()*16)+(ELEMENT.NICKEL.getProtons()*66))/100, //Protons
+			((ELEMENT.COBALT.getNeutrons()*2)+(ELEMENT.MOLYBDENUM.getNeutrons()*16)+(ELEMENT.CHROMIUM.getNeutrons()*16)+(ELEMENT.NICKEL.getNeutrons()*66))/100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.COBALT, 02),
+					new MaterialStack(ELEMENT.MOLYBDENUM, 16),
+					new MaterialStack(ELEMENT.CHROMIUM, 16),
+					new MaterialStack(ELEMENT.NICKEL, 66)
+			});
+
+	public static final Material INCOLOY_020 = new Material(
+			"Incoloy-020", //Material Name
+			new short[]{101, 81, 71, 0}, //Material Colour
+			1425, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.IRON.getProtons()*40)+(ELEMENT.COPPER.getProtons()*4)+(ELEMENT.CHROMIUM.getProtons()*20)+(ELEMENT.NICKEL.getProtons()*36))/100, //Protons
+			((ELEMENT.IRON.getNeutrons()*40)+(ELEMENT.COPPER.getNeutrons()*4)+(ELEMENT.CHROMIUM.getNeutrons()*20)+(ELEMENT.NICKEL.getNeutrons()*36))/100, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.IRON, 40),
+					new MaterialStack(ELEMENT.COPPER, 4),
+					new MaterialStack(ELEMENT.CHROMIUM, 20),
+					new MaterialStack(ELEMENT.NICKEL, 36)
+			});
+
+	public static final Material INCOLOY_DS = new Material(
+			"Incoloy-DS", //Material Name
+			new short[]{71, 101, 81, 0}, //Material Colour
+			1425, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.IRON.getProtons()*46)+(ELEMENT.COBALT.getProtons()*18)+(ELEMENT.CHROMIUM.getProtons()*18)+(ELEMENT.NICKEL.getProtons()*18))/100, //Protons
+			((ELEMENT.IRON.getNeutrons()*46)+(ELEMENT.COBALT.getNeutrons()*18)+(ELEMENT.CHROMIUM.getNeutrons()*18)+(ELEMENT.NICKEL.getNeutrons()*18))/100, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.IRON, 46),
+					new MaterialStack(ELEMENT.COBALT, 18),
+					new MaterialStack(ELEMENT.CHROMIUM, 18),
+					new MaterialStack(ELEMENT.NICKEL, 18)
+			});
+
+	public static final Material INCOLOY_MA956 = new Material(
+			"Incoloy-MA956", //Material Name
+			new short[]{81, 71, 101, 0}, //Material Colour
+			1425, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.IRON.getProtons()*75)+(ELEMENT.ALUMINIUM.getProtons()*4)+(ELEMENT.CHROMIUM.getProtons()*20)+(ELEMENT.YTTRIUM.getProtons()*1))/100, //Protons
+			((ELEMENT.IRON.getNeutrons()*75)+(ELEMENT.ALUMINIUM.getNeutrons()*4)+(ELEMENT.CHROMIUM.getNeutrons()*20)+(ELEMENT.YTTRIUM.getNeutrons()*1))/100, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.IRON, 75),
+					new MaterialStack(ELEMENT.ALUMINIUM, 4),
+					new MaterialStack(ELEMENT.CHROMIUM, 20),
+					new MaterialStack(ELEMENT.YTTRIUM, 1)
+			});
+
+	public static final Material TUNGSTEN_CARBIDE = new Material(
+			"Tungsten Carbide", //Material Name
+			new short[]{44, 44, 44, 0}, //Material Colour
+			3422, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.TUNGSTEN.getProtons()*5)+(ELEMENT.CARBON.getProtons()*5))/10, //Protons
+			((ELEMENT.TUNGSTEN.getNeutrons()*5)+(ELEMENT.CARBON.getNeutrons()*5))/10, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.CARBON, 50),
+					new MaterialStack(ELEMENT.TUNGSTEN, 50)
+			});
+
+	public static final Material SILICON_CARBIDE = new Material(
+			"Silicon Carbide", //Material Name
+			new short[]{40, 48, 36, 0}, //Material Colour
+			1414, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.SILICON.getProtons()*5)+(ELEMENT.CARBON.getProtons()*5))/10, //Protons
+			((ELEMENT.SILICON.getNeutrons()*5)+(ELEMENT.CARBON.getNeutrons()*5))/10, //Neutrons
+			false, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.CARBON, 50),
+					new MaterialStack(ELEMENT.SILICON, 50)
+			});
+
+	public static final Material TANTALUM_CARBIDE = new Material(
+			"Tantalum Carbide", //Material Name
+			new short[]{139, 136, 120, 0}, //Material Colour
+			2980, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.TANTALUM.getProtons()*5)+(ELEMENT.CARBON.getProtons()*5))/10, //Protons
+			((ELEMENT.TANTALUM.getNeutrons()*5)+(ELEMENT.CARBON.getNeutrons()*5))/10, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.CARBON, 50),
+					new MaterialStack(ELEMENT.TANTALUM, 50)
+			});
+
+	public static final Material ZIRCONIUM_CARBIDE = new Material(
+			"Zirconium Carbide", //Material Name
+			new short[]{222, 202, 180, 0}, //Material Colour
+			1855, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.ZIRCONIUM.getProtons()*5)+(ELEMENT.CARBON.getProtons()*5))/10, //Protons
+			((ELEMENT.ZIRCONIUM.getNeutrons()*5)+(ELEMENT.CARBON.getNeutrons()*5))/10, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.CARBON, 50),
+					new MaterialStack(ELEMENT.ZIRCONIUM, 50)
+			});
+
+	public static final Material NIOBIUM_CARBIDE = new Material(
+			"Niobium Carbide", //Material Name
+			new short[]{205, 197, 191, 0}, //Material Colour
+			2477, //Melting Point in C
+			0, //Boiling Point in C
+			((ELEMENT.NIOBIUM.getProtons()*5)+(ELEMENT.CARBON.getProtons()*5))/10, //Protons
+			((ELEMENT.NIOBIUM.getNeutrons()*5)+(ELEMENT.CARBON.getNeutrons()*5))/10, //Neutrons
+			true, //Uses Blast furnace?
+			//Material Stacks with Percentage of required elements.
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.CARBON, 50),
+					new MaterialStack(ELEMENT.NIOBIUM, 50)
+			});
+
+
+}
diff --git a/src/Java/gtPlusPlus/core/material/ELEMENT.java b/src/Java/gtPlusPlus/core/material/ELEMENT.java
new file mode 100644
index 0000000000..5022e8676b
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/material/ELEMENT.java
@@ -0,0 +1,85 @@
+package gtPlusPlus.core.material;
+
+import gregtech.api.enums.Materials;
+import gtPlusPlus.core.util.materials.MaterialUtils;
+
+public class ELEMENT {
+
+
+	//First 50 Elements
+	public static final Material HYDROGEN = MaterialUtils.generateMaterialFromGtENUM(Materials.Hydrogen);
+	public static final Material HELIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Helium);
+	public static final Material LITHIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Lithium);
+	public static final Material BERYLLIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Beryllium);
+	public static final Material BORON = MaterialUtils.generateMaterialFromGtENUM(Materials.Boron);
+	public static final Material CARBON = MaterialUtils.generateMaterialFromGtENUM(Materials.Carbon);
+	public static final Material NITROGEN = MaterialUtils.generateMaterialFromGtENUM(Materials.Nitrogen);
+	public static final Material OXYGEN = MaterialUtils.generateMaterialFromGtENUM(Materials.Oxygen);
+	public static final Material FLUORINE = MaterialUtils.generateMaterialFromGtENUM(Materials.Fluorine);
+	//public static final Material NEON = MaterialUtils.generateMaterialFromGtENUM(Materials.Ne);
+	public static final Material SODIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Sodium);
+	public static final Material MAGNESIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Magnesium);
+	public static final Material ALUMINIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Aluminium);
+	public static final Material SILICON = MaterialUtils.generateMaterialFromGtENUM(Materials.Silicon);
+	public static final Material PHOSPHORUS = MaterialUtils.generateMaterialFromGtENUM(Materials.Phosphorus);
+	public static final Material SULFUR = MaterialUtils.generateMaterialFromGtENUM(Materials.Sulfur);
+	public static final Material CHLORINE = MaterialUtils.generateMaterialFromGtENUM(Materials.Chlorine);
+	public static final Material ARGON = MaterialUtils.generateMaterialFromGtENUM(Materials.Argon);
+	public static final Material POTASSIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Potassium);
+	public static final Material CALCIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Calcium);
+	public static final Material SCANDIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Scandium);
+	public static final Material TITANIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Titanium);
+	public static final Material VANADIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Vanadium);
+	public static final Material CHROMIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Chromium);
+	public static final Material MANGANESE = MaterialUtils.generateMaterialFromGtENUM(Materials.Manganese);
+	public static final Material IRON = MaterialUtils.generateMaterialFromGtENUM(Materials.Iron);
+	public static final Material COBALT = MaterialUtils.generateMaterialFromGtENUM(Materials.Cobalt);
+	public static final Material NICKEL = MaterialUtils.generateMaterialFromGtENUM(Materials.Nickel);
+	public static final Material COPPER = MaterialUtils.generateMaterialFromGtENUM(Materials.Copper);
+	public static final Material ZINC = MaterialUtils.generateMaterialFromGtENUM(Materials.Zinc);
+	public static final Material GALLIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Gallium);
+	//public static final Material GERMANIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Germanium);
+	public static final Material ARSENIC = MaterialUtils.generateMaterialFromGtENUM(Materials.Arsenic);
+	//public static final Material SELENIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Selenium);
+	//public static final Material BROMINE = MaterialUtils.generateMaterialFromGtENUM(Materials.Bromine);
+	//public static final Material KRYPTON = MaterialUtils.generateMaterialFromGtENUM(Materials.Krypton);
+	public static final Material RUBIDIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Rubidium);
+	public static final Material STRONTIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Strontium);
+	public static final Material YTTRIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Yttrium);
+	public static final Material ZIRCONIUM = new Material("Zirconium", new short[]{255, 250, 205}, 1855, 4377, 40, 51, false, null);//Not a GT Inherited Material
+	public static final Material NIOBIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Niobium);
+	public static final Material MOLYBDENUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Molybdenum);
+	//public static final Material TECHNETIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Technetium);
+	//public static final Material RUTHENIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Ruthenium);
+	//public static final Material RHODIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Rhodium);
+	public static final Material PALLADIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Palladium);
+	public static final Material SILVER = MaterialUtils.generateMaterialFromGtENUM(Materials.Silver);
+	public static final Material CADMIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Cadmium);
+	public static final Material INDIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Indium);
+	public static final Material TIN = MaterialUtils.generateMaterialFromGtENUM(Materials.Tin);
+
+
+
+
+
+
+
+
+
+	//Second 50 elements
+	public static final Material TANTALUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Tantalum);
+	public static final Material TUNGSTEN = MaterialUtils.generateMaterialFromGtENUM(Materials.Tungsten);
+	public static final Material OSMIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Osmium);
+	public static final Material IRIDIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Iridium);	
+	public static final Material PLATINUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Platinum);	
+	public static final Material GOLD = MaterialUtils.generateMaterialFromGtENUM(Materials.Gold);	
+	public static final Material LEAD = MaterialUtils.generateMaterialFromGtENUM(Materials.Lead);	
+	public static final Material BISMUTH = MaterialUtils.generateMaterialFromGtENUM(Materials.Bismuth);	
+	public static final Material RADON = MaterialUtils.generateMaterialFromGtENUM(Materials.Radon);	
+	public static final Material THORIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Thorium);	
+	public static final Material URANIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Uranium);	
+	public static final Material PLUTONIUM = MaterialUtils.generateMaterialFromGtENUM(Materials.Plutonium);	
+	public static final Material URANIUM233 = new Material("Uranium-233", new short[]{73, 220, 83, 0}, 1132, 4131, 92, 141, false,	null);//Not a GT Inherited Material
+
+
+}
diff --git a/src/Java/gtPlusPlus/core/material/Material.java b/src/Java/gtPlusPlus/core/material/Material.java
new file mode 100644
index 0000000000..4ce496bb22
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/material/Material.java
@@ -0,0 +1,80 @@
+package gtPlusPlus.core.material;
+
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.item.UtilsItems;
+import gtPlusPlus.core.util.math.MathUtils;
+import net.minecraft.item.ItemStack;
+
+public class Material {
+
+	final String unlocalizedName;
+	final String localizedName;
+
+	final public MaterialStack[] materialInput = null;
+
+	final public short[] RGBA;
+
+	final boolean usesBlastFurnace;
+
+	final int meltingPointK;
+	final int boilingPointK;
+	final int meltingPointC;
+	final int boilingPointC;
+	final long vProtons;
+	final long vNeutrons;
+	final long vMass;
+
+	public Material(String materialName, short[] rgba, int meltingPoint, int boilingPoint, long protons, long neutrons, boolean blastFurnace, MaterialStack[] inputs){
+
+		this.unlocalizedName = Utils.sanitizeString(materialName);
+		this.localizedName = materialName;
+		this.RGBA = rgba;
+		this.meltingPointC = meltingPoint;
+		if (boilingPoint == 0){
+			boilingPoint = meltingPoint*4;
+		}
+		this.boilingPointC = boilingPoint;
+		this.meltingPointK = (int) MathUtils.celsiusToKelvin(meltingPointC);
+		this.boilingPointK = (int) MathUtils.celsiusToKelvin(boilingPointC);
+		this.vProtons = protons;
+		this.vNeutrons = neutrons;
+		this.vMass = getMass();
+		this.usesBlastFurnace = blastFurnace;
+
+		for (int i=0; i < inputs.length; i++){
+			if (inputs[i] != null){
+				materialInput[i] = inputs[i];
+			}
+		}
+
+	}
+	
+	public long getProtons() {
+        return vProtons;
+    }
+
+    public long getNeutrons() {
+        return vNeutrons;
+    }
+
+    public long getMass() {
+        return vProtons + vNeutrons;
+    }
+    
+    public int getMeltingPoint_C() {
+        return meltingPointC;
+    }
+    
+    public int getBoilingPoint_C() {
+        return boilingPointC;
+    }
+
+	public ItemStack getDust(){
+		return UtilsItems.getItemStackOfAmountFromOreDictNoBroken("dust"+unlocalizedName, 1);
+	}
+
+	public ItemStack[] getValidInputStacks(){
+		return UtilsItems.validItemsForOreDict(unlocalizedName);
+	}
+	
+}
diff --git a/src/Java/gtPlusPlus/core/material/MaterialStack.java b/src/Java/gtPlusPlus/core/material/MaterialStack.java
new file mode 100644
index 0000000000..ad3aa2fa76
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/material/MaterialStack.java
@@ -0,0 +1,66 @@
+package gtPlusPlus.core.material;
+
+import gtPlusPlus.core.util.item.UtilsItems;
+import net.minecraft.item.ItemStack;
+
+public class MaterialStack {
+	
+	final Material materialInput;
+	final double percentageToUse;
+	
+	public MaterialStack(Material inputs, int percentage){
+
+		this.materialInput = inputs;
+		this.percentageToUse = percentage;
+		
+		
+	}
+	
+	public ItemStack getDustStack(){
+		int caseStatus = 0;
+		int amount = 0;
+		if (percentageToUse >= 0 && percentageToUse <= 0.99){
+			caseStatus = 1;
+			amount = Integer.valueOf(String.valueOf(percentageToUse).charAt(2));
+		}
+		else if (percentageToUse >= 1 && percentageToUse <= 9.99){
+			caseStatus = 2;
+			amount = Integer.valueOf(String.valueOf(percentageToUse).charAt(0));
+		}
+		else if (percentageToUse >= 10 && percentageToUse <= 99.99){
+			caseStatus = 3;
+			amount = Integer.valueOf(String.valueOf(percentageToUse).charAt(0));
+		}
+		else if (percentageToUse == 100){
+			caseStatus = 4;
+			amount = 10;
+		}
+		switch (caseStatus) {		
+		case 1:	{
+			return UtilsItems.getItemStackOfAmountFromOreDictNoBroken("dustTiny"+materialInput.unlocalizedName, amount);
+		}
+		case 2: {
+			return UtilsItems.getItemStackOfAmountFromOreDictNoBroken("dustSmall"+materialInput.unlocalizedName, amount);
+		}
+		case 3: {
+			return UtilsItems.getItemStackOfAmountFromOreDictNoBroken("dust"+materialInput.unlocalizedName, amount);
+		}
+		case 4: {
+			return UtilsItems.getItemStackOfAmountFromOreDictNoBroken("dust"+materialInput.unlocalizedName, amount);
+		}
+		default:
+			return null;
+		}
+		
+	}
+	
+	public ItemStack[] getValidItemStacks(){
+		return UtilsItems.validItemsForOreDict(materialInput.unlocalizedName);
+	}
+	
+	
+	
+	
+	
+
+}
diff --git a/src/Java/gtPlusPlus/core/util/Utils.java b/src/Java/gtPlusPlus/core/util/Utils.java
index 72c4632df2..42d6dc4ad4 100644
--- a/src/Java/gtPlusPlus/core/util/Utils.java
+++ b/src/Java/gtPlusPlus/core/util/Utils.java
@@ -213,10 +213,10 @@ public class Utils {
 
 	/**
 	 * 
-	 * @param colorStr e.g. "#FFFFFF"
+	 * @param colourStr e.g. "#FFFFFF"
 	 * @return String - formatted "rgb(0,0,0)"
 	 */
-	public static String hex2Rgb(String hexString) {
+	public static String hex2RgbFormatted(String hexString) {
 		Color c = new Color(
 				Integer.valueOf(hexString.substring(1, 3), 16), 
 				Integer.valueOf(hexString.substring(3, 5), 16), 
@@ -232,6 +232,38 @@ public class Utils {
 		sb.append(")");
 		return sb.toString();
 	}
+	
+	/**
+	 * 
+	 * @param colourStr e.g. "#FFFFFF"
+	 * @return 
+	 */
+	public static Color hex2Rgb(String colorStr) {
+	    return new Color(
+	            Integer.valueOf( colorStr.substring( 1, 3 ), 16 ),
+	            Integer.valueOf( colorStr.substring( 3, 5 ), 16 ),
+	            Integer.valueOf( colorStr.substring( 5, 7 ), 16 ) );
+	}
+	
+	/**
+	 * 
+	 * @param colourInt e.g. 0XFFFFFF
+	 * @return Colour
+	 */
+	public static Color hex2Rgb(int colourInt) {		
+	    return Color.decode(String.valueOf(colourInt));
+	}
+	
+	/**
+	 * 
+	 * @param colourInt e.g. 0XFFFFFF
+	 * @return short[]
+	 */
+	public static short[] hex2RgbShort(int colourInt) {
+		Color rgb = Color.decode(String.valueOf(colourInt));
+		short[] rgba = {(short) rgb.getRed(), (short) rgb.getGreen(), (short) rgb.getBlue(), (short) rgb.getAlpha()};
+		return rgba;
+	}
 
 	public static Timer ShortTimer(int seconds) {
 		Timer timer;
@@ -259,6 +291,11 @@ public class Utils {
 		List<Object> targetList = new ArrayList<Object>(Arrays.asList(sourceArray));
 		return targetList;
 	}
+	
+	public static List<Object> convertArrayListToList(ArrayList sourceArray) {
+		List<Object> targetList = new ArrayList<Object>(Arrays.asList(sourceArray));
+		return targetList;
+	}
 
 	public static EntityPlayer getPlayerOnServerFromUUID(UUID parUUID){
 		if (parUUID == null) 
@@ -524,6 +561,7 @@ public class Utils {
 		temp = temp.replace("}", "");
 		temp = temp.replace("[", "");
 		temp = temp.replace("]", "");
+		temp = temp.replace(" ", "");
 		output = temp;		
 		return output;
 		
diff --git a/src/Java/gtPlusPlus/core/util/fluid/FluidUtils.java b/src/Java/gtPlusPlus/core/util/fluid/FluidUtils.java
index 53873c6e4e..fff0cbad71 100644
--- a/src/Java/gtPlusPlus/core/util/fluid/FluidUtils.java
+++ b/src/Java/gtPlusPlus/core/util/fluid/FluidUtils.java
@@ -1,8 +1,19 @@
 package gtPlusPlus.core.util.fluid;
 
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.util.GT_LanguageManager;
+import gtPlusPlus.core.fluids.GenericFluid;
 import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import net.minecraft.init.Items;
+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.fluids.IFluidContainerItem;
 
 public class FluidUtils {
 
@@ -16,7 +27,7 @@ public class FluidUtils {
 		}
 
 	}
-	
+
 	public static FluidStack[] getFluidStackArray(String fluidName, int amount){
 		Utils.LOG_WARNING("Trying to get a fluid stack of "+fluidName);
 		try {
@@ -28,7 +39,7 @@ public class FluidUtils {
 		}
 
 	}
-	
+
 	public static FluidStack[] getFluidStackArray(FluidStack fluidName, int amount){
 		Utils.LOG_WARNING("Trying to get a fluid stack of "+fluidName);
 		try {
@@ -41,4 +52,189 @@ public class FluidUtils {
 
 	}
 	
+	public static Fluid generateFluid(String fluidName, int tempK, short[] rgba ,byte aState){
+		Fluid generatedFluid = null;
+		switch (aState) {
+		case 0: {
+			generatedFluid = new GenericFluid(fluidName, 0, 100, tempK, 10000, false, rgba);
+			break;
+		}
+		default:
+		case 1:
+		case 4: {
+			generatedFluid = new GenericFluid(fluidName, 0, 100, tempK, 1000, false, rgba);
+			break;
+		}
+		case 2: {
+			generatedFluid = new GenericFluid(fluidName, 0, -100, tempK, 200, true, rgba);
+			break;
+		}
+		case 3: {
+			generatedFluid = new GenericFluid(fluidName, 15, -10000, tempK, 10, true, rgba);
+			break;
+		}
+		}
+		return generatedFluid;
+	}
+	
+
+	public static Fluid addAutogeneratedMoltenFluid(String materialNameFormatted, short[] rgba, int MeltingPoint) {
+		return addFluid("molten." + materialNameFormatted.toLowerCase(), "molten.autogenerated", "Molten " + materialNameFormatted, null, rgba, 1, (MeltingPoint <= 0L) ? 1000L : MeltingPoint, null, null, 0);
+	}	
+	
+	public static Fluid addAutogeneratedMoltenFluid(final GT_Materials aMaterial) {
+		return addFluid("molten." + aMaterial.name().toLowerCase(), "molten.autogenerated", "Molten " + aMaterial.name(), aMaterial, aMaterial.mMoltenRGBa, 1, (aMaterial.mMeltingPoint <= 0L) ? 1000L : aMaterial.mMeltingPoint, null, null, 0);
+	}
+
+	public static Fluid addFluid(final String aName, final String aLocalized, final GT_Materials aMaterial, final int aState, final long aTemperatureK) {
+		return addFluid(aName, aLocalized, aMaterial, aState, aTemperatureK, null, null, 0);
+	}
+
+	public static Fluid addFluid(final String aName, final String aLocalized, final GT_Materials aMaterial, final int aState, final long aTemperatureK, final ItemStack aFullContainer, final ItemStack aEmptyContainer, final int aFluidAmount) {
+		return addFluid(aName, aName.toLowerCase(), aLocalized, aMaterial, null, aState, aTemperatureK, aFullContainer, aEmptyContainer, aFluidAmount);
+	}
+
+	public static Fluid addFluid(String aName, final String aTexture, final String aLocalized, final GT_Materials aMaterial, final short[] aRGBa, final int aState, final long aTemperatureK, final ItemStack aFullContainer, final ItemStack aEmptyContainer, final int aFluidAmount) {
+		aName = Utils.sanitizeString(aName.toLowerCase());
+		Fluid rFluid = new FluidGT6(aName, aTexture, (aRGBa != null) ? aRGBa : Dyes._NULL.getRGBA());
+		GT_LanguageManager.addStringLocalization(rFluid.getUnlocalizedName(), (aLocalized == null) ? aName : aLocalized);
+		if (FluidRegistry.registerFluid(rFluid)) {
+			switch (aState) {
+			case 0: {
+				rFluid.setGaseous(false);
+				rFluid.setViscosity(10000);
+				break;
+			}
+			case 1:
+			case 4: {
+				rFluid.setGaseous(false);
+				rFluid.setViscosity(1000);
+				break;
+			}
+			case 2: {
+				rFluid.setGaseous(true);
+				rFluid.setDensity(-100);
+				rFluid.setViscosity(200);
+				break;
+			}
+			case 3: {
+				rFluid.setGaseous(true);
+				rFluid.setDensity(-10000);
+				rFluid.setViscosity(10);
+				rFluid.setLuminosity(15);
+				break;
+			}
+			}
+		}
+		else {
+			rFluid = FluidRegistry.getFluid(aName);
+		}
+		if (rFluid.getTemperature() == new Fluid("test").getTemperature() || rFluid.getTemperature() <= 0) {
+			rFluid.setTemperature((int) (aTemperatureK));
+		}
+		if (aMaterial != null) {
+			switch (aState) {
+			case 1: {
+				aMaterial.mFluid = (rFluid);
+				break;
+			}
+			case 2: {
+				aMaterial.mGas = (rFluid);
+				break;
+			}
+			case 3: {
+				aMaterial.mPlasma = (rFluid);
+				break;
+			}
+			}
+		}
+		if (aFullContainer != null && aEmptyContainer != null && !FluidContainerRegistry.registerFluidContainer(new FluidStack(rFluid, aFluidAmount), aFullContainer, aEmptyContainer)) {
+			GT_Values.RA.addFluidCannerRecipe(aFullContainer, container(aFullContainer, false), null, new FluidStack(rFluid, aFluidAmount));
+		}
+		return rFluid;
+	}
+
+	public static boolean valid(final Object aStack) {
+		return aStack != null && aStack instanceof ItemStack && ((ItemStack)aStack).getItem() != null && ((ItemStack)aStack).stackSize >= 0;
+	}
+
+	public static boolean invalid(final Object aStack) {
+		return aStack == null || !(aStack instanceof ItemStack) || ((ItemStack)aStack).getItem() == null || ((ItemStack)aStack).stackSize < 0;
+	}
+
+	public static boolean equal(final ItemStack aStack1, final ItemStack aStack2) {
+		return equal(aStack1, aStack2, false);
+	}
+
+	public static boolean equal(final ItemStack aStack1, final ItemStack aStack2, final boolean aIgnoreNBT) {
+		return aStack1 != null && aStack2 != null && equal_(aStack1, aStack2, aIgnoreNBT);
+	}
+
+	public static boolean equal_(final ItemStack aStack1, final ItemStack aStack2, final boolean aIgnoreNBT) {
+		return aStack1.getItem() == aStack2.getItem() && (aIgnoreNBT || (aStack1.getTagCompound() == null == (aStack2.getTagCompound() == null) && (aStack1.getTagCompound() == null || aStack1.getTagCompound().equals((Object)aStack2.getTagCompound())))) && (meta(aStack1) == meta(aStack2) || meta(aStack1) == 32767 || meta(aStack2) == 32767);
+	}
+
+	public static ItemStack copy(final Object... aStacks) {
+		for (final Object tStack : aStacks) {
+			if (valid(tStack)) {
+				return ((ItemStack)tStack).copy();
+			}
+		}
+		return null;
+	}
+
+	public static ItemStack copyMeta(final long aMetaData, final Object... aStacks) {
+		final ItemStack rStack = copy(aStacks);
+		if (invalid(rStack)) {
+			return null;
+		}
+		return meta(rStack, aMetaData);
+	}
+
+	public static short meta(final ItemStack aStack) {
+		return (short)Items.feather.getDamage(aStack);
+	}
+
+	public static ItemStack meta(final ItemStack aStack, final long aMeta) {
+		Items.feather.setDamage(aStack, (int)(short)aMeta);
+		return aStack;
+	}
+
+	public static ItemStack amount(final long aAmount, final Object... aStacks) {
+		final ItemStack rStack = copy(aStacks);
+		if (invalid(rStack)) {
+			return null;
+		}
+		rStack.stackSize = (int)aAmount;
+		return rStack;
+	}
+
+	public static ItemStack container(final ItemStack aStack, final boolean aCheckIFluidContainerItems) {
+		if (invalid(aStack)) {
+			return null;
+		}
+		if (aStack.getItem().hasContainerItem(aStack)) {
+			return aStack.getItem().getContainerItem(aStack);
+		}
+		if (equal(aStack, ItemList.Cell_Empty.get(1), true)) {
+			return null;
+		}
+		if (aCheckIFluidContainerItems && aStack.getItem() instanceof IFluidContainerItem && ((IFluidContainerItem)aStack.getItem()).getCapacity(aStack) > 0) {
+			final ItemStack tStack = amount(1L, aStack);
+			((IFluidContainerItem)aStack.getItem()).drain(tStack, Integer.MAX_VALUE, true);
+			if (!equal(aStack, tStack)) {
+				return tStack;
+			}
+			return null;
+		}
+		if (equal(aStack, ItemList.IC2_ForgeHammer.get(1)) || equal(aStack, ItemList.IC2_WireCutter.get(1))) {
+			return copyMeta(meta(aStack) + 1, aStack);
+		}
+		return null;
+	}
+
+	public static ItemStack container(final ItemStack aStack, final boolean aCheckIFluidContainerItems, final int aStacksize) {
+		return amount(aStacksize, container(aStack, aCheckIFluidContainerItems));
+	}
+
 }
diff --git a/src/Java/gtPlusPlus/core/util/item/UtilsItems.java b/src/Java/gtPlusPlus/core/util/item/UtilsItems.java
index d68174f7bb..ab8829b7af 100644
--- a/src/Java/gtPlusPlus/core/util/item/UtilsItems.java
+++ b/src/Java/gtPlusPlus/core/util/item/UtilsItems.java
@@ -24,9 +24,12 @@ import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.lib.LoadedMods;
 import gtPlusPlus.core.lib.MaterialInfo;
 import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.fluid.FluidUtils;
+import gtPlusPlus.core.util.materials.MaterialUtils;
 import gtPlusPlus.core.util.wrapper.var;
 
 import java.util.ArrayList;
+import java.util.List;
 
 import net.minecraft.block.Block;
 import net.minecraft.client.Minecraft;
@@ -39,34 +42,9 @@ import cpw.mods.fml.common.registry.GameRegistry;
 
 public class UtilsItems {
 
-	public static ItemStack getItemStackOfItem(Boolean modToCheck, String mod_itemname_meta){
-		if (modToCheck){
-			try{
-				Item em = null;
-
-				Item em1 = getItem(mod_itemname_meta);
-				Utils.LOG_WARNING("Found: "+em1.toString());
-				if (em1 != null){
-					em = em1;
-				}						
-				if (em != null ){
-					ItemStack returnStack = new ItemStack(em,1);				
-					return returnStack;
-				}
-				Utils.LOG_WARNING(mod_itemname_meta+" not found.");
-				return null;
-			} catch (NullPointerException e) {
-				Utils.LOG_ERROR(mod_itemname_meta+" not found. [NULL]");
-				return null;
-			}
-		}
-		return null;
-	}
-
 	public static ItemStack getSimpleStack(Item x){
 		return getSimpleStack(x, 1);
 	}
-
 	public static ItemStack getSimpleStack(Item x, int i){
 		try {
 			ItemStack r = new ItemStack(x, i);
@@ -75,7 +53,6 @@ public class UtilsItems {
 			return null;
 		}
 	}
-	
 	public static ItemStack getSimpleStack(ItemStack x, int i){
 		try {
 			ItemStack r = x.copy();
@@ -252,6 +229,16 @@ public class UtilsItems {
 		Item itemSpawnEgg = new BasicSpawnEgg(entityModID, parSpawnName, colourEgg, colourOverlay).setUnlocalizedName("spawn_egg_"+parSpawnName.toLowerCase()).setTextureName(CORE.MODID+":spawn_egg");
 		GameRegistry.registerItem(itemSpawnEgg, "spawnEgg"+parSpawnName);
 	}
+	
+
+	public static ItemStack[] validItemsForOreDict(String oredictName){
+		List<?> validNames = MaterialUtils.oreDictValuesForEntry(oredictName);
+		ItemStack[] inputs = null;
+		for (int i=0; i<validNames.size();i++){
+			inputs[i] = (ItemStack) validNames.get(i);
+		}
+		return inputs;		
+	}
 
 	public static ItemStack getItemStackOfAmountFromOreDict(String oredictName, int amount){
 		ArrayList<ItemStack> oreDictList = OreDictionary.getOres(oredictName);
@@ -326,7 +313,9 @@ public class UtilsItems {
 			temp = new BaseItemScrew("itemScrew"+unlocalizedName, materialName, Colour, materialTier);
 			temp = new BaseItemRotor("itemRotor"+unlocalizedName, materialName, Colour);
 			temp = new BaseItemGear("itemGear"+unlocalizedName, materialName, Colour, materialTier);
-		}
+		}		
+
+		FluidUtils.addAutogeneratedMoltenFluid(materialName, Utils.hex2RgbShort(Colour), 512);
 		
 	}
 	
diff --git a/src/Java/gtPlusPlus/core/util/materials/MaterialUtils.java b/src/Java/gtPlusPlus/core/util/materials/MaterialUtils.java
index 69548eb49a..0eae02d827 100644
--- a/src/Java/gtPlusPlus/core/util/materials/MaterialUtils.java
+++ b/src/Java/gtPlusPlus/core/util/materials/MaterialUtils.java
@@ -5,12 +5,15 @@ import gregtech.api.enums.Materials;
 import gregtech.api.enums.TC_Aspects.TC_AspectStack;
 import gregtech.api.enums.TextureSet;
 import gregtech.api.objects.MaterialStack;
-import gtPlusPlus.core.lib.MaterialInfo;
+import gtPlusPlus.core.material.Material;
 import gtPlusPlus.core.util.Utils;
 
+import java.util.ArrayList;
 import java.util.List;
 
+import net.minecraft.item.ItemStack;
 import net.minecraftforge.common.util.EnumHelper;
+import net.minecraftforge.oredict.OreDictionary;
 
 public class MaterialUtils {
 	
@@ -31,6 +34,27 @@ public class MaterialUtils {
 				aColor, aExtraData, aMaterialList, aAspects);
 		}
 	
+	public static List<?> oreDictValuesForEntry(String oredictName){
+		List<?> oredictItemNames;
+		if(OreDictionary.doesOreNameExist(oredictName)){
+			ArrayList<ItemStack> oredictItems = OreDictionary.getOres(oredictName);
+			oredictItemNames = Utils.convertArrayListToList(oredictItems);
+			return oredictItemNames;
+		}		
+		return null;
+	}
+	
+	public static Material generateMaterialFromGtENUM(Materials material){
+		String name = material.name();
+		short[] rgba = material.mRGBa;
+		int melting = material.mMeltingPoint;
+		int boiling = material.mBlastFurnaceTemp;
+		long protons = material.getProtons();
+		long neutrons = material.getNeutrons();
+		boolean blastFurnace = material.mBlastFurnaceRequired;		
+		return new Material(name, rgba, melting, boiling, protons, neutrons, blastFurnace, null);
+	}
+	
 
 	/*
 	 * That's shown, many times, in the EnumHelper code, all the add functions just wrap the addEnum function.
@@ -50,7 +74,7 @@ public class MaterialUtils {
 
 	
 
-	public static Materials GenerateGtMaterialForSingleUse(MaterialInfo s){
+	/*public static Materials GenerateGtMaterialForSingleUse(MaterialInfo s){
 
 		Materials yourName = EnumHelper.addEnum(
 
@@ -66,10 +90,10 @@ public class MaterialUtils {
 
 
 
-			/*Class<? extends ItemCell> clz = item.getClass();
+			Class<? extends ItemCell> clz = item.getClass();
 			Method methode = clz.getDeclaredMethod("addCell", int.class, InternalName.class, Block[].class);
 			methode.setAccessible(true);
-			ItemStack temp = (ItemStack) methode.invoke(item, cellID++, yourName, new Block[0]);*/
+			ItemStack temp = (ItemStack) methode.invoke(item, cellID++, yourName, new Block[0]);
 
 
 
@@ -82,6 +106,6 @@ public class MaterialUtils {
 			e.printStackTrace();
 		}
 		return null;
-	}
+	}*/
 
 }
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/Meta_GT_Proxy.java b/src/Java/gtPlusPlus/xmod/gregtech/common/Meta_GT_Proxy.java
index 5777e8de03..15bd666b53 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/Meta_GT_Proxy.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/Meta_GT_Proxy.java
@@ -12,7 +12,6 @@ import gregtech.api.enums.TC_Aspects;
 import gregtech.api.enums.ToolDictNames;
 import gregtech.api.objects.ItemData;
 import gregtech.api.objects.MaterialStack;
-import gregtech.api.util.GT_LanguageManager;
 import gregtech.api.util.GT_Log;
 import gregtech.api.util.GT_OreDictUnificator;
 import gregtech.api.util.GT_Recipe;
@@ -23,7 +22,6 @@ import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes;
 import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
-import gtPlusPlus.xmod.gregtech.api.objects.GregtechFluid;
 import gtPlusPlus.xmod.gregtech.api.util.GregtechOreDictUnificator;
 import gtPlusPlus.xmod.gregtech.api.util.GregtechRecipeRegistrator;
 import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechItems;
@@ -38,10 +36,6 @@ import java.util.List;
 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;
@@ -108,7 +102,7 @@ public class Meta_GT_Proxy {
 		}
 	}
 
-	public static Fluid addFluid(String aName, String aLocalized, GT_Materials aMaterial, int aState, int aTemperatureK) {
+	/*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);
 	}
 
@@ -173,7 +167,7 @@ public class Meta_GT_Proxy {
 			GT_Values.RA.addFluidCannerRecipe(aFullContainer, GT_Utility.getContainerItem(aFullContainer, false), null, new FluidStack(rFluid, aFluidAmount));
 		}
 		return rFluid;
-	}
+	}*/
 
 	@SubscribeEvent
 	public static void registerOre2(OreDictionary.OreRegisterEvent aEvent) {
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/fluid/GregtechFluidHandler.java b/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/fluid/GregtechFluidHandler.java
index cfb0e1d984..b30b0144bc 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/fluid/GregtechFluidHandler.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/fluid/GregtechFluidHandler.java
@@ -9,7 +9,6 @@ import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.core.util.fluid.FluidUtils;
 import gtPlusPlus.core.util.item.UtilsItems;
 import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
-import gtPlusPlus.xmod.gregtech.common.Meta_GT_Proxy;
 import net.minecraftforge.fluids.FluidStack;
 
 public class GregtechFluidHandler {
@@ -40,32 +39,32 @@ public class GregtechFluidHandler {
 		if (!LoadedMods.ThermalFoundation){
 
 			Utils.LOG_INFO("Adding in our own GT versions of Thermal Foundation Fluids");		
-			Meta_GT_Proxy.addFluid("cryotheum", "Gelid Cryotheum", GT_Materials.Cryotheum, 4, -1200, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.Cryotheum, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
-			Meta_GT_Proxy.addFluid("pyrotheum", "Blazing Pyrotheum", GT_Materials.Pyrotheum, 4, 4000, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.Pyrotheum, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("cryotheum", "Gelid Cryotheum", GT_Materials.Cryotheum, 4, -1200, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.Cryotheum, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("pyrotheum", "Blazing Pyrotheum", GT_Materials.Pyrotheum, 4, 4000, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.Pyrotheum, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 		}
 
 		if (LoadedMods.IndustrialCraft2){
 			Utils.LOG_INFO("Adding in GT Fluids for various nuclear related content.");	
 			
-			Meta_GT_Proxy.addFluid("hydrofluoricAcid", "Hydrofluoric Acid", GT_Materials.HydrofluoricAcid, 1, 120, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.HydrofluoricAcid, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("hydrofluoricAcid", "Hydrofluoric Acid", GT_Materials.HydrofluoricAcid, 1, 120, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.HydrofluoricAcid, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 			generateIC2FluidCell("HydrofluoricAcid");
 
-			Meta_GT_Proxy.addFluid("sulfurDioxide", "Sulfur Dioxide", GT_Materials.SulfurDioxide, 4, -100, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.SulfurDioxide, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("sulfurDioxide", "Sulfur Dioxide", GT_Materials.SulfurDioxide, 4, -100, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.SulfurDioxide, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 			generateIC2FluidCell("SulfurDioxide");
 
-			Meta_GT_Proxy.addFluid("sulfurousAcid", "Sulfurous Acid", GT_Materials.SulfurousAcid, 4, 75, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.SulfurousAcid, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("sulfurousAcid", "Sulfurous Acid", GT_Materials.SulfurousAcid, 4, 75, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.SulfurousAcid, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 			generateIC2FluidCell("SulfurousAcid");
 
-			Meta_GT_Proxy.addFluid("sulfuricApatite", "Sulfuric Apatite Mix", GT_Materials.SulfuricApatite, 4, 500, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.SulfuricApatite, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("sulfuricApatite", "Sulfuric Apatite Mix", GT_Materials.SulfuricApatite, 4, 500, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.SulfuricApatite, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 			generateIC2FluidCell("SulfuricApatite");
 
-			Meta_GT_Proxy.addFluid("uraniumHexafluoride", "Uranium Hexafluoride", GT_Materials.UraniumHexaFluoride, 4, 200, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.UraniumHexaFluoride, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("uraniumHexafluoride", "Uranium Hexafluoride", GT_Materials.UraniumHexaFluoride, 4, 200, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.UraniumHexaFluoride, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 			generateIC2FluidCell("UraniumHexaFluoride");
 
-			Meta_GT_Proxy.addFluid("uraniumTetrafluoride", "Uranium Tetrafluoride", GT_Materials.UraniumTetraFluoride, 4, 950, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.UraniumTetraFluoride, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("uraniumTetrafluoride", "Uranium Tetrafluoride", GT_Materials.UraniumTetraFluoride, 4, 950, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.UraniumTetraFluoride, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 			generateIC2FluidCell("UraniumTetraFluoride");
 
-			Meta_GT_Proxy.addFluid("thoriumTetrafluoride", "Thorium Tetrafluoride", GT_Materials.ThoriumTetraFluoride, 4, 1250, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.ThoriumTetraFluoride, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("thoriumTetrafluoride", "Thorium Tetrafluoride", GT_Materials.ThoriumTetraFluoride, 4, 1250, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.ThoriumTetraFluoride, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 			generateIC2FluidCell("ThoriumTetraFluoride");
 
 
@@ -78,16 +77,16 @@ public class GregtechFluidHandler {
 					else {
 						Utils.LOG_INFO("No Suitable versions of Hydrogen Chloride available, adding our own.");
 					}
-					Meta_GT_Proxy.addFluid("hydrogenChloride", "Hydrogen Chloride", GT_Materials.HydrogenChloride, 4, 75, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.HydrogenChloride, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+					FluidUtils.addFluid("hydrogenChloride", "Hydrogen Chloride", GT_Materials.HydrogenChloride, 4, 75, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.HydrogenChloride, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 					generateIC2FluidCell("HydrogenChloride");
 				}
 			}
 			
 
-			Meta_GT_Proxy.addFluid("sulfuricLithium", "Sulfuric Lithium Mix", GT_Materials.SulfuricLithium, 4, 280, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.SulfuricLithium, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("sulfuricLithium", "Sulfuric Lithium Mix", GT_Materials.SulfuricLithium, 4, 280, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.SulfuricLithium, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 			generateIC2FluidCell("SulfuricLithium");
 
-			Meta_GT_Proxy.addFluid("lithiumHydroxide", "Lithium Hydroxide", GT_Materials.LithiumHydroxide, 4, 500, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.LithiumHydroxide, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+			FluidUtils.addFluid("lithiumHydroxide", "Lithium Hydroxide", GT_Materials.LithiumHydroxide, 4, 500, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.LithiumHydroxide, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
 			generateIC2FluidCell("SulfuricApatite");
 
 			/*Meta_GT_Proxy.addFluid("sulfuricApatite", "Sulfuric Apatite", GT_Materials.SulfuricApatite, 4, 500, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.SulfuricApatite, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);