Merge branch 'master' of https://github.com/draknyte1/GTplusplus

20 files changed, 2154 insertions, 368 deletions

diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/automation/GT_MetaTileEntity_TesseractGenerator.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/automation/GT_MetaTileEntity_TesseractGenerator.java
new file mode 100644
index 0000000000..0338871482
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/automation/GT_MetaTileEntity_TesseractGenerator.java
@@ -0,0 +1,603 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.automation;
+
+import static gtPlusPlus.core.lib.CORE.sTesseractGenerators;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IDigitalChest;
+import gregtech.api.interfaces.tileentity.IGregTechDeviceInformation;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Config;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.player.PlayerUtils;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+import net.minecraftforge.fluids.IFluidHandler;
+
+public class GT_MetaTileEntity_TesseractGenerator
+extends GT_MetaTileEntity_BasicTank
+{
+	public static int TESSERACT_ENERGY_COST_DIMENSIONAL = 2048;
+	public static int TESSERACT_ENERGY_COST = 1024;
+	public byte isWorking = 0;
+	public int oFrequency = 0;
+	public int mNeededEnergy = 0;
+	public int mFrequency = 0;
+
+	public GT_MetaTileEntity_TesseractGenerator(int aID, String aName, String aNameRegional, int aTier) {
+		super(aID, aName, aNameRegional, aTier, 3, "");
+	}
+
+	public GT_MetaTileEntity_TesseractGenerator(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+		super(aName, aTier, 3, aDescription, aTextures);
+	}  
+
+	@Override
+	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GT_MetaTileEntity_TesseractGenerator(mName, mTier, mDescription, mTextures);
+	}
+
+	@Override
+	public boolean isTransformerUpgradable()
+	{
+		return true;
+	}
+
+	@Override
+	public boolean isOverclockerUpgradable()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isSimpleMachine()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isFacingValid(byte aFacing)
+	{
+		return true;
+	}
+
+	@Override
+	public boolean isEnetInput()
+	{
+		return true;
+	}
+
+	@Override
+	public boolean isEnetOutput()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isInputFacing(byte aSide)
+	{
+		return true;
+	}
+
+	@Override
+	public boolean isOutputFacing(byte aSide) {
+		return aSide == getBaseMetaTileEntity().getBackFacing();
+	}
+
+	@Override
+	public boolean isValidSlot(int aIndex)
+	{
+		return false;
+	}
+
+	@Override
+	public long getMinimumStoredEU()
+	{
+		return getBaseMetaTileEntity().getEUCapacity() / 2;
+	}
+
+	@Override
+	public long maxEUInput()
+	{
+		return 2048;
+	}
+
+	@Override
+	public long maxEUOutput()
+	{
+		return 0;
+	}
+
+	@Override
+	public long maxEUStore()
+	{
+		return 100000;
+	}
+
+	@Override
+	public long maxSteamStore()
+	{
+		return maxEUStore();
+	}
+
+	@Override
+	public boolean isAccessAllowed(EntityPlayer aPlayer)
+	{
+		return true;
+	}
+
+	@Override
+	public boolean ownerControl()
+	{
+		return true;
+	}
+
+	@Override
+	public int getProgresstime()
+	{
+		return (sTesseractGenerators.get(Integer.valueOf(this.mFrequency)) == this) && (this.isWorking >= 20) ? 999 : 0;
+	}
+
+	@Override
+	public int maxProgresstime()
+	{
+		return 1000;
+	}
+
+	@Override
+	public void saveNBTData(NBTTagCompound aNBT)
+	{
+		aNBT.setInteger("mFrequency", this.mFrequency);
+	}
+
+	@Override
+	public void loadNBTData(NBTTagCompound aNBT)
+	{
+		this.mFrequency = aNBT.getInteger("mFrequency");
+	}
+
+	@Override
+	public void onConfigLoad(GT_Config aConfig)
+	{
+		TESSERACT_ENERGY_COST = 1024;
+		TESSERACT_ENERGY_COST_DIMENSIONAL = 2048;
+	}
+
+	@Override
+	public void onServerStart()
+	{
+		sTesseractGenerators.clear();
+	}
+
+	public void onServerStop()
+	{
+		sTesseractGenerators.clear();
+	}
+	
+	@Override
+	public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ){
+		if (aSide == getBaseMetaTileEntity().getFrontFacing()){
+			float[] tCoords = GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ);
+			switch ((byte)((byte)(int)(tCoords[0] * 2.0F) + 2 * (byte)(int)(tCoords[1] * 2.0F))){
+			case 0: 
+				Utils.LOG_INFO("Freq. -1 | " + this.mFrequency);
+				this.mFrequency -= 1;
+				break;
+			case 1: 
+				Utils.LOG_INFO("Freq. +1 | " + this.mFrequency);
+				this.mFrequency += 1;
+			default:
+				//Utils.LOG_INFO("Did not click the correct place.");
+				break;
+			}
+			PlayerUtils.messagePlayer(aPlayer, "Frequency: " + this.mFrequency);
+			PlayerUtils.messagePlayer(aPlayer, ((sTesseractGenerators.get(Integer.valueOf(this.mFrequency)) != null) && (sTesseractGenerators.get(Integer.valueOf(this.mFrequency)) != this) ? EnumChatFormatting.RED + " (Occupied)" : ""));
+			}
+		return true;
+	}
+
+	@Override
+	public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ)
+	{
+		if (aSide == getBaseMetaTileEntity().getFrontFacing())
+		{
+			float[] tCoords = GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ);
+			switch ((byte)((byte)(int)(tCoords[0] * 2.0F) + 2 * (byte)(int)(tCoords[1] * 2.0F)))
+			{
+			case 0: 
+				this.mFrequency -= 64;
+				break;
+			case 1: 
+				this.mFrequency += 64;
+				break;
+			case 2: 
+				this.mFrequency -= 512;
+				break;
+			case 3: 
+				this.mFrequency += 512;
+			}
+			GT_Utility.sendChatToPlayer(aPlayer, "Frequency: " + this.mFrequency + ((sTesseractGenerators.get(Integer.valueOf(this.mFrequency)) != null) && (sTesseractGenerators.get(Integer.valueOf(this.mFrequency)) != this) ? EnumChatFormatting.RED + " (Occupied)" : ""));
+		}
+	}
+
+	public boolean allowCoverOnSide(byte aSide, int aCoverID)
+	{
+		return aSide != getBaseMetaTileEntity().getFrontFacing();
+	}
+
+	@Override
+	public String[] getInfoData()
+	{
+		TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity != null) && (getBaseMetaTileEntity().isAllowedToWork()) && ((tTileEntity instanceof IGregTechDeviceInformation)) && (((IGregTechDeviceInformation)tTileEntity).isGivingInformation())) {
+			return ((IGregTechDeviceInformation)tTileEntity).getInfoData();
+		}
+		return new String[] { "Tesseract Generator", "Freqency:", "" + this.mFrequency, (sTesseractGenerators.get(Integer.valueOf(this.mFrequency)) == this) && (this.isWorking >= 20) ? "Active" : "Inactive" };
+	}
+
+	@Override
+	public boolean isGivingInformation()
+	{
+		return true;
+	}
+
+	public boolean isSendingInformation()
+	{
+		TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity != null) && (getBaseMetaTileEntity().isAllowedToWork()) && ((tTileEntity instanceof IGregTechDeviceInformation))) {
+			return ((IGregTechDeviceInformation)tTileEntity).isGivingInformation();
+		}
+		return false;
+	}
+
+	@Override
+	public boolean isDigitalChest()
+	{
+		TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity != null) && (getBaseMetaTileEntity().isAllowedToWork()) && ((tTileEntity instanceof IDigitalChest))) {
+			return ((IDigitalChest)tTileEntity).isDigitalChest();
+		}
+		return false;
+	}
+
+	@Override
+	public ItemStack[] getStoredItemData()
+	{
+		TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity != null) && (getBaseMetaTileEntity().isAllowedToWork()) && ((tTileEntity instanceof IDigitalChest))) {
+			return ((IDigitalChest)tTileEntity).getStoredItemData();
+		}
+		return null;
+	}
+
+	@Override
+	public void setItemCount(int aCount)
+	{
+		TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity != null) && (getBaseMetaTileEntity().isAllowedToWork()) && ((tTileEntity instanceof IDigitalChest))) {
+			((IDigitalChest)tTileEntity).setItemCount(aCount);
+		}
+	}
+
+	@Override
+	public int getMaxItemCount()
+	{
+		TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity != null) && (getBaseMetaTileEntity().isAllowedToWork()) && ((tTileEntity instanceof IDigitalChest))) {
+			return ((IDigitalChest)tTileEntity).getMaxItemCount();
+		}
+		return 0;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int aIndex, ItemStack aStack)
+	{
+		IInventory tTileEntity = getBaseMetaTileEntity().getIInventoryAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		return tTileEntity.isItemValidForSlot(aIndex, aStack);
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int aSide)
+	{
+		IInventory tTileEntity = getBaseMetaTileEntity().getIInventoryAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return new int[0];
+		}
+		if ((tTileEntity instanceof ISidedInventory)) {
+			return ((ISidedInventory)tTileEntity).getAccessibleSlotsFromSide(aSide);
+		}
+		int[] rArray = new int[getSizeInventory()];
+		for (int i = 0; i < getSizeInventory(); i++) {
+			rArray[i] = i;
+		}
+		return rArray;
+	}
+
+	@Override
+	public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide)
+	{
+		IInventory tTileEntity = getBaseMetaTileEntity().getIInventoryAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		if ((tTileEntity instanceof ISidedInventory)) {
+			return ((ISidedInventory)tTileEntity).canInsertItem(aIndex, aStack, aSide);
+		}
+		return true;
+	}
+
+	@Override
+	public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide)
+	{
+		IInventory tTileEntity = getBaseMetaTileEntity().getIInventoryAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		if ((tTileEntity instanceof ISidedInventory)) {
+			return ((ISidedInventory)tTileEntity).canExtractItem(aIndex, aStack, aSide);
+		}
+		return true;
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		IInventory tTileEntity = getBaseMetaTileEntity().getIInventoryAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return 0;
+		}
+		return tTileEntity.getSizeInventory();
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int aIndex)
+	{
+		IInventory tTileEntity = getBaseMetaTileEntity().getIInventoryAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return null;
+		}
+		return tTileEntity.getStackInSlot(aIndex);
+	}
+
+	@Override
+	public void setInventorySlotContents(int aIndex, ItemStack aStack)
+	{
+		IInventory tTileEntity = getBaseMetaTileEntity().getIInventoryAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return;
+		}
+		tTileEntity.setInventorySlotContents(aIndex, aStack);
+	}
+
+	@Override
+	public ItemStack decrStackSize(int aIndex, int aAmount)
+	{
+		IInventory tTileEntity = getBaseMetaTileEntity().getIInventoryAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return null;
+		}
+		return tTileEntity.decrStackSize(aIndex, aAmount);
+	}
+
+	@Override
+	public String getInventoryName()
+	{
+		IInventory tTileEntity = getBaseMetaTileEntity().getIInventoryAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return "";
+		}
+		return tTileEntity.getInventoryName();
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		IInventory tTileEntity = getBaseMetaTileEntity().getIInventoryAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return 0;
+		}
+		return tTileEntity.getInventoryStackLimit();
+	}
+
+	@Override
+	public boolean canFill(ForgeDirection aSide, Fluid aFluid)
+	{
+		IFluidHandler tTileEntity = getBaseMetaTileEntity().getITankContainerAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		return tTileEntity.canFill(aSide, aFluid);
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection aSide, Fluid aFluid)
+	{
+		IFluidHandler tTileEntity = getBaseMetaTileEntity().getITankContainerAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		return tTileEntity.canDrain(aSide, aFluid);
+	}
+
+	@Override
+	public FluidTankInfo[] getTankInfo(ForgeDirection aSide)
+	{
+		IFluidHandler tTileEntity = getBaseMetaTileEntity().getITankContainerAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return new FluidTankInfo[0];
+		}
+		return tTileEntity.getTankInfo(aSide);
+	}
+
+	@Override
+	public int fill_default(ForgeDirection aDirection, FluidStack aFluid, boolean doFill)
+	{
+		IFluidHandler tTileEntity = getBaseMetaTileEntity().getITankContainerAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return 0;
+		}
+		return tTileEntity.fill(aDirection, aFluid, doFill);
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection aDirection, int maxDrain, boolean doDrain)
+	{
+		IFluidHandler tTileEntity = getBaseMetaTileEntity().getITankContainerAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return null;
+		}
+		return tTileEntity.drain(aDirection, maxDrain, doDrain);
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain)
+	{
+		IFluidHandler tTileEntity = getBaseMetaTileEntity().getITankContainerAtSide(getBaseMetaTileEntity().getBackFacing());
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return null;
+		}
+		return tTileEntity.drain(aSide, aFluid, doDrain);
+	}
+
+	public boolean addEnergyConsumption(GT_MetaTileEntity_TesseractTerminal aTerminal)
+	{
+		if (!getBaseMetaTileEntity().isAllowedToWork()) {
+			return false;
+		}
+		this.mNeededEnergy += (aTerminal.getBaseMetaTileEntity().getWorld() == getBaseMetaTileEntity().getWorld() ? TESSERACT_ENERGY_COST : TESSERACT_ENERGY_COST_DIMENSIONAL);
+		return true;
+	}
+
+	public boolean isValidTesseractGenerator(String aOwnerName, boolean aWorkIrrelevant)
+	{
+		return (getBaseMetaTileEntity() != null) && (!getBaseMetaTileEntity().isInvalidTileEntity()) && (getBaseMetaTileEntity().isAllowedToWork()) && ((aOwnerName == null) || (getBaseMetaTileEntity().getOwnerName().equals(aOwnerName))) && ((aWorkIrrelevant) || (this.isWorking >= 20));
+	}
+
+	public void onPostTick()
+	{
+		if (getBaseMetaTileEntity().isServerSide()){
+			if (this.mFrequency != this.oFrequency){
+				
+				Utils.LOG_INFO("mFreq != oFreq");
+				
+				if (sTesseractGenerators.get(Integer.valueOf(this.oFrequency)) == this)
+				{
+					sTesseractGenerators.remove(Integer.valueOf(this.oFrequency));
+					getBaseMetaTileEntity().issueBlockUpdate();
+					Utils.LOG_INFO("this Gen == oFreq on map - do block update");
+				}
+				Utils.LOG_INFO("mFreq will be set to oFreq");
+				this.oFrequency = this.mFrequency;
+			}
+			if ((getBaseMetaTileEntity().isAllowedToWork()) && (getBaseMetaTileEntity().decreaseStoredEnergyUnits(this.mNeededEnergy, false)))
+			{
+				Utils.LOG_INFO("Can Work & Has Energy");
+				if ((sTesseractGenerators.get(Integer.valueOf(this.mFrequency)) == null) || (!((GT_MetaTileEntity_TesseractGenerator)sTesseractGenerators.get(Integer.valueOf(this.mFrequency))).isValidTesseractGenerator(null, true))) {
+					Utils.LOG_INFO("storing TE I think to mFreq map?");
+					sTesseractGenerators.put(Integer.valueOf(this.mFrequency), this);
+				}
+			}
+			else
+			{
+				if (sTesseractGenerators.get(Integer.valueOf(this.mFrequency)) == this)
+				{
+					Utils.LOG_INFO("this gen == mFreq on map - do block update");
+					sTesseractGenerators.remove(Integer.valueOf(this.mFrequency));
+					getBaseMetaTileEntity().issueBlockUpdate();
+				}
+				this.isWorking = 0;
+			}
+			if (sTesseractGenerators.get(Integer.valueOf(this.mFrequency)) == this)
+			{
+				Utils.LOG_INFO("mFreq == this - do work related things");
+				if (this.isWorking < 20) {
+					this.isWorking = ((byte)(this.isWorking + 1));
+				}
+				if (this.isWorking == 20)
+				{
+					getBaseMetaTileEntity().issueBlockUpdate();
+					this.isWorking = ((byte)(this.isWorking + 1));
+				}
+			}
+			else
+			{
+				this.isWorking = 0;
+			}
+			this.mNeededEnergy = 0;
+		}
+	}
+
+	@Override
+	public String[] getDescription()
+	{
+		return new String[] {"Generates a Tesseract for the attached Inventory"};
+	}
+
+	@Override
+	public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return false;
+	}
+
+	@Override
+	public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return false;
+	}
+
+	@Override
+	public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+		return new ITexture[0][0][0];
+	}
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+		return aSide == aFacing ? new ITexture[]{ new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Dimensional), new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Screen_Frequency)} : new ITexture[]{new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Dimensional), new GT_RenderedTexture(Textures.BlockIcons.VOID)};
+	}
+
+	
+	//To-Do?
+	@Override
+	public boolean doesFillContainers() {
+		return false;
+	}
+
+	@Override
+	public boolean doesEmptyContainers() {
+		return false;
+	}
+
+	@Override
+	public boolean canTankBeFilled() {
+		return false;
+	}
+
+	@Override
+	public boolean canTankBeEmptied() {
+		return false;
+	}
+
+	@Override
+	public boolean displaysItemStack() {
+		return false;
+	}
+
+	@Override
+	public boolean displaysStackSize() {
+		return false;
+	}
+}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/automation/GT_MetaTileEntity_TesseractTerminal.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/automation/GT_MetaTileEntity_TesseractTerminal.java
new file mode 100644
index 0000000000..aa8ddad326
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/automation/GT_MetaTileEntity_TesseractTerminal.java
@@ -0,0 +1,528 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.automation;
+
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Config;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.player.PlayerUtils;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+
+public class GT_MetaTileEntity_TesseractTerminal
+extends GT_MetaTileEntity_BasicTank
+{
+	public int mFrequency = 0;
+	public boolean mDidWork = false;
+	public static boolean sInterDimensionalTesseractAllowed = true;
+
+	public GT_MetaTileEntity_TesseractTerminal(int aID, String aName, String aNameRegional, int aTier) {
+		super(aID, aName, aNameRegional, aTier, 3, "");
+	}
+
+	public GT_MetaTileEntity_TesseractTerminal(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+		super(aName, aTier, 3, aDescription, aTextures);
+	}  
+
+	@Override
+	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GT_MetaTileEntity_TesseractTerminal(mName, mTier, mDescription, mTextures);
+	}
+
+	@Override
+	public boolean isTransformerUpgradable()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isOverclockerUpgradable()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isSimpleMachine()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isFacingValid(byte aFacing)
+	{
+		return true;
+	}
+	
+	@Override
+	public boolean isOutputFacing(byte aSide) {
+		return aSide == getBaseMetaTileEntity().getBackFacing();
+	}
+
+	@Override
+	public boolean isValidSlot(int aIndex)
+	{
+		return false;
+	}
+	
+	@Override
+	public long getMinimumStoredEU()
+	{
+		return getBaseMetaTileEntity().getEUCapacity() / 2;
+	}
+
+	@Override
+	public long maxEUInput()
+	{
+		return 2048;
+	}
+
+	@Override
+	public boolean isAccessAllowed(EntityPlayer aPlayer)
+	{
+		return true;
+	}
+	
+	@Override
+	public long maxEUStore()
+	{
+		return 100000;
+	}
+
+	@Override
+	public long maxSteamStore()
+	{
+		return maxEUStore();
+	}
+
+	@Override
+	public boolean ownerControl()
+	{
+		return true;
+	}
+
+	@Override
+	public int getProgresstime()
+	{
+		return getTesseract(this.mFrequency, false) != null ? 999 : 0;
+	}
+
+	@Override
+	public int maxProgresstime()
+	{
+		return 1000;
+	}
+
+	@Override
+	public void saveNBTData(NBTTagCompound aNBT)
+	{
+		aNBT.setInteger("mFrequency", this.mFrequency);
+	}
+
+	@Override
+	public void loadNBTData(NBTTagCompound aNBT)
+	{
+		this.mFrequency = aNBT.getInteger("mFrequency");
+	}
+
+	@Override
+	public void onConfigLoad(GT_Config aConfig)
+	{
+		sInterDimensionalTesseractAllowed = true;
+	}
+
+	/*public boolean onRightclick(EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ)
+	{
+		if (aSide == getBaseMetaTileEntity().getFrontFacing())
+		{
+			float[] tCoords = GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ);
+			switch ((byte)((byte)(int)(tCoords[0] * 2.0F) + 2 * (byte)(int)(tCoords[1] * 2.0F)))
+			{
+			case 0: 
+				this.mFrequency -= 1;
+				break;
+			case 1: 
+				this.mFrequency += 1;
+			}
+			GT_Utility.sendChatToPlayer(aPlayer, "Frequency: " + this.mFrequency + (getTesseract(this.mFrequency, false) == null ? "" : new StringBuilder().append(EnumChatFormatting.GREEN).append(" (Connected)").toString()));
+		}
+		return true;
+	}*/
+
+	@Override
+	public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ){
+		if (aSide == getBaseMetaTileEntity().getFrontFacing()){
+			float[] tCoords = GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ);
+			switch ((byte)((byte)(int)(tCoords[0] * 2.0F) + 2 * (byte)(int)(tCoords[1] * 2.0F))){
+			case 0: 
+				Utils.LOG_INFO("Freq. -1 | " + this.mFrequency);
+				this.mFrequency -= 1;
+				break;
+			case 1: 
+				Utils.LOG_INFO("Freq. +1 | " + this.mFrequency);
+				this.mFrequency += 1;
+			default:
+				//Utils.LOG_INFO("Did not click the correct place.");
+				break;
+			}
+			PlayerUtils.messagePlayer(aPlayer, "Frequency: " + this.mFrequency);
+			PlayerUtils.messagePlayer(aPlayer, (getTesseract(this.mFrequency, false) == null ? "" : new StringBuilder().append(EnumChatFormatting.GREEN).append(" (Connected)").toString()));
+		}
+		return true;
+	}
+	
+	@Override
+	public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ)
+	{
+		if (aSide == getBaseMetaTileEntity().getFrontFacing())
+		{
+			float[] tCoords = GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ);
+			switch ((byte)((byte)(int)(tCoords[0] * 2.0F) + 2 * (byte)(int)(tCoords[1] * 2.0F)))
+			{
+			case 0: 
+				this.mFrequency -= 64;
+				break;
+			case 1: 
+				this.mFrequency += 64;
+				break;
+			case 2: 
+				this.mFrequency -= 512;
+				break;
+			case 3: 
+				this.mFrequency += 512;
+			}
+			GT_Utility.sendChatToPlayer(aPlayer, "Frequency: " + this.mFrequency + (getTesseract(this.mFrequency, false) == null ? "" : new StringBuilder().append(EnumChatFormatting.GREEN).append(" (Connected)").toString()));
+		}
+	}
+
+	public boolean allowCoverOnSide(byte aSide, int aCoverID)
+	{
+		return aSide != getBaseMetaTileEntity().getFrontFacing();
+	}
+
+	public GT_MetaTileEntity_TesseractGenerator getTesseract(int aFrequency, boolean aWorkIrrelevant)
+	{
+		GT_MetaTileEntity_TesseractGenerator rTesseract = (GT_MetaTileEntity_TesseractGenerator)CORE.sTesseractGenerators.get(Integer.valueOf(aFrequency));
+		if (rTesseract == null) {
+			return null;
+		}
+		if (rTesseract.mFrequency != aFrequency)
+		{
+			CORE.sTesseractGenerators.put(Integer.valueOf(aFrequency), null);return null;
+		}
+		if (!rTesseract.isValidTesseractGenerator(getBaseMetaTileEntity().getOwnerName(), aWorkIrrelevant)) {
+			return null;
+		}
+		if ((!sInterDimensionalTesseractAllowed) && (rTesseract.getBaseMetaTileEntity().getWorld() != getBaseMetaTileEntity().getWorld())) {
+			return null;
+		}
+		return rTesseract;
+	}
+
+	@Override
+	public String[] getInfoData()
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity != null) && (getBaseMetaTileEntity().isAllowedToWork()) && (tTileEntity.isSendingInformation())) {
+			return tTileEntity.getInfoData();
+		}
+		return new String[] { "Tesseract Generator", "Freqency:", "" + this.mFrequency, getTesseract(this.mFrequency, false) != null ? "Active" : "Inactive" };
+	}
+
+	@Override
+	public boolean isGivingInformation()
+	{
+		return true;
+	}
+
+	@Override
+	public boolean isDigitalChest()
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		return tTileEntity.isDigitalChest();
+	}
+
+	@Override
+	public ItemStack[] getStoredItemData()
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return null;
+		}
+		return tTileEntity.getStoredItemData();
+	}
+
+	@Override
+	public void setItemCount(int aCount)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return;
+		}
+		tTileEntity.setItemCount(aCount);
+	}
+
+	@Override
+	public int getMaxItemCount()
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return 0;
+		}
+		return tTileEntity.getMaxItemCount();
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int aIndex, ItemStack aStack)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		return tTileEntity.isItemValidForSlot(aIndex, aStack);
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int aSide)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return new int[0];
+		}
+		return tTileEntity.getAccessibleSlotsFromSide(aSide);
+	}
+
+	@Override
+	public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		return tTileEntity.canInsertItem(aIndex, aStack, aSide);
+	}
+
+	@Override
+	public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		return tTileEntity.canExtractItem(aIndex, aStack, aSide);
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return 0;
+		}
+		return tTileEntity.getSizeInventory();
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int aIndex)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return null;
+		}
+		return tTileEntity.getStackInSlot(aIndex);
+	}
+
+	@Override
+	public void setInventorySlotContents(int aIndex, ItemStack aStack)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return;
+		}
+		tTileEntity.setInventorySlotContents(aIndex, aStack);
+	}
+
+	@Override
+	public ItemStack decrStackSize(int aIndex, int aAmount)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return null;
+		}
+		return tTileEntity.decrStackSize(aIndex, aAmount);
+	}
+
+	@Override
+	public String getInventoryName()
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return "";
+		}
+		return tTileEntity.getInventoryName();
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return 0;
+		}
+		return tTileEntity.getInventoryStackLimit();
+	}
+
+	@Override
+	public boolean canFill(ForgeDirection aSide, Fluid aFluid)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		return tTileEntity.canFill(aSide, aFluid);
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection aSide, Fluid aFluid)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return false;
+		}
+		return tTileEntity.canDrain(aSide, aFluid);
+	}
+
+	@Override
+	public FluidTankInfo[] getTankInfo(ForgeDirection aSide)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return new FluidTankInfo[0];
+		}
+		return tTileEntity.getTankInfo(aSide);
+	}
+
+	@Override
+	public int fill_default(ForgeDirection aDirection, FluidStack aFluid, boolean doFill)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return 0;
+		}
+		return tTileEntity.fill(aDirection, aFluid, doFill);
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection aDirection, int maxDrain, boolean doDrain)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return null;
+		}
+		return tTileEntity.drain(aDirection, maxDrain, doDrain);
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain)
+	{
+		GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, false);
+		if ((tTileEntity == null) || (!getBaseMetaTileEntity().isAllowedToWork())) {
+			return null;
+		}
+		return tTileEntity.drain(aSide, aFluid, doDrain);
+	}
+
+	public void onPostTick()
+	{
+		if ((getBaseMetaTileEntity().isServerSide()) && (getBaseMetaTileEntity().isAllowedToWork()))
+		{
+			GT_MetaTileEntity_TesseractGenerator tTileEntity = getTesseract(this.mFrequency, true);
+			if (tTileEntity != null)
+			{
+				tTileEntity.addEnergyConsumption(this);
+				if ((!this.mDidWork) && (getTesseract(this.mFrequency, false) != null))
+				{
+					this.mDidWork = true;
+					getBaseMetaTileEntity().issueBlockUpdate();
+				}
+			}
+			else if (this.mDidWork == true)
+			{
+				this.mDidWork = false;
+				getBaseMetaTileEntity().issueBlockUpdate();
+			}
+		}
+	}
+
+	@Override
+	public String[] getDescription()
+	{
+		return new String[] {"Accesses Tesseracts remotely"};
+	}
+
+	@Override
+	public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return false;
+	}
+
+	@Override
+	public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return false;
+	}
+
+	@Override
+	public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+		return new ITexture[0][0][0];
+	}
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+		return aSide == aFacing ? new ITexture[]{new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Dimensional), new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Screen_Frequency)} : new ITexture[]{new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Dimensional), new GT_RenderedTexture(Textures.BlockIcons.VOID)};
+	}
+
+	//To-Do?
+	@Override
+	public boolean doesFillContainers() {
+		return false;
+	}
+
+	@Override
+	public boolean doesEmptyContainers() {
+		return false;
+	}
+
+	@Override
+	public boolean canTankBeFilled() {
+		return false;
+	}
+
+	@Override
+	public boolean canTankBeEmptied() {
+		return false;
+	}
+
+	@Override
+	public boolean displaysItemStack() {
+		return false;
+	}
+
+	@Override
+	public boolean displaysStackSize() {
+		return false;
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityDoubleFuelGeneratorBase.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityDoubleFuelGeneratorBase.java
new file mode 100644
index 0000000000..65a2892710
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityDoubleFuelGeneratorBase.java
@@ -0,0 +1,136 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.generators;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ConfigCategories;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Recipe;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.generators.GregtechRocketFuelGeneratorBase;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import net.minecraft.item.ItemStack;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class GregtechMetaTileEntityDoubleFuelGeneratorBase
+        extends GregtechRocketFuelGeneratorBase {
+
+    public int mEfficiency;
+
+    public GregtechMetaTileEntityDoubleFuelGeneratorBase(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, "Requires two liquid Fuels. Fuel A is Fastburn, Fuel B is slowburn.", new ITexture[0]);
+        onConfigLoad();
+    }
+
+    public GregtechMetaTileEntityDoubleFuelGeneratorBase(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+        onConfigLoad();
+    }
+
+    @Override
+	public boolean isOutputFacing(byte aSide) {
+        return aSide == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaTileEntityDoubleFuelGeneratorBase(this.mName, this.mTier, this.mDescription, this.mTextures);
+    }
+
+    @Override
+	public GT_Recipe.GT_Recipe_Map getRecipes() {
+        return GT_Recipe.GT_Recipe_Map.sDieselFuels;
+    }
+
+    @Override
+	public int getCapacity() {
+        return 32000;
+    }
+
+    public void onConfigLoad() {
+        this.mEfficiency = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "RocketEngine.efficiency.tier." + this.mTier, (100 - this.mTier * 8));
+    }
+
+    @Override
+	public int getEfficiency() {
+        return this.mEfficiency;
+    }
+
+    @Override
+	public int getFuelValue(ItemStack aStack) {
+        int rValue = Math.max(GT_ModHandler.getFuelCanValue(aStack) * 6 / 5, super.getFuelValue(aStack));
+        if (ItemList.Fuel_Can_Plastic_Filled.isStackEqual(aStack, false, true)) {
+            rValue = Math.max(rValue, GameRegistry.getFuelValue(aStack) * 3);
+        }
+        return rValue;
+    }
+    
+    private GT_RenderedTexture getCasingTexture(){
+    	if (this.mTier <= 4){
+    		return  new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Simple_Top);
+    	}
+    	else if (this.mTier == 5){
+
+    		return  new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Advanced);
+    	}
+    	else if (this.mTier >= 6){
+
+    		return  new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Ultra);
+    	}
+		return  new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Simple_Top);
+    }
+    
+
+    @Override
+	public ITexture[] getFront(byte aColor) {
+        return new ITexture[]{super.getFront(aColor)[0], getCasingTexture(), Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getBack(byte aColor) {
+        return new ITexture[]{super.getBack(aColor)[0], getCasingTexture(), new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Vent)};
+    }
+
+    @Override
+	public ITexture[] getBottom(byte aColor) {
+        return new ITexture[]{super.getBottom(aColor)[0], new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Simple_Bottom)};
+    }
+
+    @Override
+	public ITexture[] getTop(byte aColor) {
+        return new ITexture[]{super.getTop(aColor)[0], new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Redstone_Off)};
+    }
+
+    @Override
+	public ITexture[] getSides(byte aColor) {
+        return new ITexture[]{super.getSides(aColor)[0], getCasingTexture(), new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Diesel_Horizontal)};
+    }
+
+    @Override
+	public ITexture[] getFrontActive(byte aColor) {
+        return new ITexture[]{super.getFrontActive(aColor)[0], getCasingTexture(), Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getBackActive(byte aColor) {
+        return new ITexture[]{super.getBackActive(aColor)[0], getCasingTexture(), new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Vent_Fast)};
+    }
+
+    @Override
+	public ITexture[] getBottomActive(byte aColor) {
+        return new ITexture[]{super.getBottomActive(aColor)[0], new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Simple_Bottom)};
+    }
+
+    @Override
+	public ITexture[] getTopActive(byte aColor) {
+        return new ITexture[]{super.getTopActive(aColor)[0], new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Redstone_On)};
+    }
+
+    @Override
+	public ITexture[] getSidesActive(byte aColor) {
+        return new ITexture[]{super.getSidesActive(aColor)[0], getCasingTexture(), new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Diesel_Horizontal_Active)};
+    }
+}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityGeothermalGenerator.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityGeothermalGenerator.java
new file mode 100644
index 0000000000..b45cf93bff
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityGeothermalGenerator.java
@@ -0,0 +1,145 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.generators;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ConfigCategories;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class GregtechMetaTileEntityGeothermalGenerator
+extends GT_MetaTileEntity_BasicGenerator
+{
+
+	public int mEfficiency;
+
+	public GregtechMetaTileEntityGeothermalGenerator(int aID, String aName, String aNameRegional, int aTier) {
+		super(aID, aName, aNameRegional, aTier, "Requires Pahoehoe Lava or Normal Lava as Fuel", new ITexture[0]);
+		onConfigLoad();
+	}
+
+	public GregtechMetaTileEntityGeothermalGenerator(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+		super(aName, aTier, aDescription, aTextures);
+		onConfigLoad();
+	}  
+
+	@Override
+	public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+		if (aBaseMetaTileEntity.isClientSide()){
+			return true;
+		}
+		aBaseMetaTileEntity.openGUI(aPlayer);
+		return true;
+	} 
+
+	@Override
+	public int getCapacity() {
+		//return MathUtils.roundToClosestMultiple(32000*(this.mTier/2), 25000);
+		return 5000*this.mTier;
+	}
+
+	public void onConfigLoad() {
+		this.mEfficiency = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "ThermalGenerator.efficiency.tier." + this.mTier, (100 - this.mTier * 7));
+	}
+
+	@Override
+	public int getEfficiency() {
+		return this.mEfficiency;
+	}
+
+	@Override
+	public int getFuelValue(ItemStack aStack) {
+		int rValue = Math.max(GT_ModHandler.getFuelCanValue(aStack) * 6 / 5, super.getFuelValue(aStack));
+		if (ItemList.Fuel_Can_Plastic_Filled.isStackEqual(aStack, false, true)) {
+			rValue = Math.max(rValue, GameRegistry.getFuelValue(aStack) * 3);
+		}
+		return rValue;
+	}
+
+	@Override
+	public boolean isOutputFacing(byte aSide) {
+		return aSide == getBaseMetaTileEntity().getFrontFacing();
+	}
+
+	@Override
+	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaTileEntityGeothermalGenerator(this.mName, this.mTier, this.mDescription, this.mTextures);
+	}
+
+	@Override
+	public ITexture[] getFront(byte aColor) {
+		return new ITexture[]{super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_SIDE), Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[this.mTier]};
+	}
+
+	@Override
+	public ITexture[] getBack(byte aColor) {
+		return new ITexture[]{super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BACK), new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Diesel_Vertical)};
+	}
+
+	@Override
+	public ITexture[] getBottom(byte aColor) {
+		return new ITexture[]{super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BOTTOM)};
+	}
+
+	@Override
+	public ITexture[] getTop(byte aColor) {
+		return new ITexture[]{super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_SIDE), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_ROCK_BREAKER)};
+	}
+
+	@Override
+	public ITexture[] getSides(byte aColor) {
+		return new ITexture[]{super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.BOILER_LAVA_FRONT)};
+	}
+
+	@Override
+	public ITexture[] getFrontActive(byte aColor) {
+		return new ITexture[]{super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_SIDE_ACTIVE), Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[this.mTier]};
+	}
+
+	@Override
+	public ITexture[] getBackActive(byte aColor) {
+		return new ITexture[]{super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BACK_ACTIVE), new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Diesel_Vertical_Active)};
+	}
+
+	@Override
+	public ITexture[] getBottomActive(byte aColor) {
+		return new ITexture[]{super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BOTTOM_ACTIVE)};
+	}
+
+	@Override
+	public ITexture[] getTopActive(byte aColor) {
+		return new ITexture[]{super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_SIDE), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_ROCK_BREAKER_ACTIVE)};
+	}
+
+	@Override
+	public ITexture[] getSidesActive(byte aColor) {
+		return new ITexture[]{super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.BOILER_LAVA_FRONT_ACTIVE)};
+	}
+
+
+	@Override
+	public String[] getDescription()
+	{
+		return new String[] {"Generates power from Lava/Pahoehoe at " + getEfficiency() + "% Efficiency per tick"};
+	}
+
+	@Override
+	public GT_Recipe_Map getRecipes()
+	{
+		return GT_Recipe_Map.sHotFuels;
+	}
+
+	
+	public int getPollution() {
+		return 100;
+	}
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java
index 20ebd611a2..59e4a1b875 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java
@@ -11,6 +11,7 @@ import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_Recipe;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.generators.GregtechRocketFuelGeneratorBase;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 import net.minecraft.item.ItemStack;
 import cpw.mods.fml.common.registry.GameRegistry;
 
@@ -20,7 +21,7 @@ public class GregtechMetaTileEntityRocketFuelGenerator
     public int mEfficiency;
 
     public GregtechMetaTileEntityRocketFuelGenerator(int aID, String aName, String aNameRegional, int aTier) {
-        super(aID, aName, aNameRegional, aTier, "Requires liquid Fuel", new ITexture[0]);
+        super(aID, aName, aNameRegional, aTier, "Requires liquid Fuels.", new ITexture[0]);
         onConfigLoad();
     }
 
@@ -66,54 +67,70 @@ public class GregtechMetaTileEntityRocketFuelGenerator
         }
         return rValue;
     }
+    
+    private GT_RenderedTexture getCasingTexture(){
+    	if (this.mTier <= 4){
+    		return  new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Simple_Top);
+    	}
+    	else if (this.mTier == 5){
+
+    		return  new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Advanced);
+    	}
+    	else if (this.mTier >= 6){
+
+    		return  new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Ultra);
+    	}
+		return  new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Simple_Top);
+    }
+    
 
     @Override
 	public ITexture[] getFront(byte aColor) {
-        return new ITexture[]{super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_FRONT), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier]};
+        return new ITexture[]{super.getFront(aColor)[0], getCasingTexture(), Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[this.mTier]};
     }
 
     @Override
 	public ITexture[] getBack(byte aColor) {
-        return new ITexture[]{super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BACK)};
+        return new ITexture[]{super.getBack(aColor)[0], getCasingTexture(), new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Vent)};
     }
 
     @Override
 	public ITexture[] getBottom(byte aColor) {
-        return new ITexture[]{super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BOTTOM)};
+        return new ITexture[]{super.getBottom(aColor)[0], new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Simple_Bottom)};
     }
 
     @Override
 	public ITexture[] getTop(byte aColor) {
-        return new ITexture[]{super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_TOP)};
+        return new ITexture[]{super.getTop(aColor)[0], new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Redstone_Off)};
     }
 
     @Override
 	public ITexture[] getSides(byte aColor) {
-        return new ITexture[]{super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_SIDE)};
+        return new ITexture[]{super.getSides(aColor)[0], getCasingTexture(), new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Diesel_Horizontal)};
     }
 
     @Override
 	public ITexture[] getFrontActive(byte aColor) {
-        return new ITexture[]{super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_FRONT_ACTIVE), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier]};
+        return new ITexture[]{super.getFrontActive(aColor)[0], getCasingTexture(), Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[this.mTier]};
     }
 
     @Override
 	public ITexture[] getBackActive(byte aColor) {
-        return new ITexture[]{super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BACK_ACTIVE)};
+        return new ITexture[]{super.getBackActive(aColor)[0], getCasingTexture(), new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Vent_Fast)};
     }
 
     @Override
 	public ITexture[] getBottomActive(byte aColor) {
-        return new ITexture[]{super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BOTTOM_ACTIVE)};
+        return new ITexture[]{super.getBottomActive(aColor)[0], new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Simple_Bottom)};
     }
 
     @Override
 	public ITexture[] getTopActive(byte aColor) {
-        return new ITexture[]{super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_TOP_ACTIVE)};
+        return new ITexture[]{super.getTopActive(aColor)[0], new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Redstone_On)};
     }
 
     @Override
 	public ITexture[] getSidesActive(byte aColor) {
-        return new ITexture[]{super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_SIDE_ACTIVE)};
+        return new ITexture[]{super.getSidesActive(aColor)[0], getCasingTexture(), new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Diesel_Horizontal_Active)};
     }
 }
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntityChunkLoader.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntityChunkLoader.java
new file mode 100644
index 0000000000..0d9fadc6df
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaTileEntityChunkLoader.java
@@ -0,0 +1,129 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic;
+
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_SpawnEventHandler;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+public class GregtechMetaTileEntityChunkLoader extends GT_MetaTileEntity_TieredMachineBlock {
+
+    public int mRange = 16;
+
+    public GregtechMetaTileEntityChunkLoader(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, 0, "Reprells nasty Creatures. Range: " + (4 + (12 * aTier)) + " unpowered / " + (16 + (48 * aTier)) + " powered");
+    }
+
+    public GregtechMetaTileEntityChunkLoader(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aInvSlotCount, aDescription, aTextures);
+    }
+
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaTileEntityChunkLoader(this.mName, this.mTier, this.mInventory.length, this.mDescription, this.mTextures);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1], (aSide != 1) ? null : aActive ? new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TELEPORTER_ACTIVE) : new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TELEPORTER)};
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) {
+        if (aBaseMetaTileEntity.isAllowedToWork() && aBaseMetaTileEntity.isServerSide()) {
+            int[] tCoords = new int[]{aBaseMetaTileEntity.getXCoord(), aBaseMetaTileEntity.getYCoord(), aBaseMetaTileEntity.getZCoord(), aBaseMetaTileEntity.getWorld().provider.dimensionId};
+            if ((aTimer % 600 == 0) && !GT_SpawnEventHandler.mobReps.contains(tCoords)) {
+                GT_SpawnEventHandler.mobReps.add(tCoords);
+            }
+            if (aBaseMetaTileEntity.isUniversalEnergyStored(getMinimumStoredEU()) && aBaseMetaTileEntity.decreaseStoredEnergyUnits(1 << (this.mTier * 2), false)) {
+                mRange = 16 + (48 * mTier);
+            } else {
+                mRange = 4 + (12 * mTier);
+            }
+        }
+    }
+
+    @Override
+    public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {
+        int[] tCoords = new int[]{aBaseMetaTileEntity.getXCoord(), aBaseMetaTileEntity.getYCoord(), aBaseMetaTileEntity.getZCoord(), aBaseMetaTileEntity.getWorld().provider.dimensionId};
+        GT_SpawnEventHandler.mobReps.add(tCoords);
+    }
+
+    @Override
+    public void onRemoval() {
+        int[] tCoords = new int[]{this.getBaseMetaTileEntity().getXCoord(), this.getBaseMetaTileEntity().getYCoord(), this.getBaseMetaTileEntity().getZCoord(), this.getBaseMetaTileEntity().getWorld().provider.dimensionId};
+        GT_SpawnEventHandler.mobReps.remove(tCoords);
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return false;
+    }
+
+    @Override
+    public boolean isFacingValid(byte aFacing) {
+        return true;
+    }
+
+    @Override
+    public boolean isEnetInput() {
+        return true;
+    }
+
+    @Override
+    public boolean isInputFacing(byte aSide) {
+        return true;
+    }
+
+    @Override
+    public boolean isTeleporterCompatible() {
+        return false;
+    }
+
+    @Override
+    public long getMinimumStoredEU() {
+        return 512;
+    }
+
+    @Override
+    public long maxEUStore() {
+        return 512 + V[mTier] * 50;
+    }
+
+    @Override
+    public long maxEUInput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxAmperesIn() {
+        return 2;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+        return null;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+    }
+}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMTENuclearReactor.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMTE_NuclearReactor.java
index 32bae133ba..202647913c 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMTENuclearReactor.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMTE_NuclearReactor.java
@@ -13,7 +13,7 @@ import gregtech.api.util.Recipe_GT;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.util.Utils;
-import gtPlusPlus.core.util.item.UtilsItems;
+import gtPlusPlus.core.util.item.ItemUtils;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine;
 
 import java.util.ArrayList;
@@ -27,21 +27,21 @@ import net.minecraftforge.fluids.FluidStack;
 
 import org.apache.commons.lang3.ArrayUtils;
 
-public class GregtechMTENuclearReactor extends GT_MetaTileEntity_MultiBlockBase {
+public class GregtechMTE_NuclearReactor extends GT_MetaTileEntity_MultiBlockBase {
 
 	public static int sUUAperUUM = 1;
 	public static int sUUASpeedBonus = 4;
 	public static int sDurationMultiplier = 3215;
 	public static boolean sRequiresUUA = false;
 	private int recipeCounter = 0;
-	private static Block IC2Glass = Block.getBlockFromItem(UtilsItems.getItem("IC2:blockAlloyGlass"));
+	private static Block IC2Glass = Block.getBlockFromItem(ItemUtils.getItem("IC2:blockAlloyGlass"));
 	//public FluidStack mFluidOut = Materials.UUMatter.getFluid(1L);
 
-	public GregtechMTENuclearReactor(int aID, String aName, String aNameRegional) {
+	public GregtechMTE_NuclearReactor(int aID, String aName, String aNameRegional) {
 		super(aID, aName, aNameRegional);
 	}
 
-	public GregtechMTENuclearReactor(String aName) {
+	public GregtechMTE_NuclearReactor(String aName) {
 		super(aName);
 	}
 
@@ -281,7 +281,7 @@ public class GregtechMTENuclearReactor extends GT_MetaTileEntity_MultiBlockBase
 
 	@Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-		return new GregtechMTENuclearReactor(this.mName);
+		return new GregtechMTE_NuclearReactor(this.mName);
 	}
 
 }
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_AlloyBlastSmelter.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_AlloyBlastSmelter.java
new file mode 100644
index 0000000000..bb7327857a
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_AlloyBlastSmelter.java
@@ -0,0 +1,232 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi;
+
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.Recipe_GT;
+import gtPlusPlus.core.block.ModBlocks;
+import gtPlusPlus.core.util.Utils;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+public class GregtechMetaTileEntity_AlloyBlastSmelter
+        extends GT_MetaTileEntity_MultiBlockBase {
+    private int mHeatingCapacity = 0;
+
+    public GregtechMetaTileEntity_AlloyBlastSmelter(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GregtechMetaTileEntity_AlloyBlastSmelter(String aName) {
+        super(aName);
+    }
+
+    @Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaTileEntity_AlloyBlastSmelter(this.mName);
+    }
+
+    @Override
+	public String[] getDescription() {
+        return new String[]{
+        		"Controller Block for the Alloy Blast Smelter", //Outputs 144mb fluid for every inputStack.stackSize; Time to use those hot metals.
+        		"Size: 3x3x4 (Hollow)",
+        		"Controller (front middle at bottom)",
+        		"16x Blast Smelter Heat Containment Coils (two middle Layers, hollow)",
+        		"1x Input bus (one of bottom)",
+        		"1x Output Hatch (one of bottom)",
+        		"1x Energy Hatch (one of bottom)", 
+        		"1x Maintenance Hatch (one of bottom)",
+        		"1x Muffler Hatch (top middle)",
+        		"Blast Smelter Casings for the rest"};
+    }
+
+    @Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        if (aSide == aFacing) {
+            return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[72], new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE)};
+        }
+        return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[72]};
+    }
+
+    @Override
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "ElectricBlastFurnace.png");
+    }
+
+    @Override
+	public GT_Recipe.GT_Recipe_Map getRecipeMap() {
+        return Recipe_GT.Gregtech_Recipe_Map.sAlloyBlastSmelterRecipes;
+    }
+
+    @Override
+	public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+	public boolean isFacingValid(byte aFacing) {
+        return aFacing > 1;
+    }
+
+    @Override
+	public boolean checkRecipe(ItemStack aStack) {
+        ArrayList<ItemStack> tInputList = getStoredInputs();
+        for (int i = 0; i < tInputList.size() - 1; i++) {
+            for (int j = i + 1; j < tInputList.size(); j++) {
+                if (GT_Utility.areStacksEqual((ItemStack) tInputList.get(i), (ItemStack) tInputList.get(j))) {
+                    if (((ItemStack) tInputList.get(i)).stackSize >= ((ItemStack) tInputList.get(j)).stackSize) {
+                        tInputList.remove(j--);
+                    } else {
+                        tInputList.remove(i--);
+                        break;
+                    }
+                }
+            }
+        }
+        ItemStack[] tInputs = (ItemStack[]) Arrays.copyOfRange(tInputList.toArray(new ItemStack[tInputList.size()]), 0, 2);
+
+        ArrayList<FluidStack> tFluidList = getStoredFluids();
+        for (int i = 0; i < tFluidList.size() - 1; i++) {
+            for (int j = i + 1; j < tFluidList.size(); j++) {
+                if (GT_Utility.areFluidsEqual((FluidStack) tFluidList.get(i), (FluidStack) tFluidList.get(j))) {
+                    if (((FluidStack) tFluidList.get(i)).amount >= ((FluidStack) tFluidList.get(j)).amount) {
+                        tFluidList.remove(j--);
+                    } else {
+                        tFluidList.remove(i--);
+                        break;
+                    }
+                }
+            }
+        }
+        FluidStack[] tFluids = (FluidStack[]) Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tInputList.size()]), 0, 1);
+        if (tInputList.size() > 1) {
+            long tVoltage = getMaxInputVoltage();
+            byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
+            GT_Recipe tRecipe = Recipe_GT.Gregtech_Recipe_Map.sAlloyBlastSmelterRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], tFluids, tInputs);
+            if ((tRecipe != null) && (this.mHeatingCapacity >= tRecipe.mSpecialValue) && (tRecipe.isRecipeInputEqual(true, tFluids, tInputs))) {
+            	Utils.LOG_WARNING("Found some Valid Inputs.");
+                this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+                this.mEfficiencyIncrease = 10000;
+                if (tRecipe.mEUt <= 16) {
+                    this.mEUt = (tRecipe.mEUt * (1 << tTier - 1) * (1 << tTier - 1));
+                    this.mMaxProgresstime = (tRecipe.mDuration / (1 << tTier - 1));
+                } else {
+                    this.mEUt = tRecipe.mEUt;
+                    this.mMaxProgresstime = tRecipe.mDuration;
+                    while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) {
+                        this.mEUt *= 4;
+                        this.mMaxProgresstime /= 2;
+                    }
+                }
+                if (this.mEUt > 0) {
+                    this.mEUt = (-this.mEUt);
+                }
+                this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime);
+                this.mOutputFluids = new FluidStack[]{tRecipe.getFluidOutput(0)};
+                updateSlots();
+                return true;
+            }
+        }
+    	Utils.LOG_WARNING("Failed to find some Valid Inputs.");
+        return false;
+    }
+
+    @Override
+	public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
+        int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
+
+        //this.mHeatingCapacity = 0;
+        if (!aBaseMetaTileEntity.getAirOffset(xDir, 1, zDir)) {
+            return false;
+        }
+        if (!aBaseMetaTileEntity.getAirOffset(xDir, 2, zDir)) {
+            return false;
+        }
+        addMufflerToMachineList(aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir, 3, zDir), 72);
+
+        byte tUsedMeta = aBaseMetaTileEntity.getMetaIDOffset(xDir + 1, 2, zDir);
+             
+        this.mHeatingCapacity = 20000;
+        
+        for (int i = -1; i < 2; i++) {
+            for (int j = -1; j < 2; j++) {
+                if ((i != 0) || (j != 0)) {
+                    if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 2, zDir + j) != ModBlocks.blockCasingsMisc) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 2, zDir + j) != 14) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 1, zDir + j) != ModBlocks.blockCasingsMisc) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 1, zDir + j) != 14) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 3, zDir + j) != ModBlocks.blockCasingsMisc) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 3, zDir + j) != 15) {
+                        return false;
+                    }
+                }
+            }
+        }
+        for (int i = -1; i < 2; i++) {
+            for (int j = -1; j < 2; j++) {
+                if ((xDir + i != 0) || (zDir + j != 0)) {
+                    IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, 0, zDir + j);
+                    if ((!addMaintenanceToMachineList(tTileEntity, 72)) && (!addInputToMachineList(tTileEntity, 72)) && (!addOutputToMachineList(tTileEntity, 72)) && (!addEnergyInputToMachineList(tTileEntity, 72))) {
+                        if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 0, zDir + j) != ModBlocks.blockCasingsMisc) {
+                            return false;
+                        }
+                        if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 0, zDir + j) != 15) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        this.mHeatingCapacity += 100 * (GT_Utility.getTier(getMaxInputVoltage()) - 2);
+        return true;
+    }
+
+    @Override
+	public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+	public int getPollutionPerTick(ItemStack aStack) {
+        return 10;
+    }
+
+    @Override
+	public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+	public int getAmountOfOutputs() {
+        return 2;
+    }
+
+    @Override
+	public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCentrifuge.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialCentrifuge.java
index 13ae8e424f..0838bdefbd 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCentrifuge.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialCentrifuge.java
@@ -12,55 +12,45 @@ import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
-import gtPlusPlus.core.lib.CORE.configSwitches;
 import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock.CustomIcon;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import net.minecraft.block.Block;
-import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
-import net.minecraft.server.MinecraftServer;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
 
 import org.apache.commons.lang3.ArrayUtils;
 
-public class GregtechMetaTileEntityIndustrialCentrifuge
+public class GregtechMetaTileEntity_IndustrialCentrifuge
 extends GregtechMeta_MultiBlockBase {
 	private static boolean controller;
 	private static boolean isDisabled = false;
 	private static ITexture frontFace;
 	private static ITexture frontFaceActive;
-	private static Textures.BlockIcons.CustomIcon GT9_5_Active = new Textures.BlockIcons.CustomIcon("iconsets/LARGETURBINE_ST_ACTIVE5");
-	private static Textures.BlockIcons.CustomIcon GT9_5 = new Textures.BlockIcons.CustomIcon("iconsets/LARGETURBINE_ST5");
-	private static Textures.BlockIcons.CustomIcon GT8_5_Active = new Textures.BlockIcons.CustomIcon("iconsets/LARGETURBINE_ACTIVE5");
-	private static Textures.BlockIcons.CustomIcon GT8_5 = new Textures.BlockIcons.CustomIcon("iconsets/LARGETURBINE5");
+	private static CustomIcon GT9_5_Active = new CustomIcon("iconsets/LARGECENTRIFUGE_ACTIVE5");
+	private static CustomIcon GT9_5 = new CustomIcon("iconsets/LARGECENTRIFUGE5");
 	//public static double recipesComplete = 0;
 
-	public GregtechMetaTileEntityIndustrialCentrifuge(int aID, String aName, String aNameRegional) {
+	public GregtechMetaTileEntity_IndustrialCentrifuge(int aID, String aName, String aNameRegional) {
 		super(aID, aName, aNameRegional);
-		if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK){
 			frontFaceActive = new GT_RenderedTexture(GT9_5_Active);
 			frontFace = new GT_RenderedTexture(GT9_5);
-		}
-		else{
-			frontFaceActive = new GT_RenderedTexture(GT8_5_Active);
-			frontFace = new GT_RenderedTexture(GT8_5);
-		}
 	}
 
-	public GregtechMetaTileEntityIndustrialCentrifuge(String aName) {
+	public GregtechMetaTileEntity_IndustrialCentrifuge(String aName) {
 		super(aName);
 	}
 
 	@Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-		return new GregtechMetaTileEntityIndustrialCentrifuge(this.mName);
+		return new GregtechMetaTileEntity_IndustrialCentrifuge(this.mName);
 	}
 
 	@Override
@@ -239,13 +229,13 @@ extends GregtechMeta_MultiBlockBase {
 
 	@Override
 	public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
-		if (configSwitches.disableCentrifugeFormation){
+		/*if (configSwitches.disableCentrifugeFormation){
 			EntityPlayerMP player = MinecraftServer.getServer().getConfigurationManager().func_152612_a(this.getBaseMetaTileEntity().getOwnerName());
 			if (!player.getEntityWorld().isRemote && isDisabled == false)
-				Utils.messagePlayer(player, "This Multiblock is disabled via the config. [Only re-enable if you're bugtesting.]");
+				PlayerUtils.messagePlayer(player, "This Multiblock is disabled via the config. [Only re-enable if you're bugtesting.]");
 			isDisabled = true;
 			return false;
-		}
+		}*/
 		int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
 		int yDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetY;
 		int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCokeOven.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialCokeOven.java
index 9c67502cae..c2e2df7a8f 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCokeOven.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialCokeOven.java
@@ -11,6 +11,7 @@ import gregtech.api.util.GT_Utility;
 import gregtech.api.util.Recipe_GT;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
 
@@ -22,21 +23,21 @@ import net.minecraft.item.ItemStack;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
 
-public class GregtechMetaTileEntityIndustrialCokeOven
+public class GregtechMetaTileEntity_IndustrialCokeOven
         extends GregtechMeta_MultiBlockBase {
     private int mLevel = 0;
 
-    public GregtechMetaTileEntityIndustrialCokeOven(int aID, String aName, String aNameRegional) {
+    public GregtechMetaTileEntity_IndustrialCokeOven(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional);
     }
 
-    public GregtechMetaTileEntityIndustrialCokeOven(String aName) {
+    public GregtechMetaTileEntity_IndustrialCokeOven(String aName) {
         super(aName);
     }
 
     @Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-        return new GregtechMetaTileEntityIndustrialCokeOven(this.mName);
+        return new GregtechMetaTileEntity_IndustrialCokeOven(this.mName);
     }
 
     @Override
@@ -115,7 +116,12 @@ public class GregtechMetaTileEntityIndustrialCokeOven
             }
         }
         FluidStack[] tFluids = (FluidStack[]) Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tInputList.size()]), 0, 1);
-        if (tInputList.size() > 0) {
+        
+        int tValidOutputSlots = this.getValidOutputSlots(getRecipeMap(), tInputs);
+		Utils.LOG_WARNING("Valid Output Slots: "+tValidOutputSlots);
+		
+		//More than or one input
+		if (tInputList.size() > 0 && tValidOutputSlots >= 1) {
             long tVoltage = getMaxInputVoltage();
             byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
             GT_Recipe tRecipe = Recipe_GT.Gregtech_Recipe_Map.sCokeOvenRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], tFluids, tInputs);
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialElectrolyzer.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialElectrolyzer.java
index e300de3d88..1680006afd 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialElectrolyzer.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialElectrolyzer.java
@@ -6,13 +6,14 @@ import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
 import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -26,19 +27,19 @@ import net.minecraftforge.fluids.FluidStack;
 
 import org.apache.commons.lang3.ArrayUtils;
 
-public class GregtechMetaTileEntityIndustrialElectrolyzer
-extends GT_MetaTileEntity_MultiBlockBase {
-	public GregtechMetaTileEntityIndustrialElectrolyzer(int aID, String aName, String aNameRegional) {
+public class GregtechMetaTileEntity_IndustrialElectrolyzer
+extends GregtechMeta_MultiBlockBase {
+	public GregtechMetaTileEntity_IndustrialElectrolyzer(int aID, String aName, String aNameRegional) {
 		super(aID, aName, aNameRegional);
 	}
 
-	public GregtechMetaTileEntityIndustrialElectrolyzer(String aName) {
+	public GregtechMetaTileEntity_IndustrialElectrolyzer(String aName) {
 		super(aName);
 	}
 
 	@Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-		return new GregtechMetaTileEntityIndustrialElectrolyzer(this.mName);
+		return new GregtechMetaTileEntity_IndustrialElectrolyzer(this.mName);
 	}
 
 	@Override
@@ -76,11 +77,6 @@ extends GT_MetaTileEntity_MultiBlockBase {
 	}
 
 	@Override
-	public boolean isCorrectMachinePart(ItemStack aStack) {
-		return true;
-	}
-
-	@Override
 	public boolean isFacingValid(byte aFacing) {
 		return aFacing > 1;
 	}
@@ -119,7 +115,12 @@ extends GT_MetaTileEntity_MultiBlockBase {
             }
         }
         FluidStack[] tFluids = (FluidStack[]) Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tInputList.size()]), 0, 1);
-        if (tInputList.size() > 0) {
+        
+        int tValidOutputSlots = this.getValidOutputSlots(getRecipeMap(), tInputs);
+		Utils.LOG_WARNING("Valid Output Slots: "+tValidOutputSlots);
+		
+		//More than or one input
+		if (tInputList.size() > 0 && tValidOutputSlots >= 1) {
             long tVoltage = getMaxInputVoltage();
             byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
             GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sElectrolyzerRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], tFluids, tInputs);
@@ -242,11 +243,6 @@ extends GT_MetaTileEntity_MultiBlockBase {
 	}
 
 	@Override
-	public int getDamageToComponent(ItemStack aStack) {
-		return 0;
-	}
-
-	@Override
 	public int getAmountOfOutputs() {
 		return 1;
 	}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialMacerator.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialMacerator.java
index ff8b6c7f22..68b2f647ee 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialMacerator.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialMacerator.java
@@ -14,6 +14,7 @@ import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -24,21 +25,21 @@ import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.common.util.ForgeDirection;
 
-public class GregtechMetaTileEntityIndustrialMacerator
+public class GregtechMetaTileEntity_IndustrialMacerator
 extends GregtechMeta_MultiBlockBase {
 	private static boolean controller;
 
-	public GregtechMetaTileEntityIndustrialMacerator(int aID, String aName, String aNameRegional) {
+	public GregtechMetaTileEntity_IndustrialMacerator(int aID, String aName, String aNameRegional) {
 		super(aID, aName, aNameRegional);
 	}
 
-	public GregtechMetaTileEntityIndustrialMacerator(String aName) {
+	public GregtechMetaTileEntity_IndustrialMacerator(String aName) {
 		super(aName);
 	}
 
 	@Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-		return new GregtechMetaTileEntityIndustrialMacerator(this.mName);
+		return new GregtechMetaTileEntity_IndustrialMacerator(this.mName);
 	}
 
 	@Override
@@ -58,7 +59,7 @@ extends GregtechMeta_MultiBlockBase {
 	@Override
 	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
 		if (aSide == aFacing) {
-			return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[64], new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_STEAM_MACERATOR_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_STEAM_MACERATOR)};
+			return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[64], new GT_RenderedTexture(aActive ? TexturesGtBlock.Overlay_MatterFab_Active : TexturesGtBlock.Overlay_MatterFab)};
 		}
 		return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[64]};
 	}
@@ -107,6 +108,8 @@ extends GregtechMeta_MultiBlockBase {
 
 	@Override
 	public boolean checkRecipe(ItemStack aStack) {
+		
+		//Get inputs.
 		ArrayList<ItemStack> tInputList = getStoredInputs();
 		for (int i = 0; i < tInputList.size() - 1; i++) {
 			for (int j = i + 1; j < tInputList.size(); j++) {
@@ -120,16 +123,49 @@ extends GregtechMeta_MultiBlockBase {
 				}
 			}
 		}
+		
+		//Temp var
 		ItemStack[] tInputs = (ItemStack[]) Arrays.copyOfRange(tInputList.toArray(new ItemStack[tInputList.size()]), 0, 2);
-		if (tInputList.size() > 0) {
-			GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.findRecipe(getBaseMetaTileEntity(), false, 9223372036854775807L, null, tInputs);
+
+		//Don't check the recipe if someone got around the output bus size check.
+		if (this.mOutputBusses.size() != 5){
+			return false;
+		}
+		
+		//Make a recipe instance for the rest of the method.
+		GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.findRecipe(getBaseMetaTileEntity(), false, 9223372036854775807L, null, tInputs);
+		
+		
+		int tValidOutputSlots = this.getValidOutputSlots(getRecipeMap(), tInputs);
+		Utils.LOG_WARNING("Valid Output Slots: "+tValidOutputSlots);
+		
+		//More than or one input
+		if (tInputList.size() > 0 && tValidOutputSlots >= 1) {
 			if ((tRecipe != null) && (tRecipe.isRecipeInputEqual(true, null, tInputs))) {
+				Utils.LOG_WARNING("Valid Recipe found - size "+tRecipe.mOutputs.length);
 				this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
 				this.mEfficiencyIncrease = 10000;
 
+
 				this.mEUt = (-tRecipe.mEUt);
 				this.mMaxProgresstime = Math.max(1, (tRecipe.mDuration/5));
-				this.mOutputItems = new ItemStack[]{tRecipe.getOutput(0), tRecipe.getOutput(1)};
+				ItemStack[] outputs = new ItemStack[tRecipe.mOutputs.length];
+				for (int i = 0; i < tRecipe.mOutputs.length; i++){
+					if (i==0) {
+						Utils.LOG_WARNING("Adding the default output");
+						outputs[0] =  tRecipe.getOutput(i);
+					}
+					else if (getBaseMetaTileEntity().getRandomNumber(7500) < tRecipe.getOutputChance(i)){
+						Utils.LOG_WARNING("Adding a bonus output");
+						outputs[i] = tRecipe.getOutput(i); 
+					}
+					else {
+						Utils.LOG_WARNING("Adding null output");
+						outputs[i] = null;
+					}
+				}
+
+				this.mOutputItems = outputs;
 				sendLoopStart((byte) 20);
 				updateSlots();
 				return true;
@@ -194,56 +230,6 @@ extends GregtechMeta_MultiBlockBase {
 		return tAmount >= 26;
 	}
 
-	/*public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
-        int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
-        int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
-        if (!aBaseMetaTileEntity.getAirOffset(xDir, 1, zDir)) {
-            return false;
-        }
-        int tAmount = 0;
-        controller = false;
-        for (int i = -1; i < 2; i++) {
-            for (int j = -1; j < 2; j++) {
-                for (int h = 0; h < 6; h++) {
-                    if (!(i == 0 && j == 0 && (h > 0 && h < 5)))//((h > 0)&&(h<5)) || (((xDir + i != 0) || (zDir + j != 0)) && ((i != 0) || (j != 0)))
-                    {
-                        IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, h, zDir + j);
-                        if ((!addMaintenanceToMachineList(tTileEntity, 64)) && (!addInputToMachineList(tTileEntity, 64)) && (!addOutputToMachineList(tTileEntity, 64)) && (!addEnergyInputToMachineList(tTileEntity, 64)) && (!ignoreController(aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j)))) {
-                            if (aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j) != ModBlocks.blockCasingsMisc) {
-                                return false;
-                            }
-                            if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, h, zDir + j) != 1) {
-                                return false;
-                            }
-                            tAmount++;
-                        }
-                    }
-                }
-            }
-        }
-        if (this.mOutputBusses.size() != 5 || this.mInputBusses.size() != 1) {
-            return false;
-        }
-        int height = this.getBaseMetaTileEntity().getYCoord();
-        if (this.mInputHatches.get(0).getBaseMetaTileEntity().getYCoord() != height) {
-            return false;
-        }
-        GT_MetaTileEntity_Hatch_OutputBus[] tmpHatches = new GT_MetaTileEntity_Hatch_OutputBus[5];
-        for (int i = 0; i < this.mOutputBusses.size(); i++) {
-            int hatchNumber = this.mOutputBusses.get(i).getBaseMetaTileEntity().getYCoord() - 1 - height;
-            if (tmpHatches[hatchNumber] == null) {
-                tmpHatches[hatchNumber] = this.mOutputBusses.get(i);
-            } else {
-                return false;
-            }
-        }
-        this.mOutputBusses.clear();
-        for (int i = 0; i < tmpHatches.length; i++) {
-            this.mOutputBusses.add(tmpHatches[i]);
-        }
-        return tAmount >= 26;
-    }*/
-
 	public boolean ignoreController(Block tTileEntity) {
 		if (!controller && tTileEntity == GregTech_API.sBlockMachines) {
 			return true;
@@ -261,18 +247,18 @@ extends GregtechMeta_MultiBlockBase {
 		return 0;
 	}
 
-	/*@Override
-	public int getDamageToComponent(ItemStack aStack) {
-		return 0;
-	}*/
-
 	@Override
 	public int getAmountOfOutputs() {
-		return 2;
+		return 16;
 	}
 
 	@Override
 	public boolean explodesOnComponentBreak(ItemStack aStack) {
 		return false;
 	}
+
+	@Override
+	public boolean isOverclockerUpgradable() {
+		return true;
+	}
 }
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialPlatePress.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialPlatePress.java
index df60138c60..96095698fa 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialPlatePress.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialPlatePress.java
@@ -6,13 +6,14 @@ import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
 import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -23,19 +24,19 @@ import net.minecraft.item.ItemStack;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
 
-public class GregtechMetaTileEntityIndustrialPlatePress
-extends GT_MetaTileEntity_MultiBlockBase {
-	public GregtechMetaTileEntityIndustrialPlatePress(int aID, String aName, String aNameRegional) {
+public class GregtechMetaTileEntity_IndustrialPlatePress
+extends GregtechMeta_MultiBlockBase {
+	public GregtechMetaTileEntity_IndustrialPlatePress(int aID, String aName, String aNameRegional) {
 		super(aID, aName, aNameRegional);
 	}
 
-	public GregtechMetaTileEntityIndustrialPlatePress(String aName) {
+	public GregtechMetaTileEntity_IndustrialPlatePress(String aName) {
 		super(aName);
 	}
 
 	@Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-		return new GregtechMetaTileEntityIndustrialPlatePress(this.mName);
+		return new GregtechMetaTileEntity_IndustrialPlatePress(this.mName);
 	}
 
 	@Override
@@ -71,11 +72,6 @@ extends GT_MetaTileEntity_MultiBlockBase {
 	}
 
 	@Override
-	public boolean isCorrectMachinePart(ItemStack aStack) {
-		return true;
-	}
-
-	@Override
 	public boolean isFacingValid(byte aFacing) {
 		return aFacing > 1;
 	}
@@ -111,7 +107,11 @@ extends GT_MetaTileEntity_MultiBlockBase {
             }
         }
         FluidStack[] tFluids = (FluidStack[]) Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tInputList.size()]), 0, 1);
-        if (tInputList.size() > 0) {
+        
+        int tValidOutputSlots = this.getValidOutputSlots(getRecipeMap(), tInputs);
+		Utils.LOG_WARNING("Valid Output Slots: "+tValidOutputSlots);		
+		//More than or one input
+		if (tInputList.size() > 0 && tValidOutputSlots >= 1) {        
             long tVoltage = getMaxInputVoltage();
             byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
             GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sBenderRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], tFluids, tInputs);
@@ -188,11 +188,6 @@ extends GT_MetaTileEntity_MultiBlockBase {
 	}
 
 	@Override
-	public int getDamageToComponent(ItemStack aStack) {
-		return 0;
-	}
-
-	@Override
 	public int getAmountOfOutputs() {
 		return 1;
 	}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialSinter.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialSinter.java
index ca5e102521..ee49b7fcb9 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialSinter.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialSinter.java
@@ -22,23 +22,23 @@ import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 
-public class GregtechMetaTileEntityIndustrialSinter
+public class GregtechMetaTileEntity_IndustrialSinter
 extends GT_MetaTileEntity_MultiBlockBase {
 	
 
 	RenderBlocks asdasd = RenderBlocks.getInstance();
 	
-	public GregtechMetaTileEntityIndustrialSinter(int aID, String aName, String aNameRegional) {
+	public GregtechMetaTileEntity_IndustrialSinter(int aID, String aName, String aNameRegional) {
 		super(aID, aName, aNameRegional);
 	}
 
-	public GregtechMetaTileEntityIndustrialSinter(String aName) {
+	public GregtechMetaTileEntity_IndustrialSinter(String aName) {
 		super(aName);
 	}
 
 	@Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-		return new GregtechMetaTileEntityIndustrialSinter(this.mName);
+		return new GregtechMetaTileEntity_IndustrialSinter(this.mName);
 	}
 
 	@Override
@@ -151,7 +151,7 @@ extends GT_MetaTileEntity_MultiBlockBase {
 				IGregTechTileEntity tTileEntity;
 				if ((null != (tTileEntity = getBaseMetaTileEntity().getIGregTechTileEntityAtSideAndDistance(i, 2))) &&
 						(tTileEntity.getFrontFacing() == getBaseMetaTileEntity().getFrontFacing()) && (tTileEntity.getMetaTileEntity() != null) &&
-						((tTileEntity.getMetaTileEntity() instanceof GregtechMetaTileEntityIndustrialSinter))) {
+						((tTileEntity.getMetaTileEntity() instanceof GregtechMetaTileEntity_IndustrialSinter))) {
 					//Utils.LOG_INFO("False 1");
 					return false;
 				}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialWireMill.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialWireMill.java
index b0bc87c74a..ca300ba277 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialWireMill.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialWireMill.java
@@ -6,7 +6,6 @@ import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Maintenance;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
 import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
@@ -14,6 +13,7 @@ import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
 
 import java.util.ArrayList;
 
@@ -21,19 +21,19 @@ import net.minecraft.block.Block;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 
-public class GregtechMetaTileEntityIndustrialWireMill
-extends GT_MetaTileEntity_MultiBlockBase {
-	public GregtechMetaTileEntityIndustrialWireMill(int aID, String aName, String aNameRegional) {
+public class GregtechMetaTileEntity_IndustrialWireMill
+extends GregtechMeta_MultiBlockBase {
+	public GregtechMetaTileEntity_IndustrialWireMill(int aID, String aName, String aNameRegional) {
 		super(aID, aName, aNameRegional);
 	}
 
-	public GregtechMetaTileEntityIndustrialWireMill(String aName) {
+	public GregtechMetaTileEntity_IndustrialWireMill(String aName) {
 		super(aName);
 	}
 
 	@Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-		return new GregtechMetaTileEntityIndustrialWireMill(this.mName);
+		return new GregtechMetaTileEntity_IndustrialWireMill(this.mName);
 	}
 
 	@Override
@@ -69,11 +69,6 @@ extends GT_MetaTileEntity_MultiBlockBase {
 	}
 
 	@Override
-	public boolean isCorrectMachinePart(ItemStack aStack) {
-		return true;
-	}
-
-	@Override
 	public boolean isFacingValid(byte aFacing) {
 		return aFacing > 1;
 	}
@@ -87,6 +82,12 @@ extends GT_MetaTileEntity_MultiBlockBase {
 
 			GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sWiremillRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], null, new ItemStack[]{tInput});
 			if (tRecipe != null) {
+				
+				int tValidOutputSlots = this.getValidOutputSlots(getRecipeMap(), new ItemStack[]{tInput});
+				Utils.LOG_WARNING("Valid Output Slots: "+tValidOutputSlots);
+				//More than or one input
+				if (tInputList.size() > 0 && tValidOutputSlots >= 1) {
+				
 				if (tRecipe.isRecipeInputEqual(true, null, new ItemStack[]{tInput})) {
 					this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
 					this.mEfficiencyIncrease = 10000;
@@ -109,6 +110,7 @@ extends GT_MetaTileEntity_MultiBlockBase {
 					updateSlots();
 					return true;
 				}
+				}
 			}
 		}
 		return false;
@@ -136,7 +138,7 @@ extends GT_MetaTileEntity_MultiBlockBase {
 				IGregTechTileEntity tTileEntity;
 				if ((null != (tTileEntity = getBaseMetaTileEntity().getIGregTechTileEntityAtSideAndDistance(i, 2))) &&
 						(tTileEntity.getFrontFacing() == getBaseMetaTileEntity().getFrontFacing()) && (tTileEntity.getMetaTileEntity() != null) &&
-						((tTileEntity.getMetaTileEntity() instanceof GregtechMetaTileEntityIndustrialWireMill))) {
+						((tTileEntity.getMetaTileEntity() instanceof GregtechMetaTileEntity_IndustrialWireMill))) {
 					//Utils.LOG_INFO("False 1");
 					return false;
 				}
@@ -208,11 +210,6 @@ extends GT_MetaTileEntity_MultiBlockBase {
 	}
 
 	@Override
-	public int getDamageToComponent(ItemStack aStack) {
-		return 0;
-	}
-
-	@Override
 	public int getAmountOfOutputs() {
 		return 1;
 	}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIronBlastFurnace.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IronBlastFurnace.java
index 3edb17efcb..aa7aecc8c5 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIronBlastFurnace.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IronBlastFurnace.java
@@ -3,7 +3,6 @@ package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi;
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.OrePrefixes;
-import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.MetaTileEntity;
@@ -15,6 +14,7 @@ import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.xmod.gregtech.api.gui.CONTAINER_IronBlastFurnace;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_IronBlastFurnace;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.init.Blocks;
@@ -23,11 +23,11 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraftforge.common.util.ForgeDirection;
 
-public class GregtechMetaTileEntityIronBlastFurnace
+public class GregtechMetaTileEntity_IronBlastFurnace
         extends MetaTileEntity {
-    private static final ITexture[] FACING_SIDE = {new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_SOLID_STEEL)};
-    private static final ITexture[] FACING_FRONT = {new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_FRONT)};
-    private static final ITexture[] FACING_ACTIVE = {new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_FRONT_ACTIVE)};
+    private static final ITexture[] FACING_SIDE = {new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Simple_Top)};
+    private static final ITexture[] FACING_FRONT = {new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Redstone_Off)};
+    private static final ITexture[] FACING_ACTIVE = {new GT_RenderedTexture(TexturesGtBlock.Casing_Machine_Redstone_On)};
     public int mMaxProgresstime = 0;
     public int mUpdate = 30;
     public int mProgresstime = 0;
@@ -35,11 +35,11 @@ public class GregtechMetaTileEntityIronBlastFurnace
     public ItemStack mOutputItem1;
     public ItemStack mOutputItem2;
 
-    public GregtechMetaTileEntityIronBlastFurnace(int aID, String aName, String aNameRegional) {
+    public GregtechMetaTileEntity_IronBlastFurnace(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional, 4);
     }
 
-    public GregtechMetaTileEntityIronBlastFurnace(String aName) {
+    public GregtechMetaTileEntity_IronBlastFurnace(String aName) {
         super(aName, 4);
     }
 
@@ -139,7 +139,7 @@ public class GregtechMetaTileEntityIronBlastFurnace
 
     @Override
 	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-        return new GregtechMetaTileEntityIronBlastFurnace(this.mName);
+        return new GregtechMetaTileEntity_IronBlastFurnace(this.mName);
     }
 
     @Override
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityMassFabricator.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_MassFabricator.java
index 6fa5b9fcac..7f8db893c0 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityMassFabricator.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_MassFabricator.java
@@ -6,7 +6,6 @@ import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
 import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.util.GT_Config;
 import gregtech.api.util.GT_Recipe;
@@ -16,8 +15,10 @@ import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.core.util.fluid.FluidUtils;
-import gtPlusPlus.core.util.item.UtilsItems;
+import gtPlusPlus.core.util.item.ItemUtils;
 import gtPlusPlus.xmod.gregtech.api.gui.GUI_MatterFab;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -30,7 +31,7 @@ import net.minecraftforge.fluids.FluidStack;
 
 import org.apache.commons.lang3.ArrayUtils;
 
-public class GregtechMetaTileEntityMassFabricator extends GT_MetaTileEntity_MultiBlockBase {
+public class GregtechMetaTileEntity_MassFabricator extends GregtechMeta_MultiBlockBase {
 
 	public static int sUUAperUUM = 1;
 	public static int sUUASpeedBonus = 4;
@@ -38,7 +39,7 @@ public class GregtechMetaTileEntityMassFabricator extends GT_MetaTileEntity_Mult
 	public static boolean sRequiresUUA = false;
 	private int mAmplifierUsed = 0;
 	private int mMatterProduced = 0;
-	private static Block IC2Glass = Block.getBlockFromItem(UtilsItems.getItem("IC2:blockAlloyGlass"));
+	private static Block IC2Glass = Block.getBlockFromItem(ItemUtils.getItem("IC2:blockAlloyGlass"));
 	FluidStack tempFake = FluidUtils.getFluidStack("uuamplifier", 1);
 	GT_Recipe fakeRecipe;
 	
@@ -52,11 +53,11 @@ public class GregtechMetaTileEntityMassFabricator extends GT_MetaTileEntity_Mult
 	
 	//public FluidStack mFluidOut = Materials.UUMatter.getFluid(1L);
 
-	public GregtechMetaTileEntityMassFabricator(int aID, String aName, String aNameRegional) {
+	public GregtechMetaTileEntity_MassFabricator(int aID, String aName, String aNameRegional) {
 		super(aID, aName, aNameRegional);
 	}
 
-	public GregtechMetaTileEntityMassFabricator(String aName) {
+	public GregtechMetaTileEntity_MassFabricator(String aName) {
 		super(aName);
 	}
 
@@ -82,7 +83,7 @@ public class GregtechMetaTileEntityMassFabricator extends GT_MetaTileEntity_Mult
 	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
 		if (aSide == aFacing) {
 			return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[66],
-					new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_LARGE_BOILER_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_LARGE_BOILER)};
+					new GT_RenderedTexture(aActive ? TexturesGtBlock.Casing_Machine_Screen_3 : TexturesGtBlock.Casing_Machine_Screen_1)};
 		}
 		return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[66]};
 	}
@@ -315,11 +316,6 @@ public class GregtechMetaTileEntityMassFabricator extends GT_MetaTileEntity_Mult
 	}
 
 	@Override
-	public boolean isCorrectMachinePart(ItemStack aStack) {
-		return true;
-	}
-
-	@Override
 	public int getMaxEfficiency(ItemStack aStack) {
 		return 10000;
 	}
@@ -330,11 +326,6 @@ public class GregtechMetaTileEntityMassFabricator extends GT_MetaTileEntity_Mult
 	}
 
 	@Override
-	public int getDamageToComponent(ItemStack aStack) {
-		return 0;
-	}
-
-	@Override
 	public int getAmountOfOutputs() {
 		return 1;
 	}
@@ -346,7 +337,7 @@ public class GregtechMetaTileEntityMassFabricator extends GT_MetaTileEntity_Mult
 
 	@Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-		return new GregtechMetaTileEntityMassFabricator(this.mName);
+		return new GregtechMetaTileEntity_MassFabricator(this.mName);
 	}
 
 }
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityMultiTank.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_MultiTank.java
index 7d6c3caec7..32759c4024 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityMultiTank.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_MultiTank.java
@@ -21,9 +21,9 @@ import net.minecraft.nbt.NBTTagCompound;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
 
-public class GregtechMetaTileEntityMultiTank
+public class GregtechMetaTileEntity_MultiTank
         extends GregtechMeta_MultiBlockBase {
-    public GregtechMetaTileEntityMultiTank(int aID, String aName, String aNameRegional) {
+    public GregtechMetaTileEntity_MultiTank(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional);
     }
 
@@ -114,13 +114,13 @@ public class GregtechMetaTileEntityMultiTank
         mCrowbar = aNBT.getBoolean("mCrowbar");
     }
     
-    public GregtechMetaTileEntityMultiTank(String aName) {
+    public GregtechMetaTileEntity_MultiTank(String aName) {
         super(aName);
     }
 
     @Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-        return new GregtechMetaTileEntityMultiTank(this.mName);
+        return new GregtechMetaTileEntity_MultiTank(this.mName);
     }
 
     @Override
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityPowerSubStationController.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_PowerSubStationController.java
index b85e011115..45635ea74d 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityPowerSubStationController.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_PowerSubStationController.java
@@ -15,15 +15,15 @@ import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.common.util.ForgeDirection;
 
-public class GregtechMetaTileEntityPowerSubStationController extends GT_MetaTileEntity_MultiBlockBase {
+public class GregtechMetaTileEntity_PowerSubStationController extends GT_MetaTileEntity_MultiBlockBase {
 
 	private int recipeCounter = 0;
 
-	public GregtechMetaTileEntityPowerSubStationController(int aID, String aName, String aNameRegional) {
+	public GregtechMetaTileEntity_PowerSubStationController(int aID, String aName, String aNameRegional) {
 		super(aID, aName, aNameRegional);
 	}
 
-	public GregtechMetaTileEntityPowerSubStationController(String aName) {
+	public GregtechMetaTileEntity_PowerSubStationController(String aName) {
 		super(aName);
 	}
 
@@ -39,10 +39,10 @@ public class GregtechMetaTileEntityPowerSubStationController extends GT_MetaTile
 	@Override
 	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
 		if (aSide == aFacing) {
-			return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[66],
+			return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[67],
 					new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_LARGE_BOILER_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_LARGE_BOILER)};
 		}
-		return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[66]};
+		return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[67]};
 	}
 
 	@Override
@@ -183,7 +183,7 @@ public class GregtechMetaTileEntityPowerSubStationController extends GT_MetaTile
 
 	@Override
 	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-		return new GregtechMetaTileEntityPowerSubStationController(this.mName);
+		return new GregtechMetaTileEntity_PowerSubStationController(this.mName);
 	}
 
 }
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/storage/GT_MetaTileEntity_TieredTank.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/storage/GT_MetaTileEntity_TieredTank.java
index 7946f5f8e5..7508391f93 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/storage/GT_MetaTileEntity_TieredTank.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/storage/GT_MetaTileEntity_TieredTank.java
@@ -5,188 +5,223 @@ import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank;
 import gregtech.api.objects.GT_RenderedTexture;
-import gtPlusPlus.core.util.Utils;
-import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.lossless.GregtechMetaTileEntityLosslessBasicTank;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.fluid.FluidUtils;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.nbt.NBTTagCompound;
-import net.minecraftforge.fluids.FluidStack;
 
 public class GT_MetaTileEntity_TieredTank
-        extends GregtechMetaTileEntityLosslessBasicTank {
-	
-	//protected FluidStack internalTank = getInternalStack();
-	/*protected String fluidName = getFluidName();
-	protected int fluidAmount = getInternalFluidAmount();*/
+extends GT_MetaTileEntity_BasicTank {
+
+	private NBTTagCompound mRecipeStuff = new NBTTagCompound();
+	private String mFluidName;
+	private int mFluidAmount;
+
+	public GT_MetaTileEntity_TieredTank(int aID, String aName, String aNameRegional, int aTier) {
+		super(aID, aName, aNameRegional, aTier, 3, "Stores " + ((int) (Math.pow(2, aTier) * 32000)) + "L of fluid");
+	}
+
+	public GT_MetaTileEntity_TieredTank(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+		super(aName, aTier, 3, aDescription, aTextures);
+	}
+
+	@Override
+	public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+		return new ITexture[0][0][0];
+	}
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+		return aSide == 1 ? new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_POTIONBREWER_ACTIVE)} : new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_POTIONBREWER)};
+	}
+
 	
-	/*private String getFluidName(){
-		String x;
-		if (internalTank != null){
-			x = internalTank.getFluid().getName();
+	private boolean setVars(){
+		//Utils.LOG_INFO("setting Vars.");
+		if (mFluidName.equals("") || !mFluidName.equals(null)){
+			if (mFluid != null)	mFluidName = mFluid.getFluid().getName();
+		}
+		else{
+			if (mFluid != null){
+				if (!mFluidName.equalsIgnoreCase(mFluid.getFluid().getName())){
+					mFluidName = mFluid.getFluid().getName();
+				}
+			}
+			else {
+				// Leave Values Blank.	
+				return false;
+			}
+		}
+
+		if (mFluidAmount <= 0){
+			if (mFluid != null)	mFluidAmount = mFluid.amount;
 		}
 		else {
-			x = "null";
+			if (mFluid != null){
+				if (mFluidAmount != mFluid.amount){
+					mFluidAmount = mFluid.amount;
+				}
+			}
+			else {
+				// Leave Values Blank.	
+				return false;
+			}
 		}
-		return x;
+		return true;
 	}
 	
-	private int getInternalFluidAmount(){
-		int x;
-		if (internalTank != null){
-			x = internalTank.amount;
+
+	@Override
+	public String[] getDescription() {
+		
+		setVars();
+
+
+		if ((mFluidName.equals("Empty")||mFluidName.equals("")) || mFluidAmount <= 0){
+			return new String[] {mDescription, CORE.GT_Tooltip};
 		}
-		else {
-			x = 0;
+		return new String[] {mDescription, "Stored Fluid: "+mFluidName, "Stored Amount: "+mFluidAmount+"l", CORE.GT_Tooltip};
+	}
+
+
+	@Override
+	public void saveNBTData(NBTTagCompound aNBT) {
+		super.saveNBTData(aNBT);
+		setVars();
+		mRecipeStuff.setString("mFluidName", mFluidName);		
+		mRecipeStuff.setInteger("mFluidAmount", mFluidAmount);
+		aNBT.setTag("GT.CraftingComponents", mRecipeStuff);
+	}
+
+	@Override
+	public void loadNBTData(NBTTagCompound aNBT) {
+		super.loadNBTData(aNBT);  
+		mRecipeStuff = aNBT.getCompoundTag("GT.CraftingComponents");
+		mFluidName = mRecipeStuff.getString("mFluidName");
+		mFluidAmount = mRecipeStuff.getInteger("mFluidAmount");
+		mFluid = FluidUtils.getFluidStack(mFluidName, mFluidAmount);
+		setItemNBT(aNBT);
+	}
+
+	@Override
+	public void setItemNBT(NBTTagCompound aNBT) {
+		super.setItemNBT(aNBT);
+		mRecipeStuff.setString("mFluidName", mFluidName);		
+		mRecipeStuff.setInteger("mFluidAmount", mFluidAmount);
+		aNBT.setTag("GT.CraftingComponents", mRecipeStuff);
+	}
+
+
+	@Override
+	public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+		if (aBaseMetaTileEntity.isClientSide()){
+			return true;
 		}
-		return x;
-	}*/
-	
-    public GT_MetaTileEntity_TieredTank(int aID, String aName, String aNameRegional, int aTier) {
-        super(aID, aName, aNameRegional, aTier, 3, "Stores " + ((int) (Math.pow(2, aTier) * 32000)) + "L of fluid");
-    }
-
-    public GT_MetaTileEntity_TieredTank(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
-        super(aName, aTier, 3, aDescription, aTextures);
-    }
-
-    @Override
-    public ITexture[][][] getTextureSet(ITexture[] aTextures) {
-        return new ITexture[0][0][0];
-    }
-
-    @Override
-    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
-        return aSide == 1 ? new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_POTIONBREWER_ACTIVE)} : new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_POTIONBREWER)};
-    }
-
-   /* @Override
-    public void saveNBTData(NBTTagCompound aNBT) {
-        super.saveNBTData(aNBT);
-    }
-    
-    @Override
-    public void loadNBTData(NBTTagCompound aNBT) {
-        super.loadNBTData(aNBT);
-    }*/
-    
-    @Override
-    public void saveNBTData(NBTTagCompound aNBT) {
-        super.saveNBTData(aNBT);
-        Utils.LOG_INFO("Dumping Fluid data. Name: "+mFluid.getFluid().getName()+" Amount: "+mFluid.amount+"L");
-        if (mFluid != null) aNBT.setTag("mFluid", mFluid.writeToNBT(new NBTTagCompound()));
-    }
-
-    @Override
-    public void loadNBTData(NBTTagCompound aNBT) {
-        super.loadNBTData(aNBT);
-        mFluid = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mFluid"));
-        /*if (getInternalStack() != null){
-        Utils.LOG_INFO("Dumping Fluid data. Name: "+mFluid.getFluid().getName()+" Amount: "+mFluid.amount+"L");}
-        else{
-        //Utils.LOG_INFO("Loaded FluidStack was NULL");
-        	}*/
-    }
-
-    @Override
-    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
-    	Utils.LOG_INFO("Right Click on Block");
-        if (aBaseMetaTileEntity.isClientSide()){
-        	Utils.LOG_INFO("MTE is ClientSide");
-        	return true;
-        }
-    	Utils.LOG_INFO("MTE is not ClientSide");
-        aBaseMetaTileEntity.openGUI(aPlayer);
-    	Utils.LOG_INFO("MTE is now has an open GUI");
-        return true;
-    }
-
-    @Override
-    public boolean isSimpleMachine() {
-        return true;
-    }
-
-    @Override
-    public boolean isFacingValid(byte aFacing) {
-        return true;
-    }
-
-    @Override
-    public boolean isAccessAllowed(EntityPlayer aPlayer) {
-        return true;
-    }
-
-    @Override
-    public final byte getUpdateData() {
-        return 0x00;
-    }
-
-    @Override
-    public boolean doesFillContainers() {
-        return true;
-    }
-
-    @Override
-    public boolean doesEmptyContainers() {
-        return true;
-    }
-
-    @Override
-    public boolean canTankBeFilled() {
-        return true;
-    }
-
-    @Override
-    public boolean canTankBeEmptied() {
-        return true;
-    }
-
-    @Override
-    public boolean displaysItemStack() {
-        return true;
-    }
-
-    @Override
-    public boolean displaysStackSize() {
-        return false;
-    }
-
-    @Override
-    public String[] getInfoData() {
-
-        if (mFluid == null) {
-            return new String[]{
-                    GT_Values.VOLTAGE_NAMES[mTier]+" Fluid Tank",
-                    "Stored Fluid:",
-                    "No Fluid",
-                    Integer.toString(0) + "L",
-                    Integer.toString(getCapacity()) + "L"};
-        }
-        return new String[]{
-                GT_Values.VOLTAGE_NAMES[mTier]+" Fluid Tank",
-                "Stored Fluid:",
-                mFluid.getLocalizedName(),
-                Integer.toString(mFluid.amount) + "L",
-                Integer.toString(getCapacity()) + "L"};
-    }
-
-    @Override
-    public boolean isGivingInformation() {
-        return true;
-    }
-
-    @Override
-    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-        return new GT_MetaTileEntity_TieredTank(mName, mTier, mDescription, mTextures);
-    }
-
-    @Override
-    public int getCapacity() {
-        return (int) (Math.pow(2, mTier) * 32000);
-    }
-
-    @Override
-    public int getTankPressure() {
-        return 100;
-    }
+		aBaseMetaTileEntity.openGUI(aPlayer);
+		return true;
+	}
+
+	@Override
+	public boolean isSimpleMachine() {
+		return true;
+	}
+
+	@Override
+	public boolean isFacingValid(byte aFacing) {
+		return true;
+	}
+
+	@Override
+	public boolean isAccessAllowed(EntityPlayer aPlayer) {
+		return true;
+	}
+
+	@Override
+	public final byte getUpdateData() {
+		return 0x00;
+	}
+
+	@Override
+	public boolean doesFillContainers() {
+		return true;
+	}
+
+	@Override
+	public boolean doesEmptyContainers() {
+		return true;
+	}
+
+	@Override
+	public boolean canTankBeFilled() {
+		return true;
+	}
+
+	@Override
+	public boolean canTankBeEmptied() {
+		return true;
+	}
+
+	@Override
+	public boolean displaysItemStack() {
+		return true;
+	}
+
+	@Override
+	public boolean displaysStackSize() {
+		return false;
+	}
+
+	@Override
+	public String[] getInfoData() {
+
+		if (mFluid == null) {
+			return new String[]{
+					GT_Values.VOLTAGE_NAMES[mTier]+" Fluid Tank",
+					"Stored Fluid:",
+					"No Fluid",
+					Integer.toString(0) + "L",
+					Integer.toString(getCapacity()) + "L"};
+		}
+		return new String[]{
+				GT_Values.VOLTAGE_NAMES[mTier]+" Fluid Tank",
+				"Stored Fluid:",
+				mFluid.getLocalizedName(),
+				Integer.toString(mFluid.amount) + "L",
+				Integer.toString(getCapacity()) + "L"};
+	}
+
+	@Override
+	public boolean isGivingInformation() {
+		return true;
+	}
+
+	@Override
+	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GT_MetaTileEntity_TieredTank(mName, mTier, mDescription, mTextures);
+	}
+
+	@Override
+	public int getCapacity() {
+		return (int) (Math.pow(2, mTier) * 32000);
+	}
+
+	@Override
+	public int getTankPressure() {
+		return 100;
+	}
+
+	@Override
+	public void onMachineBlockUpdate() {
+		this.getBaseMetaTileEntity().markDirty();
+		super.onMachineBlockUpdate();
+	}
+
+	@Override
+	public void onRemoval() {
+		this.getBaseMetaTileEntity().markDirty();
+		super.onRemoval();
+	}
 
 }
\ No newline at end of file