$ Fixed the XP Convertor.

% Rewrote base tile entity system.
% Added hashCode() to Pair.java.
% Changed some calculations on Materials.
% Made Rocket Engines produce heavy pollution.

6 files changed, 1478 insertions, 246 deletions

diff --git a/src/Java/gtPlusPlus/core/tileentities/base/TileBasicTank.java b/src/Java/gtPlusPlus/core/tileentities/base/TileBasicTank.java
new file mode 100644
index 0000000000..671a49fca5
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/tileentities/base/TileBasicTank.java
@@ -0,0 +1,150 @@
+package gtPlusPlus.core.tileentities.base;
+
+import gtPlusPlus.api.objects.minecraft.BTF_FluidTank;
+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;
+import net.minecraftforge.fluids.IFluidTank;
+
+public class TileBasicTank extends TileEntityBase implements IFluidHandler, IFluidTank {
+
+	public final BTF_FluidTank mTank;
+	
+	public TileBasicTank(int aMaxSlots, int aFluidCapacity) {
+		super(aMaxSlots);
+		mTank = new BTF_FluidTank(aFluidCapacity);
+	}
+	
+	@Override
+	public boolean onPreTick(long aTick) {		
+
+		if (this.isServerSide()) {
+			if (mTank.isFluidChangingAllowed() && mTank.getFillableStack() != null
+					&& mTank.getFillableStack().amount <= 0) {
+				mTank.setFillableStack((FluidStack) null);
+			}
+		}
+
+		return super.onPreTick(aTick);
+		
+	}	
+
+	
+	private final boolean canFillEx(ForgeDirection aSide, Fluid aFluid) {
+		return this.fill(aSide, new FluidStack(aFluid, 1), false) == 1;
+	}
+
+	
+	private final boolean canDrainEx(ForgeDirection aSide, Fluid aFluid) {
+		return this.drain(aSide, new FluidStack(aFluid, 1), false) != null;
+	}
+
+	
+	private final FluidTankInfo[] getTankInfoEx(ForgeDirection aSide) {
+		return mTank.getCapacity() <= 0 ? new FluidTankInfo[0]
+				: new FluidTankInfo[]{mTank.getInfo()};
+	}
+
+	private final int fill_default(ForgeDirection aSide, FluidStack aFluid, boolean doFill) {
+		return mTank.fill(aFluid, doFill);
+	}
+
+	
+	private final int fillEx(ForgeDirection aSide, FluidStack aFluid, boolean doFill) {
+			return this.fill_default(aSide, aFluid, doFill);
+	}
+
+	
+	private final FluidStack drainEx(ForgeDirection aSide, FluidStack aFluid, boolean doDrain) {
+		return mTank.getFluid() != null && aFluid != null && mTank.getFluid().isFluidEqual(aFluid)
+				? mTank.drain(aFluid.amount, doDrain)
+				: null;
+	}
+
+	
+	private final FluidStack drainEx(ForgeDirection aSide, int maxDrain, boolean doDrain) {
+		return mTank.drain(maxDrain, doDrain);
+	}
+	
+	
+	public boolean isLiquidInput(byte aSide) {
+		return true;
+	}
+
+	public boolean isLiquidOutput(byte aSide) {
+		return true;
+	}
+	
+	@Override
+    public int fill(ForgeDirection aSide, FluidStack aFluid, boolean doFill) {
+        if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mInputDisabled) && (aSide == ForgeDirection.UNKNOWN || (this.isLiquidInput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidIn((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), aFluid == null ? null : aFluid.getFluid(), this))))
+            return this.fillEx(aSide, aFluid, doFill);
+        return 0;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection aSide, int maxDrain, boolean doDrain) {
+        if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mOutputDisabled) && (aSide == ForgeDirection.UNKNOWN || (this.isLiquidOutput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidOut((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), this.getFluid() == null ? null : this.getFluid().getFluid(), this))))
+            return this.drainEx(aSide, maxDrain, doDrain);
+        return null;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain) {
+        if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mOutputDisabled) && (aSide == ForgeDirection.UNKNOWN || (this.isLiquidOutput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidOut((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), aFluid == null ? null : aFluid.getFluid(), this))))
+            return this.drainEx(aSide, aFluid, doDrain);
+        return null;
+    }
+
+    @Override
+    public boolean canFill(ForgeDirection aSide, Fluid aFluid) {
+        if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mInputDisabled) && (aSide == ForgeDirection.UNKNOWN || (this.isLiquidInput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidIn((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), aFluid, this))))
+            return this.canFillEx(aSide, aFluid);
+        return false;
+    }
+
+    @Override
+    public boolean canDrain(ForgeDirection aSide, Fluid aFluid) {
+        if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mOutputDisabled) && (aSide == ForgeDirection.UNKNOWN || (this.isLiquidOutput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidOut((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), aFluid, this))))
+            return this.canDrainEx(aSide, aFluid);
+        return false;
+    }
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection aSide) {
+        if (canAccessData() && (aSide == ForgeDirection.UNKNOWN || (this.isLiquidInput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidIn((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), null, this)) || (this.isLiquidOutput((byte) aSide.ordinal()) && getCoverBehaviorAtSide((byte) aSide.ordinal()).letsFluidOut((byte) aSide.ordinal(), getCoverIDAtSide((byte) aSide.ordinal()), getCoverDataAtSide((byte) aSide.ordinal()), null, this))))
+            return this.getTankInfoEx(aSide);
+        return new FluidTankInfo[]{};
+    }
+    
+	@Override
+	public FluidStack getFluid() {
+		return mTank.getFluid();
+	}
+
+	@Override
+	public int getFluidAmount() {
+		return mTank.getFluidAmount();
+	}
+
+	@Override
+	public FluidTankInfo getInfo() {
+		return mTank.getInfo();
+	}
+
+	@Override
+	public int fill(FluidStack resource, boolean doFill) {
+		return mTank.fill(resource, doFill);
+	}
+
+	@Override
+	public FluidStack drain(int maxDrain, boolean doDrain) {
+		return mTank.drain(maxDrain, doDrain);
+	}
+	
+	
+	
+	
+}
diff --git a/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java b/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java
index 90c37e140a..c619cbb3ea 100644
--- a/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java
+++ b/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java
@@ -2,21 +2,48 @@ package gtPlusPlus.core.tileentities.base;
 
 import java.util.UUID;
 
+import gregtech.GT_Mod;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.interfaces.IDescribable;
+import gregtech.api.interfaces.tileentity.IGregTechDeviceInformation;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.net.GT_Packet_Block_Event;
+import gregtech.api.util.GT_CoverBehavior;
+import gregtech.api.util.GT_LanguageManager;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+import net.minecraft.block.Block;
+import net.minecraft.entity.item.EntityItem;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.init.Blocks;
+import net.minecraft.inventory.IInventory;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
-
+import net.minecraft.world.World;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.IFluidHandler;
+import gtPlusPlus.api.interfaces.ILazyCoverable;
 import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.minecraft.BTF_Inventory;
+import gtPlusPlus.core.util.minecraft.gregtech.PollutionUtils;
+import ic2.api.Direction;
 
-public abstract class TileEntityBase extends TileEntity implements ISidedInventory {
+public class TileEntityBase extends TileEntity implements ILazyCoverable, IGregTechDeviceInformation, IDescribable {
 
 	private String customName;
 	public String mOwnerName = "null";
 	public String mOwnerUUID = "null";	
 	private boolean mIsOwnerOP = false;
 
+	public final BTF_Inventory mInventory;
+
+	public TileEntityBase(int aCapacity) {
+		mInventory = new BTF_Inventory(aCapacity, this);
+	}
+
 	public NBTTagCompound getTag(final NBTTagCompound nbt, final String tag){
 		if(!nbt.hasKey(tag))
 		{
@@ -27,13 +54,10 @@ public abstract class TileEntityBase extends TileEntity implements ISidedInvento
 
 	@Override
 	public void writeToNBT(final NBTTagCompound nbt){
-
 		super.writeToNBT(nbt);
-
 		if (this.hasCustomInventoryName()) {
 			nbt.setString("CustomName", this.getCustomName());
 		}
-
 		nbt.setBoolean("mIsOwnerOP", this.mIsOwnerOP);
 		nbt.setString("mOwnerName", this.mOwnerName);
 		nbt.setString("mOwnerUUID", this.mOwnerUUID);
@@ -55,9 +79,11 @@ public abstract class TileEntityBase extends TileEntity implements ISidedInvento
 
 	@Override
 	public void updateEntity() {
+		long aTick = System.currentTimeMillis();
+		this.isDead = false;
 		try{
 			if (this.isServerSide()){
-				onPreTick();
+				onPreTick(aTick);
 			}
 		} catch (Throwable t){
 			Logger.ERROR("Tile Entity Encountered an error in it's pre-tick stage.");
@@ -65,7 +91,7 @@ public abstract class TileEntityBase extends TileEntity implements ISidedInvento
 		}
 		try{
 			if (this.isServerSide()){
-				onTick();
+				onTick(aTick);
 			}
 		} catch (Throwable t){
 			Logger.ERROR("Tile Entity Encountered an error in it's tick stage.");
@@ -73,7 +99,7 @@ public abstract class TileEntityBase extends TileEntity implements ISidedInvento
 		}
 		try{
 			if (this.isServerSide()){
-				onPostTick();
+				onPostTick(aTick);
 			}
 		} catch (Throwable t){
 			Logger.ERROR("Tile Entity Encountered an error in it's post-tick stage.");
@@ -81,11 +107,11 @@ public abstract class TileEntityBase extends TileEntity implements ISidedInvento
 		}
 	}
 
-	public boolean onPreTick(){
+	public boolean onPreTick(long aTick) {
 		return true;
 	}
 
-	public boolean onTick(){
+	public boolean onTick(long aTick){
 		try{
 			if (this.isServerSide()){
 				processRecipe();
@@ -97,11 +123,10 @@ public abstract class TileEntityBase extends TileEntity implements ISidedInvento
 		return true;
 	}
 
-	public boolean onPostTick(){
-
+	public boolean onPostTick(long aTick){
 		return true;
 	}
-	
+
 	public boolean processRecipe(){
 		return true;
 	}	
@@ -145,6 +170,10 @@ public abstract class TileEntityBase extends TileEntity implements ISidedInvento
 		return false;
 	}
 
+	public final boolean isClientSide() {
+		return this.worldObj.isRemote;
+	}
+
 	public String getCustomName() {
 		return this.customName;
 	}
@@ -164,42 +193,1107 @@ public abstract class TileEntityBase extends TileEntity implements ISidedInvento
 	}
 
 	@Override
-	public abstract int getSizeInventory();
+	public int getSizeInventory() {
+		return this.mInventory.getSizeInventory();
+	}
 
 	@Override
-	public abstract ItemStack getStackInSlot(int p_70301_1_);
+	public ItemStack getStackInSlot(int aIndex) {
+		return this.mInventory.getStackInSlot(aIndex);
+	}
+
+    @Override
+    public ItemStack decrStackSize(int aIndex, int aAmount) {
+        if (canAccessData()) {
+            mInventoryChanged = true;
+            return mInventory.decrStackSize(aIndex, aAmount);
+        }
+        return null;
+    }
 
 	@Override
-	public abstract ItemStack decrStackSize(int p_70298_1_, int p_70298_2_);
+	public ItemStack getStackInSlotOnClosing(int p_70304_1_) {
+		return this.mInventory.getStackInSlotOnClosing(p_70304_1_);
+	}
 
 	@Override
-	public abstract ItemStack getStackInSlotOnClosing(int p_70304_1_);
+	public void setInventorySlotContents(int p_70299_1_, ItemStack p_70299_2_) {
+		this.mInventory.setInventorySlotContents(p_70299_1_, p_70299_2_);
+	}
 
 	@Override
-	public abstract void setInventorySlotContents(int p_70299_1_, ItemStack p_70299_2_);
+	public int getInventoryStackLimit() {
+		return this.mInventory.getInventoryStackLimit();
+	}
 
 	@Override
-	public abstract int getInventoryStackLimit();
+	public boolean isUseableByPlayer(EntityPlayer p_70300_1_) {
+		return this.mInventory.isUseableByPlayer(p_70300_1_);
+	}
 
 	@Override
-	public abstract boolean isUseableByPlayer(EntityPlayer p_70300_1_);
+	public void openInventory() {
+		this.mInventory.openInventory();
+	}
 
 	@Override
-	public abstract void openInventory();
+	public void closeInventory() {
+		this.mInventory.closeInventory();
+	}
+
+	  /**
+     * Can put aStack into Slot
+     */
+    @Override
+    public boolean isItemValidForSlot(int aIndex, ItemStack aStack) {
+        return canAccessData() && mInventory.isItemValidForSlot(aIndex, aStack);
+    }
+
+    /**
+     * returns all valid Inventory Slots, no matter which Side (Unless it's covered).
+     * The Side Stuff is done in the following two Functions.
+     */
+    @Override
+    public int[] getAccessibleSlotsFromSide(int aSide) {
+        if (canAccessData() && (getCoverBehaviorAtSide((byte) aSide).letsItemsOut((byte) aSide, getCoverIDAtSide((byte) aSide), getCoverDataAtSide((byte) aSide), -1, this) || getCoverBehaviorAtSide((byte) aSide).letsItemsIn((byte) aSide, getCoverIDAtSide((byte) aSide), getCoverDataAtSide((byte) aSide), -1, this)))
+            return mInventory.getAccessibleSlotsFromSide(aSide);
+        return new int[0];
+    }
+
+    /**
+     * Can put aStack into Slot at Side
+     */
+    @Override
+    public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide) {
+        return canAccessData() && (mRunningThroughTick || !mInputDisabled) && getCoverBehaviorAtSide((byte) aSide).letsItemsIn((byte) aSide, getCoverIDAtSide((byte) aSide), getCoverDataAtSide((byte) aSide), aIndex, this) && mInventory.canInsertItem(aIndex, aStack, aSide);
+    }
+
+    /**
+     * Can pull aStack out of Slot from Side
+     */
+    @Override
+    public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide) {
+        return canAccessData() && (mRunningThroughTick || !mOutputDisabled) && getCoverBehaviorAtSide((byte) aSide).letsItemsOut((byte) aSide, getCoverIDAtSide((byte) aSide), getCoverDataAtSide((byte) aSide), aIndex, this) && mInventory.canExtractItem(aIndex, aStack, aSide);
+    }
+	
 
 	@Override
-	public abstract void closeInventory();
+	public boolean isValidSlot(int aIndex) {
+		return this.canAccessData() ? this.mInventory.isValidSlot(aIndex) : false;
+	}
+
+
+
+
+	private final GT_CoverBehavior[] mCoverBehaviors = new GT_CoverBehavior[] { GregTech_API.sNoBehavior,
+			GregTech_API.sNoBehavior, GregTech_API.sNoBehavior, GregTech_API.sNoBehavior, GregTech_API.sNoBehavior,
+			GregTech_API.sNoBehavior };
+	protected TileEntityBase mMetaTileEntity;
+	protected long mStoredEnergy = 0;
+	protected int mAverageEUInputIndex = 0, mAverageEUOutputIndex = 0;
+	protected boolean mReleaseEnergy = false;
+	protected int[] mAverageEUInput = new int[11], mAverageEUOutput = new int[11];
+	private boolean[] mActiveEUInputs = new boolean[] { false, false, false, false, false, false },
+			mActiveEUOutputs = new boolean[] { false, false, false, false, false, false };
+	private byte[] mSidedRedstone = new byte[] { 15, 15, 15, 15, 15, 15 };
+	private int[] mCoverSides = new int[] { 0, 0, 0, 0, 0, 0 }, mCoverData = new int[] { 0, 0, 0, 0, 0, 0 },
+			mTimeStatistics = new int[GregTech_API.TICKS_FOR_LAG_AVERAGING];
+	private boolean mHasEnoughEnergy = true;
+	protected boolean mRunningThroughTick = false;
+	protected boolean mInputDisabled = false;
+	protected boolean mOutputDisabled = false;
+	private boolean mMuffler = false;
+	private boolean mLockUpgrade = false;
+	private boolean mActive = false;
+	private boolean mRedstone = false;
+	private boolean mWorkUpdate = false;
+	private boolean mSteamConverter = false;
+	private boolean mInventoryChanged = false;
+	private boolean mWorks = true;
+	private boolean mNeedsUpdate = true;
+	private boolean mNeedsBlockUpdate = true;
+	private boolean mSendClientData = false;
+	private boolean oRedstone = false;
+	private boolean mEnergyStateReady = false;
+	private byte mColor = 0, oColor = 0, mStrongRedstone = 0, oRedstoneData = 63, oTextureData = 0, oUpdateData = 0,
+			oTexturePage = 0, oLightValueClient = -1, oLightValue = -1, mLightValue = 0, mOtherUpgrades = 0,
+			mFacing = 0, oFacing = 0, mWorkData = 0;
+	private int mDisplayErrorCode = 0, oX = 0, oY = 0, oZ = 0, mTimeStatisticsIndex = 0, mLagWarningCount = 0;
+	private short mID = 0;
+	protected long mTickTimer = 0;
+	private long oOutput = 0;
+	private long mAcceptedAmperes = Long.MAX_VALUE;
+
+
+	/**
+	 * Cover Support
+	 */
+
+	public void issueClientUpdate() {
+		this.mSendClientData = true;
+	}
+	
+    protected final boolean canAccessData() {
+        return !isDead() && !this.isInvalid();
+    }
 
 	@Override
-	public abstract boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_);
+	public void issueBlockUpdate() {	
+		super.markDirty();
+	}	
 
+	@Override	
+	public void issueCoverUpdate(byte aSide) {
+		this.issueClientUpdate();
+	}
+	
 	@Override
-	public abstract int[] getAccessibleSlotsFromSide(int p_94128_1_);
+	public long getTimer() {
+		return this.mTickTimer;
+	}
+
+	
+	
+	
+	
+	
+
+	public long getOutputAmperage() {
+		return this.canAccessData() && this.mMetaTileEntity.isElectric() ? this.mMetaTileEntity.maxAmperesOut() : 0L;
+	}
+
+	public long getOutputVoltage() {
+		return this.canAccessData() && this.mMetaTileEntity.isElectric() && this.mMetaTileEntity.isEnetOutput()
+				? this.mMetaTileEntity.maxEUOutput()
+				: 0L;
+	}
+
+	public long getInputAmperage() {
+		return this.canAccessData() && this.mMetaTileEntity.isElectric() ? this.mMetaTileEntity.maxAmperesIn() : 0L;
+	}
+
+	public long getInputVoltage() {
+		return this.canAccessData() && this.mMetaTileEntity.isElectric()
+				? this.mMetaTileEntity.maxEUInput()
+				: 2147483647L;
+	}
 
 	@Override
-	public abstract boolean canInsertItem(int p_102007_1_, ItemStack p_102007_2_, int p_102007_3_);
+	public boolean decreaseStoredEnergyUnits(long aEnergy, boolean aIgnoreTooLessEnergy) {
+		return !this.canAccessData() ? false : (this.mHasEnoughEnergy = this.decreaseStoredEU(aEnergy, aIgnoreTooLessEnergy));
+	}
 
 	@Override
-	public abstract boolean canExtractItem(int p_102008_1_, ItemStack p_102008_2_, int p_102008_3_);
+	public boolean increaseStoredEnergyUnits(long aEnergy, boolean aIgnoreTooMuchEnergy) {
+		if (!this.canAccessData()) {
+			return false;
+		} else if (this.getStoredEU() >= this.getEUCapacity() && !aIgnoreTooMuchEnergy) {
+			return false;
+		} else {
+			this.setStoredEU(this.mMetaTileEntity.getEUVar() + aEnergy);
+			return true;
+		}
+	}
+	
+	@Override
+	public boolean inputEnergyFrom(byte aSide) {
+		return aSide == 6
+				? true
+				: (!this.isServerSide()
+						? this.isEnergyInputSide(aSide)
+						: aSide >= 0 && aSide < 6 && this.mActiveEUInputs[aSide] && !this.mReleaseEnergy);
+	}
+	
+	@Override
+	public boolean outputsEnergyTo(byte aSide) {
+		return aSide == 6
+				? true
+				: (!this.isServerSide()
+						? this.isEnergyOutputSide(aSide)
+						: aSide >= 0 && aSide < 6 && this.mActiveEUOutputs[aSide] || this.mReleaseEnergy);
+	}
+	
+	private boolean isEnergyInputSide(byte aSide) {
+		if (aSide >= 0 && aSide < 6) {
+			if (!this.getCoverBehaviorAtSide(aSide).letsEnergyIn(aSide, this.getCoverIDAtSide(aSide),
+					this.getCoverDataAtSide(aSide), this)) {
+				return false;
+			}
+
+			if (this.isInvalid() || this.mReleaseEnergy) {
+				return false;
+			}
+
+			if (this.canAccessData() && this.mMetaTileEntity.isElectric() && this.mMetaTileEntity.isEnetInput()) {
+				return this.mMetaTileEntity.isInputFacing(aSide);
+			}
+		}
+
+		return false;
+	}
+
+	private boolean isEnergyOutputSide(byte aSide) {
+		if (aSide >= 0 && aSide < 6) {
+			if (!this.getCoverBehaviorAtSide(aSide).letsEnergyOut(aSide, this.getCoverIDAtSide(aSide),
+					this.getCoverDataAtSide(aSide), this)) {
+				return false;
+			}
+
+			if (this.isInvalid() || this.mReleaseEnergy) {
+				return this.mReleaseEnergy;
+			}
+
+			if (this.canAccessData() && this.mMetaTileEntity.isElectric() && this.mMetaTileEntity.isEnetOutput()) {
+				return this.mMetaTileEntity.isOutputFacing(aSide);
+			}
+		}
+
+		return false;
+	}
+	
+	public boolean isOutputFacing(byte aSide) {
+		return false;
+	}
+
+	public boolean isInputFacing(byte aSide) {
+		return false;
+	}	
+	
+	private final TileEntity[] mBufferedTileEntities = new TileEntity[6];
+	public boolean ignoreUnloadedChunks = true;
+	public boolean isDead = false;
+
+	private final void clearNullMarkersFromTileEntityBuffer() {
+		for (int i = 0; i < this.mBufferedTileEntities.length; ++i) {
+			if (this.mBufferedTileEntities[i] == this) {
+				this.mBufferedTileEntities[i] = null;
+			}
+		}
+
+	}
+
+	protected final void clearTileEntityBuffer() {
+		for (int i = 0; i < this.mBufferedTileEntities.length; ++i) {
+			this.mBufferedTileEntities[i] = null;
+		}
+
+	}
+
+	public final World getWorld() {
+		return this.worldObj;
+	}
+
+	public final int getXCoord() {
+		return this.xCoord;
+	}
+
+	public final short getYCoord() {
+		return (short) this.yCoord;
+	}
+
+	public final int getZCoord() {
+		return this.zCoord;
+	}
+
+	public final int getOffsetX(byte aSide, int aMultiplier) {
+		return this.xCoord + ForgeDirection.getOrientation(aSide).offsetX * aMultiplier;
+	}
+
+	public final short getOffsetY(byte aSide, int aMultiplier) {
+		return (short) (this.yCoord + ForgeDirection.getOrientation(aSide).offsetY * aMultiplier);
+	}
+
+	public final int getOffsetZ(byte aSide, int aMultiplier) {
+		return this.zCoord + ForgeDirection.getOrientation(aSide).offsetZ * aMultiplier;
+	}
+
+	public final boolean openGUI(EntityPlayer aPlayer) {
+		return this.openGUI(aPlayer, 0);
+	}
+
+	public final boolean openGUI(EntityPlayer aPlayer, int aID) {
+		if (aPlayer == null) {
+			return false;
+		} else {
+			aPlayer.openGui(GT_Values.GT, aID, this.worldObj, this.xCoord, this.yCoord, this.zCoord);
+			return true;
+		}
+	}
+
+	public final int getRandomNumber(int aRange) {
+		return this.worldObj.rand.nextInt(aRange);
+	}
+
+	public final BiomeGenBase getBiome(int aX, int aZ) {
+		return this.worldObj.getBiomeGenForCoords(aX, aZ);
+	}
+
+	public final BiomeGenBase getBiome() {
+		return this.getBiome(this.xCoord, this.zCoord);
+	}
+
+	public final Block getBlockOffset(int aX, int aY, int aZ) {
+		return this.getBlock(this.xCoord + aX, this.yCoord + aY, this.zCoord + aZ);
+	}
+
+	public final Block getBlockAtSide(byte aSide) {
+		return this.getBlockAtSideAndDistance(aSide, 1);
+	}
+
+	public final Block getBlockAtSideAndDistance(byte aSide, int aDistance) {
+		return this.getBlock(this.getOffsetX(aSide, aDistance), this.getOffsetY(aSide, aDistance),
+				this.getOffsetZ(aSide, aDistance));
+	}
+
+	public final byte getMetaIDOffset(int aX, int aY, int aZ) {
+		return this.getMetaID(this.xCoord + aX, this.yCoord + aY, this.zCoord + aZ);
+	}
+
+	public final byte getMetaIDAtSide(byte aSide) {
+		return this.getMetaIDAtSideAndDistance(aSide, 1);
+	}
+
+	public final byte getMetaIDAtSideAndDistance(byte aSide, int aDistance) {
+		return this.getMetaID(this.getOffsetX(aSide, aDistance), this.getOffsetY(aSide, aDistance),
+				this.getOffsetZ(aSide, aDistance));
+	}
+
+	public final byte getLightLevelOffset(int aX, int aY, int aZ) {
+		return this.getLightLevel(this.xCoord + aX, this.yCoord + aY, this.zCoord + aZ);
+	}
+
+	public final byte getLightLevelAtSide(byte aSide) {
+		return this.getLightLevelAtSideAndDistance(aSide, 1);
+	}
+
+	public final byte getLightLevelAtSideAndDistance(byte aSide, int aDistance) {
+		return this.getLightLevel(this.getOffsetX(aSide, aDistance), this.getOffsetY(aSide, aDistance),
+				this.getOffsetZ(aSide, aDistance));
+	}
+
+	public final boolean getOpacityOffset(int aX, int aY, int aZ) {
+		return this.getOpacity(this.xCoord + aX, this.yCoord + aY, this.zCoord + aZ);
+	}
+
+	public final boolean getOpacityAtSide(byte aSide) {
+		return this.getOpacityAtSideAndDistance(aSide, 1);
+	}
+
+	public final boolean getOpacityAtSideAndDistance(byte aSide, int aDistance) {
+		return this.getOpacity(this.getOffsetX(aSide, aDistance), this.getOffsetY(aSide, aDistance),
+				this.getOffsetZ(aSide, aDistance));
+	}
+
+	public final boolean getSkyOffset(int aX, int aY, int aZ) {
+		return this.getSky(this.xCoord + aX, this.yCoord + aY, this.zCoord + aZ);
+	}
+
+	public final boolean getSkyAtSide(byte aSide) {
+		return this.getSkyAtSideAndDistance(aSide, 1);
+	}
+
+	public final boolean getSkyAtSideAndDistance(byte aSide, int aDistance) {
+		return this.getSky(this.getOffsetX(aSide, aDistance), this.getOffsetY(aSide, aDistance),
+				this.getOffsetZ(aSide, aDistance));
+	}
+
+	public final boolean getAirOffset(int aX, int aY, int aZ) {
+		return this.getAir(this.xCoord + aX, this.yCoord + aY, this.zCoord + aZ);
+	}
+
+	public final boolean getAirAtSide(byte aSide) {
+		return this.getAirAtSideAndDistance(aSide, 1);
+	}
+
+	public final boolean getAirAtSideAndDistance(byte aSide, int aDistance) {
+		return this.getAir(this.getOffsetX(aSide, aDistance), this.getOffsetY(aSide, aDistance),
+				this.getOffsetZ(aSide, aDistance));
+	}
+
+	public final TileEntity getTileEntityOffset(int aX, int aY, int aZ) {
+		return this.getTileEntity(this.xCoord + aX, this.yCoord + aY, this.zCoord + aZ);
+	}
+
+	public final TileEntity getTileEntityAtSideAndDistance(byte aSide, int aDistance) {
+		return aDistance == 1
+				? this.getTileEntityAtSide(aSide)
+				: this.getTileEntity(this.getOffsetX(aSide, aDistance), this.getOffsetY(aSide, aDistance),
+						this.getOffsetZ(aSide, aDistance));
+	}
+
+	public final IInventory getIInventory(int aX, int aY, int aZ) {
+		TileEntity tTileEntity = this.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof IInventory ? (IInventory) tTileEntity : null;
+	}
+
+	public final IInventory getIInventoryOffset(int aX, int aY, int aZ) {
+		TileEntity tTileEntity = this.getTileEntityOffset(aX, aY, aZ);
+		return tTileEntity instanceof IInventory ? (IInventory) tTileEntity : null;
+	}
+
+	public final IInventory getIInventoryAtSide(byte aSide) {
+		TileEntity tTileEntity = this.getTileEntityAtSide(aSide);
+		return tTileEntity instanceof IInventory ? (IInventory) tTileEntity : null;
+	}
+
+	public final IInventory getIInventoryAtSideAndDistance(byte aSide, int aDistance) {
+		TileEntity tTileEntity = this.getTileEntityAtSideAndDistance(aSide, aDistance);
+		return tTileEntity instanceof IInventory ? (IInventory) tTileEntity : null;
+	}
+
+	public final IFluidHandler getITankContainer(int aX, int aY, int aZ) {
+		TileEntity tTileEntity = this.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof IFluidHandler ? (IFluidHandler) tTileEntity : null;
+	}
+
+	public final IFluidHandler getITankContainerOffset(int aX, int aY, int aZ) {
+		TileEntity tTileEntity = this.getTileEntityOffset(aX, aY, aZ);
+		return tTileEntity instanceof IFluidHandler ? (IFluidHandler) tTileEntity : null;
+	}
+
+	public final IFluidHandler getITankContainerAtSide(byte aSide) {
+		TileEntity tTileEntity = this.getTileEntityAtSide(aSide);
+		return tTileEntity instanceof IFluidHandler ? (IFluidHandler) tTileEntity : null;
+	}
+
+	public final IFluidHandler getITankContainerAtSideAndDistance(byte aSide, int aDistance) {
+		TileEntity tTileEntity = this.getTileEntityAtSideAndDistance(aSide, aDistance);
+		return tTileEntity instanceof IFluidHandler ? (IFluidHandler) tTileEntity : null;
+	}
+
+	public final IGregTechTileEntity getIGregTechTileEntity(int aX, int aY, int aZ) {
+		TileEntity tTileEntity = this.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof IGregTechTileEntity ? (IGregTechTileEntity) tTileEntity : null;
+	}
+
+	public final IGregTechTileEntity getIGregTechTileEntityOffset(int aX, int aY, int aZ) {
+		TileEntity tTileEntity = this.getTileEntityOffset(aX, aY, aZ);
+		return tTileEntity instanceof IGregTechTileEntity ? (IGregTechTileEntity) tTileEntity : null;
+	}
+
+	public final IGregTechTileEntity getIGregTechTileEntityAtSide(byte aSide) {
+		TileEntity tTileEntity = this.getTileEntityAtSide(aSide);
+		return tTileEntity instanceof IGregTechTileEntity ? (IGregTechTileEntity) tTileEntity : null;
+	}
+
+	public final IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(byte aSide, int aDistance) {
+		TileEntity tTileEntity = this.getTileEntityAtSideAndDistance(aSide, aDistance);
+		return tTileEntity instanceof IGregTechTileEntity ? (IGregTechTileEntity) tTileEntity : null;
+	}
+
+	public final Block getBlock(int aX, int aY, int aZ) {
+		return this.ignoreUnloadedChunks && this.crossedChunkBorder(aX, aZ) && !this.worldObj.blockExists(aX, aY, aZ)
+				? Blocks.air
+				: this.worldObj.getBlock(aX, aY, aZ);
+	}
+
+	public final byte getMetaID(int aX, int aY, int aZ) {
+		return this.ignoreUnloadedChunks && this.crossedChunkBorder(aX, aZ) && !this.worldObj.blockExists(aX, aY, aZ)
+				? 0
+				: (byte) this.worldObj.getBlockMetadata(aX, aY, aZ);
+	}
+
+	public final byte getLightLevel(int aX, int aY, int aZ) {
+		return this.ignoreUnloadedChunks && this.crossedChunkBorder(aX, aZ) && !this.worldObj.blockExists(aX, aY, aZ)
+				? 0
+				: (byte) ((int) (this.worldObj.getLightBrightness(aX, aY, aZ) * 15.0F));
+	}
+
+	public final boolean getSky(int aX, int aY, int aZ) {
+		return this.ignoreUnloadedChunks && this.crossedChunkBorder(aX, aZ) && !this.worldObj.blockExists(aX, aY, aZ)
+				? true
+				: this.worldObj.canBlockSeeTheSky(aX, aY, aZ);
+	}
+
+	public final boolean getOpacity(int aX, int aY, int aZ) {
+		return this.ignoreUnloadedChunks && this.crossedChunkBorder(aX, aZ) && !this.worldObj.blockExists(aX, aY, aZ)
+				? false
+				: GT_Utility.isOpaqueBlock(this.worldObj, aX, aY, aZ);
+	}
+
+	public final boolean getAir(int aX, int aY, int aZ) {
+		return this.ignoreUnloadedChunks && this.crossedChunkBorder(aX, aZ) && !this.worldObj.blockExists(aX, aY, aZ)
+				? true
+				: GT_Utility.isBlockAir(this.worldObj, aX, aY, aZ);
+	}
+
+	public final TileEntity getTileEntity(int aX, int aY, int aZ) {
+		return this.ignoreUnloadedChunks && this.crossedChunkBorder(aX, aZ) && !this.worldObj.blockExists(aX, aY, aZ)
+				? null
+				: this.worldObj.getTileEntity(aX, aY, aZ);
+	}
+
+	public final TileEntity getTileEntityAtSide(byte aSide) {
+		if (aSide >= 0 && aSide < 6 && this.mBufferedTileEntities[aSide] != this) {
+			int tX = this.getOffsetX(aSide, 1);
+			short tY = this.getOffsetY(aSide, 1);
+			int tZ = this.getOffsetZ(aSide, 1);
+			if (this.crossedChunkBorder(tX, tZ)) {
+				this.mBufferedTileEntities[aSide] = null;
+				if (this.ignoreUnloadedChunks && !this.worldObj.blockExists(tX, tY, tZ)) {
+					return null;
+				}
+			}
+
+			if (this.mBufferedTileEntities[aSide] == null) {
+				this.mBufferedTileEntities[aSide] = this.worldObj.getTileEntity(tX, tY, tZ);
+				if (this.mBufferedTileEntities[aSide] == null) {
+					this.mBufferedTileEntities[aSide] = this;
+					return null;
+				} else {
+					return this.mBufferedTileEntities[aSide];
+				}
+			} else if (this.mBufferedTileEntities[aSide].isInvalid()) {
+				this.mBufferedTileEntities[aSide] = null;
+				return this.getTileEntityAtSide(aSide);
+			} else {
+				return this.mBufferedTileEntities[aSide].xCoord == tX && this.mBufferedTileEntities[aSide].yCoord == tY
+						&& this.mBufferedTileEntities[aSide].zCoord == tZ ? this.mBufferedTileEntities[aSide] : null;
+			}
+		} else {
+			return null;
+		}
+	}
+
+	public boolean isDead() {
+		return this.isDead || this.isInvalidTileEntity();
+	}
+
+	public void validate() {
+		this.clearNullMarkersFromTileEntityBuffer();
+		super.validate();
+	}
+
+	public void invalidate() {
+		this.clearNullMarkersFromTileEntityBuffer();
+		super.invalidate();
+	}
+
+	public void onChunkUnload() {
+		this.clearNullMarkersFromTileEntityBuffer();
+		super.onChunkUnload();
+		this.isDead = true;
+	}
+
+	public final void onAdjacentBlockChange(int aX, int aY, int aZ) {
+		this.clearNullMarkersFromTileEntityBuffer();
+	}
+
+	public final void sendBlockEvent(byte aID, byte aValue) {
+		GT_Values.NW.sendPacketToAllPlayersInRange(this.worldObj,
+				new GT_Packet_Block_Event(this.xCoord, (short) this.yCoord, this.zCoord, aID, aValue), this.xCoord,
+				this.zCoord);
+	}
+
+	private boolean crossedChunkBorder(int aX, int aZ) {
+		return aX >> 4 != this.xCoord >> 4 || aZ >> 4 != this.zCoord >> 4;
+	}
+
+	public final void setOnFire() {
+		GT_Utility.setCoordsOnFire(this.worldObj, this.xCoord, this.yCoord, this.zCoord, false);
+	}
+
+	public final void setToFire() {
+		this.worldObj.setBlock(this.xCoord, this.yCoord, this.zCoord, Blocks.fire);
+	}
+
+	public String trans(String aKey, String aEnglish) {
+		return GT_LanguageManager.addStringLocalization("Interaction_DESCRIPTION_Index_" + aKey, aEnglish, false);
+	}
+
+    @Override
+    public byte getInternalInputRedstoneSignal(byte aSide) {
+        return (byte) (getCoverBehaviorAtSide(aSide).getRedstoneInput(aSide, getInputRedstoneSignal(aSide), getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this) & 15);
+    }
+
+    @Override
+    public byte getInputRedstoneSignal(byte aSide) {
+        return (byte) (worldObj.getIndirectPowerLevelTo(getOffsetX(aSide, 1), getOffsetY(aSide, 1), getOffsetZ(aSide, 1), aSide) & 15);
+    }
+
+    @Override
+    public byte getOutputRedstoneSignal(byte aSide) {
+        return getCoverBehaviorAtSide(aSide).manipulatesSidedRedstoneOutput(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this) ? mSidedRedstone[aSide] : getGeneralRS(aSide);
+    }
+    
+	public boolean allowGeneralRedstoneOutput() {
+		return false;
+	}
+    
+    public byte getGeneralRS(byte aSide){
+    	return allowGeneralRedstoneOutput() ? mSidedRedstone[aSide] : 0;
+    }
+
+    @Override
+    public void setInternalOutputRedstoneSignal(byte aSide, byte aStrength) {
+        if (!getCoverBehaviorAtSide(aSide).manipulatesSidedRedstoneOutput(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this))
+            setOutputRedstoneSignal(aSide, aStrength);
+    }
+
+    @Override
+    public void setOutputRedstoneSignal(byte aSide, byte aStrength) {
+        aStrength = (byte) Math.min(Math.max(0, aStrength), 15);
+        if (aSide >= 0 && aSide < 6 && mSidedRedstone[aSide] != aStrength) {
+            mSidedRedstone[aSide] = aStrength;
+            issueBlockUpdate();
+        }
+    }
+
+    @Override
+    public boolean hasInventoryBeenModified() {
+        return mInventoryChanged;
+    }
+
+    @Override
+    public void setGenericRedstoneOutput(boolean aOnOff) {
+        mRedstone = aOnOff;
+    }
+
+    @Override
+    public GT_CoverBehavior getCoverBehaviorAtSide(byte aSide) {
+        return aSide >= 0 && aSide < mCoverBehaviors.length ? mCoverBehaviors[aSide] : GregTech_API.sNoBehavior;
+    }
+
+    @Override
+    public void setCoverIDAtSide(byte aSide, int aID) {
+        if (aSide >= 0 && aSide < 6) {
+            mCoverSides[aSide] = aID;
+            mCoverData[aSide] = 0;
+            mCoverBehaviors[aSide] = GregTech_API.getCoverBehavior(aID);
+            issueCoverUpdate(aSide);
+            issueBlockUpdate();
+        }
+    }
+
+    @Override
+    public void setCoverItemAtSide(byte aSide, ItemStack aCover) {
+        GregTech_API.getCoverBehavior(aCover).placeCover(aSide, aCover, this);
+    }
+
+    @Override
+    public int getCoverIDAtSide(byte aSide) {
+        if (aSide >= 0 && aSide < 6) return mCoverSides[aSide];
+        return 0;
+    }
+
+    @Override
+    public ItemStack getCoverItemAtSide(byte aSide) {
+        return GT_Utility.intToStack(getCoverIDAtSide(aSide));
+    }
+
+    @Override
+    public boolean canPlaceCoverIDAtSide(byte aSide, int aID) {
+        return getCoverIDAtSide(aSide) == 0;
+    }
+
+    @Override
+    public boolean canPlaceCoverItemAtSide(byte aSide, ItemStack aCover) {
+        return getCoverIDAtSide(aSide) == 0;
+    }
+
+    @Override
+    public void setCoverDataAtSide(byte aSide, int aData) {
+        if (aSide >= 0 && aSide < 6) mCoverData[aSide] = aData;
+    }
+
+    @Override
+    public int getCoverDataAtSide(byte aSide) {
+        if (aSide >= 0 && aSide < 6) return mCoverData[aSide];
+        return 0;
+    }
+
+    public byte getLightValue() {
+        return mLightValue;
+    }
+
+    @Override
+    public void setLightValue(byte aLightValue) {
+        mLightValue = (byte) (aLightValue & 15);
+    }
+
+    @Override
+    public long getAverageElectricInput() {
+        int rEU = 0;
+        for (int i = 0; i < mAverageEUInput.length; i++) {
+            if (i != mAverageEUInputIndex)
+                rEU += mAverageEUInput[i];
+        }
+        return rEU / (mAverageEUInput.length - 1);
+    }
+
+    @Override
+    public long getAverageElectricOutput() {
+        int rEU = 0;
+        for (int i = 0; i < mAverageEUOutput.length; i++) {
+            if (i != mAverageEUOutputIndex)
+                rEU += mAverageEUOutput[i];
+        }
+        return rEU / (mAverageEUOutput.length - 1);
+    }
+
+	public boolean hasSidedRedstoneOutputBehavior() {
+		return false;
+	}
+
+    @Override
+    public boolean dropCover(byte aSide, byte aDroppedSide, boolean aForced) {
+        if (getCoverBehaviorAtSide(aSide).onCoverRemoval(aSide, getCoverIDAtSide(aSide), mCoverData[aSide], this, aForced) || aForced) {
+            ItemStack tStack = getCoverBehaviorAtSide(aSide).getDrop(aSide, getCoverIDAtSide(aSide), getCoverDataAtSide(aSide), this);
+            if (tStack != null) {
+                tStack.setTagCompound(null);
+                EntityItem tEntity = new EntityItem(worldObj, getOffsetX(aDroppedSide, 1) + 0.5, getOffsetY(aDroppedSide, 1) + 0.5, getOffsetZ(aDroppedSide, 1) + 0.5, tStack);
+                tEntity.motionX = 0;
+                tEntity.motionY = 0;
+                tEntity.motionZ = 0;
+                worldObj.spawnEntityInWorld(tEntity);
+            }
+            setCoverIDAtSide(aSide, 0);
+            if (mMetaTileEntity.hasSidedRedstoneOutputBehavior()) {
+                setOutputRedstoneSignal(aSide, (byte) 0);
+            } else {
+                setOutputRedstoneSignal(aSide, (byte) 15);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public String getOwnerName() {
+        if (GT_Utility.isStringInvalid(mOwnerName)) return "Player";
+        return mOwnerName;
+    }
+
+    public String setOwnerName(String aName) {
+        if (GT_Utility.isStringInvalid(aName)) return mOwnerName = "Player";
+        return mOwnerName = aName;
+    }
+
+    @Override
+    public byte getComparatorValue(byte aSide) {
+        return canAccessData() ? mMetaTileEntity.getComparatorValue(aSide) : 0;
+    }
+
+    @Override
+    public byte getStrongOutputRedstoneSignal(byte aSide) {
+        return aSide >= 0 && aSide < 6 && (mStrongRedstone & (1 << aSide)) != 0 ? (byte) (mSidedRedstone[aSide] & 15) : 0;
+    }
+
+    @Override
+    public void setStrongOutputRedstoneSignal(byte aSide, byte aStrength) {
+        mStrongRedstone |= (1 << aSide);
+        setOutputRedstoneSignal(aSide, aStrength);
+    }
+
+    @Override
+    public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) {
+        if (!canAccessData() || !mMetaTileEntity.isElectric() || !inputEnergyFrom(aSide) || aAmperage <= 0 || aVoltage <= 0 || getStoredEU() >= getEUCapacity() || mMetaTileEntity.maxAmperesIn() <= mAcceptedAmperes)
+            return 0;
+        if (aVoltage > getInputVoltage()) {
+            doExplosion(aVoltage);
+            return 0;
+        }
+        if (increaseStoredEnergyUnits(aVoltage * (aAmperage = Math.min(aAmperage, Math.min(mMetaTileEntity.maxAmperesIn() - mAcceptedAmperes, 1 + ((getEUCapacity() - getStoredEU()) / aVoltage)))), true)) {
+            mAverageEUInput[mAverageEUInputIndex] += aVoltage * aAmperage;
+            mAcceptedAmperes += aAmperage;
+            return aAmperage;
+        }
+        return 0;
+    }
+
+    @Override
+    public boolean drainEnergyUnits(byte aSide, long aVoltage, long aAmperage) {
+        if (!canAccessData() || !mMetaTileEntity.isElectric() || !outputsEnergyTo(aSide) || getStoredEU() - (aVoltage * aAmperage) < mMetaTileEntity.getMinimumStoredEU())
+            return false;
+        if (decreaseStoredEU(aVoltage * aAmperage, false)) {
+            mAverageEUOutput[mAverageEUOutputIndex] += aVoltage * aAmperage;
+            return true;
+        }
+        return false;
+    }
+
+    
+    public double getOutputEnergyUnitsPerTick() {
+        return oOutput;
+    }
+
+    
+    public boolean isTeleporterCompatible(ForgeDirection aSide) {
+        return false;
+    }
+
+    
+    public double demandedEnergyUnits() {
+        if (mReleaseEnergy || !canAccessData() || !mMetaTileEntity.isEnetInput()) return 0;
+        return getEUCapacity() - getStoredEU();
+    }
+
+    
+    public double injectEnergyUnits(ForgeDirection aDirection, double aAmount) {
+        return injectEnergyUnits((byte) aDirection.ordinal(), (int) aAmount, 1) > 0 ? 0 : aAmount;
+    }
+
+    
+    public boolean acceptsEnergyFrom(TileEntity aEmitter, ForgeDirection aDirection) {
+        return inputEnergyFrom((byte) aDirection.ordinal());
+    }
+
+    
+    public boolean emitsEnergyTo(TileEntity aReceiver, ForgeDirection aDirection) {
+        return outputsEnergyTo((byte) aDirection.ordinal());
+    }
+
+    
+    public double getOfferedEnergy() {
+        return (canAccessData() && getStoredEU() - mMetaTileEntity.getMinimumStoredEU() >= oOutput) ? Math.max(0, oOutput) : 0;
+    }
+
+    
+    public void drawEnergy(double amount) {
+        mAverageEUOutput[mAverageEUOutputIndex] += amount;
+        decreaseStoredEU((int) amount, true);
+    }
+
+    
+    public int injectEnergy(ForgeDirection aForgeDirection, int aAmount) {
+        return injectEnergyUnits((byte) aForgeDirection.ordinal(), aAmount, 1) > 0 ? 0 : aAmount;
+    }
+
+    
+    public int addEnergy(int aEnergy) {
+        if (!canAccessData()) return 0;
+        if (aEnergy > 0)
+            increaseStoredEnergyUnits(aEnergy, true);
+        else
+            decreaseStoredEU(-aEnergy, true);
+        return (int) Math.min(Integer.MAX_VALUE, mMetaTileEntity.getEUVar());
+    }
+
+    
+    public boolean isAddedToEnergyNet() {
+        return false;
+    }
+
+    
+    public int demandsEnergy() {
+        if (mReleaseEnergy || !canAccessData() || !mMetaTileEntity.isEnetInput()) return 0;
+        return getCapacity() - getStored();
+    }
+
+    
+    public int getCapacity() {
+        return (int) Math.min(Integer.MAX_VALUE, getEUCapacity());
+    }
+
+    
+    public int getStored() {
+        return (int) Math.min(Integer.MAX_VALUE, Math.min(getStoredEU(), getCapacity()));
+    }
+
+    
+    public void setStored(int aEU) {
+        if (canAccessData()) setStoredEU(aEU);
+    }
+
+    
+    public int getMaxSafeInput() {
+        return (int) Math.min(Integer.MAX_VALUE, getInputVoltage());
+    }
+
+    
+    public int getMaxEnergyOutput() {
+        if (mReleaseEnergy) return Integer.MAX_VALUE;
+        return getOutput();
+    }
+
+    
+    public int getOutput() {
+        return (int) Math.min(Integer.MAX_VALUE, oOutput);
+    }
+
+    
+    public int injectEnergy(Direction aDirection, int aAmount) {
+        return injectEnergyUnits((byte) aDirection.toSideValue(), aAmount, 1) > 0 ? 0 : aAmount;
+    }
+
+    public boolean acceptsEnergyFrom(TileEntity aReceiver, Direction aDirection) {
+        return inputEnergyFrom((byte) aDirection.toSideValue());
+    }
+
+    
+    public boolean emitsEnergyTo(TileEntity aReceiver, Direction aDirection) {
+        return outputsEnergyTo((byte) aDirection.toSideValue());
+    }
+
+    @Override
+    public boolean isInvalidTileEntity() {
+        return isInvalid();
+    }
+
+    @Override
+    public boolean addStackToSlot(int aIndex, ItemStack aStack) {
+        if (GT_Utility.isStackInvalid(aStack)) return true;
+        if (aIndex < 0 || aIndex >= getSizeInventory()) return false;
+        ItemStack tStack = getStackInSlot(aIndex);
+        if (GT_Utility.isStackInvalid(tStack)) {
+            setInventorySlotContents(aIndex, aStack);
+            return true;
+        }
+        aStack = GT_OreDictUnificator.get(aStack);
+        if (GT_Utility.areStacksEqual(tStack, aStack) && tStack.stackSize + aStack.stackSize <= Math.min(aStack.getMaxStackSize(), getInventoryStackLimit())) {
+            tStack.stackSize += aStack.stackSize;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean addStackToSlot(int aIndex, ItemStack aStack, int aAmount) {
+        return addStackToSlot(aIndex, GT_Utility.copyAmount(aAmount, aStack));
+    }
+
+    @Override
+    public void markDirty() {
+        super.markDirty();
+        mInventoryChanged = true;
+    }
+
+    
+    
+    /**
+     * To Do
+     */
+    
+	public boolean isElectric() {
+		return true;
+	}
+
+	public boolean isEnetOutput() {
+		return false;
+	}
+
+	public boolean isEnetInput() {
+		return false;
+	}
+
+	public long maxEUStore() {
+		return 0L;
+	}
+
+	public long maxEUInput() {
+		return 0L;
+	}
+
+	public long maxEUOutput() {
+		return 0L;
+	}
+
+	public long maxAmperesOut() {
+		return 1L;
+	}
+
+	public long maxAmperesIn() {
+		return 1L;
+	}
+    
+	public void doEnergyExplosion() {
+		if (this.getUniversalEnergyCapacity() > 0L
+				&& this.getUniversalEnergyStored() >= this.getUniversalEnergyCapacity() / 5L) {
+			this.doExplosion(this.oOutput * (long) (this.getUniversalEnergyStored() >= this.getUniversalEnergyCapacity()
+					? 4
+					: (this.getUniversalEnergyStored() >= this.getUniversalEnergyCapacity() / 2L ? 2 : 1)));
+			GT_Mod arg9999 = GT_Mod.instance;
+			GT_Mod.achievements.issueAchievement(this.getWorldObj().getPlayerEntityByName(this.mOwnerName),
+					"electricproblems");
+		}
+
+	}
+
+	public void doExplosion(long aAmount) {
+		if (this.canAccessData()) {
+			if (GregTech_API.sMachineWireFire && this.mMetaTileEntity.isElectric()) {
+				try {
+					this.mReleaseEnergy = true;
+					Util.emitEnergyToNetwork(GT_Values.V[5], Math.max(1L, this.getStoredEU() / GT_Values.V[5]), this);
+				} catch (Exception arg4) {
+				}
+			}
+			this.mReleaseEnergy = false;
+			this.onExplosion();
+			PollutionUtils.addPollution(this, 100000);
+			this.mMetaTileEntity.doExplosion(aAmount);
+		}
+
+	}
+
+	public void onExplosion() {
+		
+	}
+
+	@Override
+	public String[] getDescription() {
+		return this.canAccessData() ? this.mMetaTileEntity.getDescription() : new String[0];
+	}
+
+	@Override
+	public boolean isGivingInformation() {
+		return true;
+	}
+
+	@Override
+	public String[] getInfoData() {
+		return null;
+	}
+	
+	public long getEUVar() {
+		return this.mStoredEnergy;
+	}
+
+	public void setEUVar(long aEnergy) {
+		this.mStoredEnergy = aEnergy;
+	}
+	
+	public long getStoredEU() {
+		return this.canAccessData() ? Math.min(this.mMetaTileEntity.getEUVar(), this.getEUCapacity()) : 0L;
+	}
+
+	public long getEUCapacity() {
+		return this.canAccessData() ? this.mMetaTileEntity.maxEUStore() : 0L;
+	}
+	
+	public long getMinimumStoredEU() {
+		return 512L;
+	}
+	
+	public boolean setStoredEU(long aEnergy) {
+		if (!this.canAccessData()) {
+			return false;
+		} else {
+			if (aEnergy < 0L) {
+				aEnergy = 0L;
+			}
+
+			this.mMetaTileEntity.setEUVar(aEnergy);
+			return true;
+		}
+	}
+	
+	public boolean decreaseStoredEU(long aEnergy, boolean aIgnoreTooLessEnergy) {
+		if (!this.canAccessData()) {
+			return false;
+		} else if (this.mMetaTileEntity.getEUVar() - aEnergy < 0L && !aIgnoreTooLessEnergy) {
+			return false;
+		} else {
+			this.setStoredEU(this.mMetaTileEntity.getEUVar() - aEnergy);
+			if (this.mMetaTileEntity.getEUVar() < 0L) {
+				this.setStoredEU(0L);
+				return false;
+			} else {
+				return true;
+			}
+		}
+	}
+    
+
+
 
 }
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/tileentities/base/TilePoweredGT.java b/src/Java/gtPlusPlus/core/tileentities/base/TilePoweredGT.java
index e607dac40d..fb599b0bae 100644
--- a/src/Java/gtPlusPlus/core/tileentities/base/TilePoweredGT.java
+++ b/src/Java/gtPlusPlus/core/tileentities/base/TilePoweredGT.java
@@ -1,4 +1,4 @@
-package gtPlusPlus.core.tileentities.base;
+/*package gtPlusPlus.core.tileentities.base;
 
 import net.minecraft.block.Block;
 import net.minecraft.entity.Entity;
@@ -804,33 +804,33 @@ public abstract class TilePoweredGT extends TileEntityBase implements IGregtechP
 	
 	
 	@Override
-	public boolean onPreTick() {
+	public boolean onPreTick(long aTick) {
 		return onPreTick(this, this.mTickTimer);
 	}
 
 	@Override
-	public boolean onTick() {
+	public boolean onTick(long aTick) {
 		return onTick(this, this.mTickTimer);
 	}
 
 	@Override
-	public boolean onPostTick() {
+	public boolean onPostTick(long aTick) {
 		return onPostTick(this, this.mTickTimer);
 	}
 
 	@Override
 	public boolean onPreTick(TilePoweredGT tilePoweredGT, long mTickTimer2) {
-		return super.onPreTick();
+		return super.onPreTick(mTickTimer2);
 	}
 
 	@Override
 	public boolean onTick(TilePoweredGT iGregTechTileEntity, long mTickTimer2) {
-		return super.onTick();
+		return super.onTick(mTickTimer2);
 	}
 
 	@Override
 	public boolean onPostTick(TilePoweredGT iGregTechTileEntity, long mTickTimer2) {
-		return super.onPostTick();
+		return super.onPostTick(mTickTimer2);
 	}
 
 	@Override
@@ -861,7 +861,7 @@ public abstract class TilePoweredGT extends TileEntityBase implements IGregtechP
 		int tCode = 0;
 		final boolean aSideServer = this.isServerSide();
 		final boolean aSideClient = this.isClientSide();
-		/*try {
+		try {
 			for (tCode = 0; this.hasValidMetaTileEntity() && tCode >= 0; tCode = -1) {
 				Label_1743 : {
 					switch (tCode) {
@@ -1139,7 +1139,7 @@ public abstract class TilePoweredGT extends TileEntityBase implements IGregtechP
 		final boolean mWorkUpdate = false;
 		this.mRunningThroughTick = mWorkUpdate;
 		this.mInventoryChanged = mWorkUpdate;
-		this.mWorkUpdate = mWorkUpdate;*/
+		this.mWorkUpdate = mWorkUpdate;
 	}
 
 	private void onFirstTick(TilePoweredGT tilePoweredGT) {
@@ -1165,3 +1165,4 @@ public abstract class TilePoweredGT extends TileEntityBase implements IGregtechP
 	}
 	
 }
+*/
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/tileentities/general/TileEntityXpConverter.java b/src/Java/gtPlusPlus/core/tileentities/general/TileEntityXpConverter.java
index 403d331151..2816596515 100644
--- a/src/Java/gtPlusPlus/core/tileentities/general/TileEntityXpConverter.java
+++ b/src/Java/gtPlusPlus/core/tileentities/general/TileEntityXpConverter.java
@@ -7,24 +7,21 @@ import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.network.NetworkManager;
 import net.minecraft.network.Packet;
 import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
-import net.minecraft.tileentity.TileEntity;
-
-import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.minecraft.BTF_FluidTank;
+import gtPlusPlus.core.tileentities.base.TileBasicTank;
 import gtPlusPlus.core.util.minecraft.EnchantingUtils;
 import gtPlusPlus.core.util.minecraft.PlayerUtils;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.*;
 
-public class TileEntityXpConverter extends TileEntity implements IFluidHandler {
+public class TileEntityXpConverter extends TileBasicTank {
 
-	public FluidTank tankEssence = new FluidTank((int) (64000*EnchantingUtils.RATIO_MOB_ESSENCE_TO_LIQUID_XP));
-	public FluidTank tankLiquidXp = new FluidTank(64000);
-	private boolean needsUpdate = false;
+	public BTF_FluidTank tankEssence = new BTF_FluidTank((int) (64000*EnchantingUtils.RATIO_MOB_ESSENCE_TO_LIQUID_XP));
+	public BTF_FluidTank tankLiquidXp = new BTF_FluidTank(64000);
 	private boolean mConvertToEssence = true;
-	private int updateTimer = 0;
-	private long mTickTime = 0;
 
 	public TileEntityXpConverter() {
+		super (4, 32000);
 	}
 
 	private void changeMode(){
@@ -36,278 +33,266 @@ public class TileEntityXpConverter extends TileEntity implements IFluidHandler {
 			this.mConvertToEssence = true;
 			return;
 		}
-	}
-
-	private boolean isServerSide(){
-		if (this.getWorldObj().isRemote){
-			return false;
-		}
-		else {
-			return true;
-		}
-	}
+	}	
 
-	@Override
-	public int fill(final ForgeDirection from, final FluidStack resource, final boolean doFill) {
-		this.needsUpdate = true;
-		Logger.WARNING("Ticking. | mConvertToEssence: "+this.mConvertToEssence);
+	public float getAdjustedVolume() {		
 		if (this.mConvertToEssence){
-			if (resource.isFluidEqual(EnchantingUtils.getLiquidXP(1))){
-				Logger.WARNING("fill(tankLiquidXp)");
-				return this.tankLiquidXp.fill(resource, doFill);
-			}
-			else {
-				Logger.WARNING("Looking for Liquid Xp, Instead found "+resource.getLocalizedName()+".");
+			if ((this.tankLiquidXp.getFluid() != null) && (this.tankLiquidXp.getFluidAmount() >= 100) && (this.tankEssence.getFluidAmount() <= (this.tankEssence.getCapacity()-(100*EnchantingUtils.RATIO_MOB_ESSENCE_TO_LIQUID_XP)))){
+				final FluidStack bigStorage = EnchantingUtils.getEssenceFromLiquidXp(100);
+				this.tankEssence.fill(bigStorage, true);
+				this.tankLiquidXp.drain(100, true);
+				return (this.tankEssence.getCapacity()-this.tankEssence.getFluidAmount());
 			}
 		}
 		else {
-			if (resource.isFluidEqual(EnchantingUtils.getMobEssence(1))){
-				Logger.WARNING("fill(tankEssence)");
-				return this.tankEssence.fill(resource, doFill);
-			}
-			else {
-				Logger.WARNING("Looking for Essence, Instead found "+resource.getLocalizedName()+".");
+			final double rm = EnchantingUtils.RATIO_MOB_ESSENCE_TO_LIQUID_XP;
+			if ((this.tankEssence.getFluid() != null) && (this.tankEssence.getFluidAmount() >= rm) && (this.tankLiquidXp.getFluidAmount() <= (this.tankLiquidXp.getCapacity()-rm))){
+				final FluidStack bigStorage = EnchantingUtils.getLiquidXP(1);
+				this.tankLiquidXp.fill(bigStorage, true);
+				this.tankEssence.drain((int) rm, true);
+				return (this.tankLiquidXp.getCapacity()-this.tankLiquidXp.getFluidAmount());
 			}
-		}
-		Logger.WARNING("fill(0)");
-		return 0;
+		}		
+		return 0f;
 	}
 
 	@Override
-	public FluidStack drain(final ForgeDirection from, final FluidStack resource, final boolean doDrain) {
-		this.needsUpdate = true;
-		if (this.mConvertToEssence){
-			if (resource.isFluidEqual(EnchantingUtils.getMobEssence(1))){
-				Logger.WARNING("drain(mConvertToEssence)");
-				return this.tankEssence.drain(resource.amount, doDrain);
-			}
-		}
-		else {
-			if (resource.isFluidEqual(EnchantingUtils.getLiquidXP(1))){
-				Logger.WARNING("drain(tankLiquidXp)");
-				return this.tankLiquidXp.drain(resource.amount, doDrain);
-			}
-		}
-		Logger.WARNING("drain(null)");
-		return null;
+	public void readFromNBT(final NBTTagCompound tag) {
+		this.tankEssence.readFromNBT(tag);
+		this.tankLiquidXp.readFromNBT(tag);
+		this.mConvertToEssence = tag.getBoolean("mConvertToEssence");
+		super.readFromNBT(tag);
 	}
 
 	@Override
-	public FluidStack drain(final ForgeDirection from, final int maxDrain, final boolean doDrain) {
-		this.needsUpdate = true;
-		Logger.WARNING("drain(Ex)");
-		final FluidStack fluid_Essence = this.tankEssence.getFluid();
-		final FluidStack fluid_Xp = this.tankLiquidXp.getFluid();
-		if ((fluid_Essence == null) && (fluid_Xp == null)) {
-			return null;
-		}
+	public void writeToNBT(final NBTTagCompound tag) {
+		this.tankEssence.writeToNBT(tag);
+		this.tankLiquidXp.writeToNBT(tag);
+		tag.setBoolean("mConvertToEssence", this.mConvertToEssence);
+		super.writeToNBT(tag);
+	}
 
-		FluidStack fluid;
-		FluidTank tank;
+	@Override
+	public Packet getDescriptionPacket() {
+		final NBTTagCompound tag = new NBTTagCompound();
+		this.writeToNBT(tag);
+		return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, this.blockMetadata, tag);
+	}
 
-		if (this.mConvertToEssence){
-			fluid = fluid_Essence;
-			tank = this.tankEssence;
-		}
-		else {
-			fluid = fluid_Xp;
-			tank = this.tankLiquidXp;
-		}
+	@Override
+	public void onDataPacket(final NetworkManager net, final S35PacketUpdateTileEntity pkt) {
+		final NBTTagCompound tag = pkt.func_148857_g();
+		this.readFromNBT(tag);
+	}
 
-		int drained = maxDrain;
-		if (fluid.amount < drained) {
-			drained = fluid.amount;
+	public void onScrewdriverRightClick(final byte aSide, final EntityPlayer aPlayer, final float aX, final float aY, final float aZ) {
+		if (this.isServerSide()){
+			if (this.mConvertToEssence){
+				PlayerUtils.messagePlayer(aPlayer, "Converting from Mob Essence to Liquid Xp.");
+			}
+			else {
+				PlayerUtils.messagePlayer(aPlayer, "Converting from Liquid Xp to Mob Essence.");
+			}
+			//Mode Change
+			this.changeMode();
 		}
+	}
 
-		final FluidStack stack = new FluidStack(fluid, drained);
-		if (doDrain) {
-			fluid.amount -= drained;
-			if (fluid.amount <= 0) {
-				fluid = null;
-			}
+	public void onRightClick(final byte aSide, final EntityPlayer aPlayer, final int aX, final int aY, final int aZ) {		
+		if ((Keyboard.isKeyDown(42)) || (Keyboard.isKeyDown(54))) {
+			String mInput;
+			String mOutput;
 
-			if (this != null) {
-				FluidEvent.fireEvent(new FluidEvent.FluidDrainingEvent(fluid, this.getWorldObj(), this.xCoord,
-						this.yCoord, this.zCoord, tank, 0));
+			if (this.mConvertToEssence){
+				mInput = "Liquid Xp";
+				mOutput = "Mob Essence";
+			}
+			else {
+				mInput = "Mob Essence";
+				mOutput = "Liquid Xp";
 			}
-		}
 
+			PlayerUtils.messagePlayer(aPlayer, "Input: "+mInput+".");
+			PlayerUtils.messagePlayer(aPlayer, "Output: "+mOutput+".");
+		}
+	}
 
-		if (this.mConvertToEssence){
-			this.tankEssence = tank;
+	@Override
+	public boolean onPreTick(long aTick) {
+		boolean aSuperResult = super.onPreTick(aTick);		
+		long aTankSpaceLeft = 0;
+		double aAmount = 0;
+		int aRuns = 0;
+		if (this.mConvertToEssence) {
+			aTankSpaceLeft = (this.tankEssence.getCapacity()-this.tankEssence.getFluidAmount());
+			aAmount = EnchantingUtils.getEssenceFromLiquidXp(100).amount;	
 		}
 		else {
-			this.tankLiquidXp = tank;
+			aTankSpaceLeft = (this.tankLiquidXp.getCapacity()-this.tankLiquidXp.getFluidAmount());
+			aAmount = EnchantingUtils.RATIO_MOB_ESSENCE_TO_LIQUID_XP;	
 		}
-
-		Logger.WARNING("drain(Ex2)");
-		return stack;
+		aRuns = (int) (aTankSpaceLeft / aAmount);
+		for (int i=0;i<aRuns;i++) {
+			if (getAdjustedVolume() == 0) {
+				break;
+			}
+		}		
+		return aSuperResult;		
 	}
 
 	@Override
-	public boolean canFill(final ForgeDirection from, final Fluid fluid) {
-		if (this.mConvertToEssence){
-			if (this.tankEssence.getFluidAmount() < this.tankEssence.getCapacity()){
-				Logger.WARNING("canFill(mConvertToEssence)");
-				return true;
+	public boolean isLiquidInput(byte aSide) {
+		if (mConvertToEssence) {
+			if (aSide == 0 || aSide == 1) {
+				return false;
 			}
-		}
-		else {
-			if (this.tankLiquidXp.getFluidAmount()  < this.tankLiquidXp.getCapacity()){
-				Logger.WARNING("canFill(tankLiquidXp)");
+		} else {
+			if (aSide == 0 || aSide == 1) {
 				return true;
 			}
 		}
-		Logger.WARNING("canFill(false)");
 		return false;
 	}
 
 	@Override
-	public boolean canDrain(final ForgeDirection from, final Fluid fluid) {
-		if (this.mConvertToEssence){
-			if (this.tankEssence.getFluidAmount() > 0){
+	public boolean isLiquidOutput(byte aSide) {
+		if (mConvertToEssence) {
+			if (aSide == 0 || aSide == 1) {
 				return true;
 			}
-		}
-		else {
-			if (this.tankLiquidXp.getFluidAmount() > 0){
-				return true;
+		} else {
+			if (aSide == 0 || aSide == 1) {
+				return false;
 			}
 		}
-		Logger.WARNING("canDrain(false)");
 		return false;
 	}
 
 	@Override
-	public FluidTankInfo[] getTankInfo(final ForgeDirection from) {
-		if (this.mConvertToEssence){
-			return new FluidTankInfo[] { this.tankEssence.getInfo() };
-		}
-		else {
-			return new FluidTankInfo[] { this.tankLiquidXp.getInfo() };
+	public int fill(ForgeDirection aSide, FluidStack aFluid, boolean doFill) {
+		if (mConvertToEssence) {
+			if (aSide != ForgeDirection.UP && aSide != ForgeDirection.DOWN) {
+				return this.tankLiquidXp.fill(aFluid, doFill);
+			}
+		} else {
+			if (aSide == ForgeDirection.UP || aSide == ForgeDirection.DOWN) {
+				return this.tankEssence.fill(aFluid, doFill);
+			}
 		}
+		return 0;
 	}
 
-	public float getAdjustedVolume() {
-		Logger.WARNING("AdjustedVolume()");
-		this.needsUpdate = true;
-		final float amount = this.tankLiquidXp.getFluidAmount();
-		final float capacity = this.tankLiquidXp.getCapacity();
-		final float volume = (amount / capacity) * 0.8F;
-		return volume;
+	@Override
+	public FluidStack drain(ForgeDirection aSide, int maxDrain, boolean doDrain) {
+		if (mConvertToEssence) {
+			if (aSide == ForgeDirection.UP || aSide == ForgeDirection.DOWN) {
+				return this.tankEssence.drain(maxDrain, doDrain);
+			}
+		} else {
+			if (aSide != ForgeDirection.UP && aSide != ForgeDirection.DOWN) {
+				return this.tankLiquidXp.drain(maxDrain, doDrain);
+			}
+		}
+		return null;
 	}
 
 	@Override
-	public void updateEntity() {
-
-		if (this.isServerSide()){
-			this.mTickTime++;
-
-			if (this.needsUpdate) {
-				if (this.updateTimer == 0) {
-					this.updateTimer = 10; // every 10 ticks it will send an update
-				} else {
-					--this.updateTimer;
-					if (this.updateTimer == 0) {
-						this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
-						this.needsUpdate = false;
-					}
-				}
+	public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain) {
+		if (mConvertToEssence) {
+			if (aSide == ForgeDirection.UP || aSide == ForgeDirection.DOWN) {
+				return this.tankEssence.drain(aFluid, doDrain);
 			}
+		} else {
+			if (aSide != ForgeDirection.UP && aSide != ForgeDirection.DOWN) {
+				return this.tankLiquidXp.drain(aFluid, doDrain);
+			}
+		}
+		return null;
+	}
 
-
-			if (this.mConvertToEssence){
-				if ((this.tankLiquidXp.getFluid() != null) && (this.tankLiquidXp.getFluidAmount() >= 100) && (this.tankEssence.getFluidAmount() <= (this.tankEssence.getCapacity()-(100*EnchantingUtils.RATIO_MOB_ESSENCE_TO_LIQUID_XP)))){
-					final FluidStack bigStorage = EnchantingUtils.getEssenceFromLiquidXp(100);
-					this.tankEssence.fill(bigStorage, true);
-					this.tankLiquidXp.drain(100, true);
-					this.needsUpdate = true;
-					Logger.WARNING("B->A");
-				}
+	@Override
+	public boolean canFill(ForgeDirection aSide, Fluid aFluid) {
+		if (mConvertToEssence) {
+			if (aSide != ForgeDirection.UP && aSide != ForgeDirection.DOWN) {
+				return this.tankLiquidXp.canTankBeFilled();
 			}
-			else {
-				final double rm = EnchantingUtils.RATIO_MOB_ESSENCE_TO_LIQUID_XP;
-				if ((this.tankEssence.getFluid() != null) && (this.tankEssence.getFluidAmount() >= rm) && (this.tankLiquidXp.getFluidAmount() <= (this.tankLiquidXp.getCapacity()-rm))){
-					final FluidStack bigStorage = EnchantingUtils.getLiquidXP(1);
-					this.tankLiquidXp.fill(bigStorage, true);
-					this.tankEssence.drain((int) rm, true);
-					this.needsUpdate = true;
-					Logger.WARNING("A->B");
-				}
+		} else {
+			if (aSide == ForgeDirection.UP || aSide == ForgeDirection.DOWN) {
+				return this.tankEssence.canTankBeFilled();
 			}
 		}
-		else {
-		}
-		this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
-		this.markDirty();
-
-		if ((this.mTickTime % 20) == 0){
+		return false;
+	}
 
+	@Override
+	public boolean canDrain(ForgeDirection aSide, Fluid aFluid) {
+		if (mConvertToEssence) {
+			if (aSide == ForgeDirection.UP || aSide == ForgeDirection.DOWN) {
+				return this.tankEssence.canTankBeEmptied();
+			}
+		} else {
+			if (aSide != ForgeDirection.UP && aSide != ForgeDirection.DOWN) {
+				return this.tankLiquidXp.canTankBeEmptied();
+			}
 		}
-
+		return false;
 	}
 
 	@Override
-	public void readFromNBT(final NBTTagCompound tag) {
-		this.tankEssence.readFromNBT(tag);
-		this.tankLiquidXp.readFromNBT(tag);
-		this.mConvertToEssence = tag.getBoolean("mConvertToEssence");
-		super.readFromNBT(tag);
+	public FluidTankInfo[] getTankInfo(ForgeDirection aSide) {
+		if (aSide == ForgeDirection.UP || aSide == ForgeDirection.DOWN) {
+			return new FluidTankInfo[] { this.tankEssence.getInfo() };
+		} else {
+			return new FluidTankInfo[] { this.tankLiquidXp.getInfo() };
+
+		}
 	}
 
 	@Override
-	public void writeToNBT(final NBTTagCompound tag) {
-		this.tankEssence.writeToNBT(tag);
-		this.tankLiquidXp.writeToNBT(tag);
-		tag.setBoolean("mConvertToEssence", this.mConvertToEssence);
-		super.writeToNBT(tag);
+	public FluidStack getFluid() {
+		if (mConvertToEssence) {
+			return this.tankEssence.getFluid();
+		}
+		else {
+			return this.tankLiquidXp.getFluid();			
+		}
 	}
 
 	@Override
-	public Packet getDescriptionPacket() {
-		final NBTTagCompound tag = new NBTTagCompound();
-		this.writeToNBT(tag);
-		return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, this.blockMetadata, tag);
+	public int getFluidAmount() {
+		if (mConvertToEssence) {
+			return this.tankEssence.getFluidAmount();
+		}
+		else {
+			return this.tankLiquidXp.getFluidAmount();			
+		}
 	}
 
 	@Override
-	public void onDataPacket(final NetworkManager net, final S35PacketUpdateTileEntity pkt) {
-		final NBTTagCompound tag = pkt.func_148857_g();
-		this.readFromNBT(tag);
+	public FluidTankInfo getInfo() {
+		if (mConvertToEssence) {
+			return this.tankEssence.getInfo();
+		} else {
+			return this.tankLiquidXp.getInfo();
+		}
 	}
 
-	public void onScrewdriverRightClick(final byte aSide, final EntityPlayer aPlayer, final float aX, final float aY, final float aZ) {
-		if (this.isServerSide()){
-			if (this.mConvertToEssence){
-				PlayerUtils.messagePlayer(aPlayer, "Converting from Mob Essence to Liquid Xp.");
-			}
-			else {
-				PlayerUtils.messagePlayer(aPlayer, "Converting from Liquid Xp to Mob Essence.");
-			}
-			//Mode Change
-			this.changeMode();
+	@Override
+	public int fill(FluidStack resource, boolean doFill) {
+		if (mConvertToEssence) {
+			return this.tankEssence.fill(resource, doFill);
+		} else {
+			return this.tankLiquidXp.fill(resource, doFill);
 		}
 	}
 
-	public void onRightClick(final byte aSide, final EntityPlayer aPlayer, final int aX, final int aY, final int aZ) {
-
-		if ((Keyboard.isKeyDown(42)) || (Keyboard.isKeyDown(54))) {
-			String mInput;
-			String mOutput;
-
-			if (this.mConvertToEssence){
-				mInput = "Liquid Xp";
-				mOutput = "Mob Essence";
-			}
-			else {
-				mInput = "Mob Essence";
-				mOutput = "Liquid Xp";
-			}
-
-			PlayerUtils.messagePlayer(aPlayer, "Input: "+mInput+".");
-			PlayerUtils.messagePlayer(aPlayer, "Output: "+mOutput+".");
+	@Override
+	public FluidStack drain(int maxDrain, boolean doDrain) {
+		if (mConvertToEssence) {
+			return this.tankEssence.drain(maxDrain, doDrain);
+		} else {
+			return this.tankLiquidXp.drain(maxDrain, doDrain);
 		}
-
 	}
 
 }
diff --git a/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityModularityTable.java b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityModularityTable.java
index a97447420a..8ba43bb197 100644
--- a/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityModularityTable.java
+++ b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityModularityTable.java
@@ -35,6 +35,7 @@ public class TileEntityModularityTable extends TileEntityBase implements ISidedI
 	private int mRecipeTimeRemaining = -1;
 
 	public TileEntityModularityTable() {
+		super(16);
 		this.inventoryGrid = new InventoryModularMain();
 		this.inventoryOutputs = new InventoryModularOutput();
 		this.mTempRecipeStorage = new InventoryModularOutput();
@@ -363,7 +364,7 @@ public class TileEntityModularityTable extends TileEntityBase implements ISidedI
 
 	@Override
 	public String getInventoryName() {
-		return this.hasCustomInventoryName() ? this.customName : "container.fishrap";
+		return this.hasCustomInventoryName() ? this.customName : "container.fishtrap";
 	}
 
 	@Override
@@ -372,7 +373,7 @@ public class TileEntityModularityTable extends TileEntityBase implements ISidedI
 	}
 
 	@Override
-	public boolean onPreTick() {
+	public boolean onPreTick(long aTick) {
 		//Check for active recipe
 		if (this.mRecipeTimeRemaining > -1 || (this.mTempRecipeStorage != null) && (this.mTempRecipeStorage.getRecipeTime() > -1)){
 			if ((this.mTempRecipeStorage != null) && this.mTempRecipeStorage.getRecipeTime() > -1){
@@ -393,7 +394,7 @@ public class TileEntityModularityTable extends TileEntityBase implements ISidedI
 	}
 
 	@Override
-	public boolean onPostTick() {
+	public boolean onPostTick(long aTick) {
 		if (mRecipeTimeRemaining == 0){
 			this.inventoryOutputs.setInventorySlotContents(2, this.getPendingOutputItem());	
 			clearRecipeData();
diff --git a/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityTradeTable.java b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityTradeTable.java
index d766d0d02e..ad7ec3d0b3 100644
--- a/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityTradeTable.java
+++ b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityTradeTable.java
@@ -18,6 +18,7 @@ public class TileEntityTradeTable extends TileEntityBase {
 	private Container_TradeTable container;
 
 	public TileEntityTradeTable(){
+		super(2);
 		this.inventoryGrid = new InventoryTradeMain();//number of slots - without product slot
 		this.inventoryOutputs = new InventoryTradeOutput();//number of slots - without product slot
 	}