+ Added the Big Shovels, which are 3x3 shovels.

+ Updated Generated Tools and their damage taken when mining blocks.
> Now meta-tools only generate if they have a valid colour, durability and recipe contains valid components.

$ Fixed Fluid Cell Recipes between .08/.09 branches.
% Cleaned up some old textures.

+ Added a log message to output total recipes the mod has added for crafting table use.

+ Started the base work for extra NBT data saving for GT TileEntities.

22 files changed, 5065 insertions, 91 deletions

diff --git a/.classpath b/.classpath
index 37602a4409..3e8a66c867 100644
--- a/.classpath
+++ b/.classpath
@@ -13,6 +13,6 @@
 	<classpathentry kind="lib" path="libs/Baubles-deobf-1.7.10-1.0.1.10.jar"/>
 	<classpathentry kind="lib" path="libs/forestry_1.7.10-4.2.2.50-deobf.jar"/>
 	<classpathentry kind="lib" path="libs/industrialcraft-2-2.2.783-experimental-deobf.jar"/>
-	<classpathentry kind="lib" path="libs/gregtech-5.09.23-NoTC-dev.jar"/>
+	<classpathentry kind="lib" path="libs/gregtech_1.7.10-5.08.30-dev.jar" sourcepath="/Gregtech/src"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/src/Java/gregtech/api/metatileentity/BaseMetaTileEntityEx.java b/src/Java/gregtech/api/metatileentity/BaseMetaTileEntityEx.java
new file mode 100644
index 0000000000..1669a11f9a
--- /dev/null
+++ b/src/Java/gregtech/api/metatileentity/BaseMetaTileEntityEx.java
@@ -0,0 +1,2081 @@
+package gregtech.api.metatileentity;
+
+import static gregtech.api.enums.GT_Values.NW;
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.GT_Mod;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IEnergyConnected;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.net.GT_Packet_TileEntity;
+import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.util.GT_CoverBehavior;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.xmod.gregtech.common.Meta_GT_Proxy;
+import ic2.api.Direction;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockFire;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.Packet;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.EnumSkyBlock;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+
+/**
+ * NEVER INCLUDE THIS FILE IN YOUR MOD!!!
+ * <p/>
+ * This is the main TileEntity for EVERYTHING.
+ */
+public class BaseMetaTileEntityEx extends BaseTileEntity implements IGregTechTileEntity {
+	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 MetaTileEntityEx mMetaTileEntity;
+	protected long mStoredEnergy = 0, mStoredSteam = 0;
+	protected int mAverageEUInputIndex = 0, mAverageEUOutputIndex = 0;
+	protected boolean mReleaseEnergy = false;
+	protected int[] mAverageEUInput = new int[]{0, 0, 0, 0, 0}, mAverageEUOutput = new int[]{0, 0, 0, 0, 0};
+	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];
+
+
+	//TODO
+	//TODO
+	//TODO
+	//TODO
+	private boolean mHasEnoughEnergy = true;
+	private boolean  mRunningThroughTick = false;
+	private boolean mInputDisabled = false;
+	private 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;
+	//TODO
+	//TODO
+
+	// Create a new NBT Tag List to store itemstacks as NBT Tags
+	protected NBTTagList mInventoryItems = new NBTTagList();
+	protected ItemStack[] mInventory;
+	//TODO
+	//TODO
+	//TODO
+
+	private byte mColor = 0, oColor = 0, mStrongRedstone = 0, oRedstoneData = 63, oTextureData = 0, oUpdateData = 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;
+	private long mTickTimer = 0, oOutput = 0, mAcceptedAmperes = Long.MAX_VALUE;
+	private String mOwnerName = "";
+	private NBTTagCompound mRecipeStuff = new NBTTagCompound();
+
+	public BaseMetaTileEntityEx() {
+	/*	this.mInventory = mMetaTileEntity.mInventory;
+		Utils.LOG_INFO(UtilsItems.getArrayStackNames(mInventory));*/
+	}
+
+	
+	@Override
+	public void writeToNBT(NBTTagCompound aNBT) {
+		try {
+			super.writeToNBT(aNBT);
+		} catch (Throwable e) {
+			GT_Log.err.println("GT++ - Encountered CRITICAL ERROR while saving MetaTileEntity, the Chunk whould've been corrupted by now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+			e.printStackTrace(GT_Log.err);
+		}
+		try {
+			aNBT.setInteger("mID", mID);
+			aNBT.setLong("mStoredSteam", mStoredSteam);
+			aNBT.setLong("mStoredEnergy", mStoredEnergy);
+			aNBT.setIntArray("mCoverData", mCoverData);
+			aNBT.setIntArray("mCoverSides", mCoverSides);
+			aNBT.setByteArray("mRedstoneSided", mSidedRedstone);
+			aNBT.setByte("mColor", mColor);
+			aNBT.setByte("mLightValue", mLightValue);
+			aNBT.setByte("mOtherUpgrades", mOtherUpgrades);
+			aNBT.setByte("mWorkData", mWorkData);
+			aNBT.setByte("mStrongRedstone", mStrongRedstone);
+			aNBT.setShort("mFacing", mFacing);
+			aNBT.setString("mOwnerName", mOwnerName);
+			aNBT.setBoolean("mLockUpgrade", mLockUpgrade);
+			aNBT.setBoolean("mMuffler", mMuffler);
+			aNBT.setBoolean("mSteamConverter", mSteamConverter);
+			aNBT.setBoolean("mActive", mActive);
+			aNBT.setBoolean("mRedstone", mRedstone);
+			aNBT.setBoolean("mWorks", !mWorks);
+			aNBT.setBoolean("mInputDisabled", mInputDisabled);
+			aNBT.setBoolean("mOutputDisabled", mOutputDisabled);
+			aNBT.setTag("GT.CraftingComponents", mRecipeStuff);
+			
+			//Let's try save the contents of the inventory
+			// Create a new NBT Tag List to store itemstacks as NBT Tags
+			NBTTagList items = new NBTTagList();
+
+			for (int i = 0; i < getSizeInventory(); ++i)
+			{
+				// Only write stacks that contain items
+				if (getStackInSlot(i) != null){
+					// Make a new NBT Tag Compound to write the itemstack and slot index to
+					NBTTagCompound item = new NBTTagCompound();
+					item.setInteger("Slot", i);
+					// Writes the itemstack in slot(i) to the Tag Compound we just made
+					getStackInSlot(i).writeToNBT(item);
+					// add the tag compound to our tag list
+					items.appendTag(item);
+				}
+			}			
+			// Add the TagList to the ItemStack's Tag Compound with the name "ItemInventory"
+			aNBT.setTag("TileEntityInventory", items);
+			
+		} catch (Throwable e) {
+			GT_Log.err.println("GT++ - Encountered CRITICAL ERROR while saving MetaTileEntity, the Chunk whould've been corrupted by now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+			e.printStackTrace(GT_Log.err);
+		}
+		try {
+			if (hasValidMetaTileEntity()) {
+				NBTTagList tItemList = new NBTTagList();
+				for (int i = 0; i < mMetaTileEntity.getRealInventory().length; i++) {
+					ItemStack tStack = mMetaTileEntity.getRealInventory()[i];
+					if (tStack != null) {
+						NBTTagCompound tTag = new NBTTagCompound();
+						tTag.setInteger("IntSlot", i);
+						tStack.writeToNBT(tTag);
+						tItemList.appendTag(tTag);
+					}
+				}
+				aNBT.setTag("Inventory", tItemList);
+
+				try {
+					mMetaTileEntity.saveNBTData(aNBT);
+				} catch (Throwable e) {
+					GT_Log.err.println("GT++ - Encountered CRITICAL ERROR while saving MetaTileEntity, the Chunk whould've been corrupted by now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+					e.printStackTrace(GT_Log.err);
+				}
+			}
+		} catch (Throwable e) {
+			GT_Log.err.println("GT++ - Encountered CRITICAL ERROR while saving MetaTileEntity, the Chunk whould've been corrupted by now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+			e.printStackTrace(GT_Log.err);
+		}
+	}
+
+	
+	@Override
+	public void readFromNBT(NBTTagCompound aNBT) {
+		super.readFromNBT(aNBT);
+		setInitialValuesAsNBT(aNBT, (short) 0);
+	}
+
+	
+	@Override
+	public void setInitialValuesAsNBT(NBTTagCompound aNBT, short aID) {
+		if (aNBT == null) {
+			if (aID > 0) mID = aID;
+			else mID = mID > 0 ? mID : 0;
+			if (mID != 0) createNewMetatileEntity(mID);
+			mSidedRedstone = (hasValidMetaTileEntity() && mMetaTileEntity.hasSidedRedstoneOutputBehavior() ? new byte[]{0, 0, 0, 0, 0, 0} : new byte[]{15, 15, 15, 15, 15, 15});
+		} else {
+			if (aID <= 0) mID = (short) aNBT.getInteger("mID");
+			else mID = aID;
+			mStoredSteam = aNBT.getInteger("mStoredSteam");
+			mStoredEnergy = aNBT.getInteger("mStoredEnergy");
+			mColor = aNBT.getByte("mColor");
+			mLightValue = aNBT.getByte("mLightValue");
+			mWorkData = aNBT.getByte("mWorkData");
+			mStrongRedstone = aNBT.getByte("mStrongRedstone");
+			mFacing = oFacing = (byte) aNBT.getShort("mFacing");
+			mOwnerName = aNBT.getString("mOwnerName");
+			mLockUpgrade = aNBT.getBoolean("mLockUpgrade");
+			mMuffler = aNBT.getBoolean("mMuffler");
+			mSteamConverter = aNBT.getBoolean("mSteamConverter");
+			mActive = aNBT.getBoolean("mActive");
+			mRedstone = aNBT.getBoolean("mRedstone");
+			mWorks = !aNBT.getBoolean("mWorks");
+			mInputDisabled = aNBT.getBoolean("mInputDisabled");
+			mOutputDisabled = aNBT.getBoolean("mOutputDisabled");
+			mOtherUpgrades = (byte) (aNBT.getByte("mOtherUpgrades") + aNBT.getByte("mBatteries") + aNBT.getByte("mLiBatteries"));
+			mCoverSides = aNBT.getIntArray("mCoverSides");
+			mCoverData = aNBT.getIntArray("mCoverData");
+			mSidedRedstone = aNBT.getByteArray("mRedstoneSided");
+			mRecipeStuff = aNBT.getCompoundTag("GT.CraftingComponents");
+			
+			//Loading Invetory contents
+			// Gets the custom taglist we wrote to this compound, if any
+			NBTTagList items = aNBT.getTagList("TileEntityInventory", Constants.NBT.TAG_COMPOUND);
+			for (int i = 0; i < items.tagCount(); ++i){
+				NBTTagCompound item = (NBTTagCompound) items.getCompoundTagAt(i);
+				int slot = item.getInteger("Slot");
+				// Just double-checking that the saved slot index is within our inventory array bounds
+				if (slot >= 0 && slot < getSizeInventory()) {
+					mInventory[slot] = ItemStack.loadItemStackFromNBT(item);
+				}
+			}
+
+			if (mCoverData.length != 6) mCoverData = new int[]{0, 0, 0, 0, 0, 0};
+			if (mCoverSides.length != 6) mCoverSides = new int[]{0, 0, 0, 0, 0, 0};
+			if (mSidedRedstone.length != 6)
+				if (hasValidMetaTileEntity() && mMetaTileEntity.hasSidedRedstoneOutputBehavior())
+					mSidedRedstone = new byte[]{0, 0, 0, 0, 0, 0};
+				else mSidedRedstone = new byte[]{15, 15, 15, 15, 15, 15};
+
+			for (byte i = 0; i < 6; i++) mCoverBehaviors[i] = GregTech_API.getCoverBehavior(mCoverSides[i]);
+
+			if (mID != 0 && createNewMetatileEntity(mID)) {
+				NBTTagList tItemList = aNBT.getTagList("Inventory", 10);
+				for (int i = 0; i < tItemList.tagCount(); i++) {
+					NBTTagCompound tTag = tItemList.getCompoundTagAt(i);
+					int tSlot = tTag.getInteger("IntSlot");
+					if (tSlot >= 0 && tSlot < mMetaTileEntity.getRealInventory().length) {
+						mMetaTileEntity.getRealInventory()[tSlot] = GT_Utility.loadItem(tTag);
+					}
+				}
+
+				try {
+					mMetaTileEntity.loadNBTData(aNBT);
+				} catch (Throwable e) {
+					GT_Log.err.println("GT++ - Encountered Exception while loading MetaTileEntity, the Server should've crashed now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+					e.printStackTrace(GT_Log.err);
+				}
+			}
+		}
+
+		if (mCoverData.length != 6) mCoverData = new int[]{0, 0, 0, 0, 0, 0};
+		if (mCoverSides.length != 6) mCoverSides = new int[]{0, 0, 0, 0, 0, 0};
+		if (mSidedRedstone.length != 6)
+			if (hasValidMetaTileEntity() && mMetaTileEntity.hasSidedRedstoneOutputBehavior())
+				mSidedRedstone = new byte[]{0, 0, 0, 0, 0, 0};
+			else mSidedRedstone = new byte[]{15, 15, 15, 15, 15, 15};
+
+		for (byte i = 0; i < 6; i++) mCoverBehaviors[i] = GregTech_API.getCoverBehavior(mCoverSides[i]);
+	}
+
+	private boolean createNewMetatileEntity(short aID) {
+		if (aID <= 0 || aID >= Meta_GT_Proxy.METATILEENTITIES.length || Meta_GT_Proxy.METATILEENTITIES[aID] == null) {
+			GT_Log.err.println("GT++ - MetaID " + aID + " not loadable => locking TileEntity!");
+		} else {
+			if (aID != 0) {
+				if (hasValidMetaTileEntity()) mMetaTileEntity.setBaseMetaTileEntity(null);
+				Meta_GT_Proxy.METATILEENTITIES[aID].newMetaEntity(this).setBaseMetaTileEntity(this);
+				mTickTimer = 0;
+				mID = aID;
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Used for ticking special BaseMetaTileEntities, which need that for Energy Conversion
+	 * It's called right before onPostTick()
+	 */
+	public void updateStatus() {
+		//
+	}
+
+	/**
+	 * Called when trying to charge Items
+	 */
+	public void chargeItem(ItemStack aStack) {
+		decreaseStoredEU(GT_ModHandler.chargeElectricItem(aStack, (int) Math.min(Integer.MAX_VALUE, getStoredEU()), (int) Math.min(Integer.MAX_VALUE, mMetaTileEntity.getOutputTier()), false, false), true);
+	}
+
+	/**
+	 * Called when trying to discharge Items
+	 */
+	public void dischargeItem(ItemStack aStack) {
+		increaseStoredEnergyUnits(GT_ModHandler.dischargeElectricItem(aStack, (int) Math.min(Integer.MAX_VALUE, getEUCapacity() - getStoredEU()), (int) Math.min(Integer.MAX_VALUE, mMetaTileEntity.getInputTier()), false, false, false), true);
+	}
+
+	
+	@Override
+	public void updateEntity() {
+		super.updateEntity();
+
+		if (!hasValidMetaTileEntity()) {
+			if (mMetaTileEntity == null) return;
+			mMetaTileEntity.setBaseMetaTileEntity(this);
+		}
+
+		mRunningThroughTick = true;
+		long tTime = System.currentTimeMillis();
+
+		for (int tCode = 0; hasValidMetaTileEntity() && tCode >= 0; ) {
+			try {
+				switch (tCode) {
+				case 0:
+					tCode++;
+					if (mTickTimer++ == 0) {
+						oX = xCoord;
+						oY = yCoord;
+						oZ = zCoord;
+						if (isServerSide()) for (byte i = 0; i < 6; i++)
+							if (getCoverIDAtSide(i) != 0)
+								if (!mMetaTileEntity.allowCoverOnSide(i, new GT_ItemStack(getCoverIDAtSide(i))))
+									dropCover(i, i, true);
+
+						worldObj.markTileEntityChunkModified(xCoord, yCoord, zCoord, this);
+
+						mMetaTileEntity.onFirstTick(this);
+						if (!hasValidMetaTileEntity()) {
+							mRunningThroughTick = false;
+							return;
+						}
+					}
+				case 1:
+					tCode++;
+					if (isClientSide()) {
+						if (mColor != oColor) {
+							mMetaTileEntity.onColorChangeClient(oColor = mColor);
+							issueTextureUpdate();
+						}
+
+						if (mLightValue != oLightValueClient) {
+							worldObj.setLightValue(EnumSkyBlock.Block, xCoord, yCoord, zCoord, mLightValue);
+							worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord);
+							worldObj.updateLightByType(EnumSkyBlock.Block, xCoord + 1, yCoord, zCoord);
+							worldObj.updateLightByType(EnumSkyBlock.Block, xCoord - 1, yCoord, zCoord);
+							worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord + 1, zCoord);
+							worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord - 1, zCoord);
+							worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord + 1);
+							worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord - 1);
+							oLightValueClient = mLightValue;
+							issueTextureUpdate();
+						}
+
+						if (mNeedsUpdate) {
+							worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+							//worldObj.func_147479_m(xCoord, yCoord, zCoord);
+							mNeedsUpdate = false;
+						}
+					}
+				case 2:
+				case 3:
+				case 4:
+				case 5:
+				case 6:
+				case 7:
+					if (isServerSide() && mTickTimer > 10) {
+						for (byte i = (byte) (tCode - 2); i < 6; i++)
+							if (getCoverIDAtSide(i) != 0) {
+								tCode++;
+								GT_CoverBehavior tCover = getCoverBehaviorAtSide(i);
+								int tCoverTickRate = tCover.getTickRate(i, getCoverIDAtSide(i), mCoverData[i], this);
+								if (tCoverTickRate > 0 && mTickTimer % tCoverTickRate == 0) {
+									mCoverData[i] = tCover.doCoverThings(i, getInputRedstoneSignal(i), getCoverIDAtSide(i), mCoverData[i], this, mTickTimer);
+									if (!hasValidMetaTileEntity()) {
+										mRunningThroughTick = false;
+										return;
+									}
+								}
+							}
+
+					}
+				case 8:
+					tCode = 9;
+					if (isServerSide()) {
+						if (++mAverageEUInputIndex >= mAverageEUInput.length) mAverageEUInputIndex = 0;
+						if (++mAverageEUOutputIndex >= mAverageEUOutput.length) mAverageEUOutputIndex = 0;
+
+						mAverageEUInput[mAverageEUInputIndex] = 0;
+						mAverageEUOutput[mAverageEUOutputIndex] = 0;
+					}
+				case 9:
+					tCode++;
+					mMetaTileEntity.onPreTick(this, mTickTimer);
+					if (!hasValidMetaTileEntity()) {
+						mRunningThroughTick = false;
+						return;
+					}
+				case 10:
+					tCode++;
+					if (isServerSide()) {
+						if (mRedstone != oRedstone || mTickTimer == 10) {
+							for (byte i = 0; i < 6; i++)
+								mCoverBehaviors[i] = GregTech_API.getCoverBehavior(mCoverSides[i]);
+							oRedstone = mRedstone;
+							issueBlockUpdate();
+						}
+
+						if (xCoord != oX || yCoord != oY || zCoord != oZ) {
+							oX = xCoord;
+							oY = yCoord;
+							oZ = zCoord;
+							issueClientUpdate();
+							clearTileEntityBuffer();
+						}
+
+						if (mFacing != oFacing) {
+							oFacing = mFacing;
+							for (byte i = 0; i < 6; i++)
+								if (getCoverIDAtSide(i) != 0)
+									if (!mMetaTileEntity.allowCoverOnSide(i, new GT_ItemStack(getCoverIDAtSide(i))))
+										dropCover(i, i, true);
+							issueBlockUpdate();
+						}
+
+						if (mTickTimer > 20 && mMetaTileEntity.isElectric()) {
+							mAcceptedAmperes = 0;
+
+							if (getOutputVoltage() != oOutput) {
+								oOutput = getOutputVoltage();
+							}
+
+							if (mMetaTileEntity.isEnetOutput() || mMetaTileEntity.isEnetInput()) {
+								for (byte i = 0; i < 6; i++) {
+									boolean
+									temp = isEnergyInputSide(i);
+									if (temp != mActiveEUInputs[i]) {
+										mActiveEUInputs[i] = temp;
+									}
+									temp = isEnergyOutputSide(i);
+									if (temp != mActiveEUOutputs[i]) {
+										mActiveEUOutputs[i] = temp;
+									}
+								}
+							}
+
+							if (mMetaTileEntity.isEnetOutput() && oOutput > 0) {
+								long tOutputVoltage = Math.max(oOutput, oOutput + (1 << GT_Utility.getTier(oOutput))), tUsableAmperage = Math.min(getOutputAmperage(), (getStoredEU() - mMetaTileEntity.getMinimumStoredEU()) / tOutputVoltage);
+								if (tUsableAmperage > 0) {
+									long tEU = tOutputVoltage * IEnergyConnected.Util.emitEnergyToNetwork(oOutput, tUsableAmperage, this);
+									mAverageEUOutput[mAverageEUOutputIndex] += tEU;
+									decreaseStoredEU(tEU, true);
+								}
+							}
+							if (getEUCapacity() > 0) {
+								if (GregTech_API.sMachineFireExplosions && getRandomNumber(1000) == 0) {
+									Block tBlock = getBlockAtSide((byte) getRandomNumber(6));
+									if (tBlock != null && tBlock instanceof BlockFire) doEnergyExplosion();
+								}
+
+								if (!hasValidMetaTileEntity()) {
+									mRunningThroughTick = false;
+									return;
+								}
+
+								if (getRandomNumber(1000) == 0) {
+									if ((getCoverIDAtSide((byte) 1) == 0 && worldObj.getPrecipitationHeight(xCoord, zCoord) - 2 < yCoord)
+											|| (getCoverIDAtSide((byte) 2) == 0 && worldObj.getPrecipitationHeight(xCoord, zCoord - 1) - 1 < yCoord)
+											|| (getCoverIDAtSide((byte) 3) == 0 && worldObj.getPrecipitationHeight(xCoord, zCoord + 1) - 1 < yCoord)
+											|| (getCoverIDAtSide((byte) 4) == 0 && worldObj.getPrecipitationHeight(xCoord - 1, zCoord) - 1 < yCoord)
+											|| (getCoverIDAtSide((byte) 5) == 0 && worldObj.getPrecipitationHeight(xCoord + 1, zCoord) - 1 < yCoord)) {
+										if (GregTech_API.sMachineRainExplosions && worldObj.isRaining() && getBiome().rainfall > 0) {
+											if (getRandomNumber(10) == 0) {
+												try {
+													GT_Mod.instance.achievements.issueAchievement(this.getWorldObj().getPlayerEntityByName(mOwnerName), "badweather");
+												} catch (Exception e) {
+												}
+												doEnergyExplosion();
+											} else setOnFire();
+										}
+										if (!hasValidMetaTileEntity()) {
+											mRunningThroughTick = false;
+											return;
+										}
+										if (GregTech_API.sMachineThunderExplosions && worldObj.isThundering() && getBiome().rainfall > 0 && getRandomNumber(3) == 0) {
+											try {
+												GT_Mod.instance.achievements.issueAchievement(this.getWorldObj().getPlayerEntityByName(mOwnerName), "badweather");
+											} catch (Exception e) {
+											}
+											doEnergyExplosion();
+										}
+									}
+								}
+							}
+						}
+
+						if (!hasValidMetaTileEntity()) {
+							mRunningThroughTick = false;
+							return;
+						}
+					}
+				case 11:
+					tCode++;
+					if (isServerSide()) {
+						if (mMetaTileEntity.dechargerSlotCount() > 0 && getStoredEU() < getEUCapacity()) {
+							for (int i = mMetaTileEntity.dechargerSlotStartIndex(), k = mMetaTileEntity.dechargerSlotCount() + i; i < k; i++) {
+								if (mMetaTileEntity.mInventory[i] != null && getStoredEU() < getEUCapacity()) {
+									dischargeItem(mMetaTileEntity.mInventory[i]);
+									if (mMetaTileEntity.mInventory[i].stackSize <= 0)
+										mMetaTileEntity.mInventory[i] = null;
+									mInventoryChanged = true;
+								}
+							}
+						}
+					}
+				case 12:
+					tCode++;
+					if (isServerSide()) {
+						if (mMetaTileEntity.rechargerSlotCount() > 0 && getStoredEU() > 0) {
+							for (int i = mMetaTileEntity.rechargerSlotStartIndex(), k = mMetaTileEntity.rechargerSlotCount() + i; i < k; i++) {
+								if (getStoredEU() > 0 && mMetaTileEntity.mInventory[i] != null) {
+									chargeItem(mMetaTileEntity.mInventory[i]);
+									if (mMetaTileEntity.mInventory[i].stackSize <= 0)
+										mMetaTileEntity.mInventory[i] = null;
+									mInventoryChanged = true;
+								}
+							}
+						}
+					}
+				case 13:
+					tCode++;
+					updateStatus();
+					if (!hasValidMetaTileEntity()) {
+						mRunningThroughTick = false;
+						return;
+					}
+				case 14:
+					tCode++;
+					mMetaTileEntity.onPostTick(this, mTickTimer);
+					if (!hasValidMetaTileEntity()) {
+						mRunningThroughTick = false;
+						return;
+					}
+				case 15:
+					tCode++;
+					if (isServerSide()) {
+						if (mTickTimer % 10 == 0) {
+							if (mSendClientData) {
+								NW.sendPacketToAllPlayersInRange(worldObj, new GT_Packet_TileEntity(xCoord, (short) yCoord, zCoord, mID, mCoverSides[0], mCoverSides[1], mCoverSides[2], mCoverSides[3], mCoverSides[4], mCoverSides[5], oTextureData = (byte) ((mFacing & 7) | (mActive ? 8 : 0) | (mRedstone ? 16 : 0) | (mLockUpgrade ? 32 : 0)), oUpdateData = hasValidMetaTileEntity() ? mMetaTileEntity.getUpdateData() : 0, oRedstoneData = (byte) (((mSidedRedstone[0] > 0) ? 1 : 0) | ((mSidedRedstone[1] > 0) ? 2 : 0) | ((mSidedRedstone[2] > 0) ? 4 : 0) | ((mSidedRedstone[3] > 0) ? 8 : 0) | ((mSidedRedstone[4] > 0) ? 16 : 0) | ((mSidedRedstone[5] > 0) ? 32 : 0)), oColor = mColor), xCoord, zCoord);
+								mSendClientData = false;
+							}
+						}
+
+						if (mTickTimer > 10) {
+							byte tData = (byte) ((mFacing & 7) | (mActive ? 8 : 0) | (mRedstone ? 16 : 0) | (mLockUpgrade ? 32 : 0));
+							if (tData != oTextureData) sendBlockEvent((byte) 0, oTextureData = tData);
+							tData = mMetaTileEntity.getUpdateData();
+							if (tData != oUpdateData) sendBlockEvent((byte) 1, oUpdateData = tData);
+							if (mColor != oColor) sendBlockEvent((byte) 2, oColor = mColor);
+							tData = (byte) (((mSidedRedstone[0] > 0) ? 1 : 0) | ((mSidedRedstone[1] > 0) ? 2 : 0) | ((mSidedRedstone[2] > 0) ? 4 : 0) | ((mSidedRedstone[3] > 0) ? 8 : 0) | ((mSidedRedstone[4] > 0) ? 16 : 0) | ((mSidedRedstone[5] > 0) ? 32 : 0));
+							if (tData != oRedstoneData) sendBlockEvent((byte) 3, oRedstoneData = tData);
+							if (mLightValue != oLightValue) {
+								worldObj.setLightValue(EnumSkyBlock.Block, xCoord, yCoord, zCoord, mLightValue);
+								worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord);
+								worldObj.updateLightByType(EnumSkyBlock.Block, xCoord + 1, yCoord, zCoord);
+								worldObj.updateLightByType(EnumSkyBlock.Block, xCoord - 1, yCoord, zCoord);
+								worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord + 1, zCoord);
+								worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord - 1, zCoord);
+								worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord + 1);
+								worldObj.updateLightByType(EnumSkyBlock.Block, xCoord, yCoord, zCoord - 1);
+								issueTextureUpdate();
+								sendBlockEvent((byte) 7, oLightValue = mLightValue);
+							}
+						}
+
+						if (mNeedsBlockUpdate) {
+							worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, getBlockOffset(0, 0, 0));
+							mNeedsBlockUpdate = false;
+						}
+					}
+				default:
+					tCode = -1;
+					break;
+				}
+			} catch (Throwable e) {
+				GT_Log.err.println("GT++ - Encountered Exception while ticking MetaTileEntity in Step " + (tCode - 1) + ". The Game should've crashed now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+				e.printStackTrace(GT_Log.err);
+			}
+		}
+
+		if (isServerSide() && hasValidMetaTileEntity()) {
+			tTime = System.currentTimeMillis() - tTime;
+			if (mTimeStatistics.length > 0)
+				mTimeStatistics[mTimeStatisticsIndex = (mTimeStatisticsIndex + 1) % mTimeStatistics.length] = (int) tTime;
+			if (tTime > 0 && tTime > GregTech_API.MILLISECOND_THRESHOLD_UNTIL_LAG_WARNING && mTickTimer > 1000 && getMetaTileEntity().doTickProfilingMessageDuringThisTick() && mLagWarningCount++ < 10)
+				System.out.println("GT++ - WARNING: Possible Lag Source at [" + xCoord + ", " + yCoord + ", " + zCoord + "] in Dimension " + worldObj.provider.dimensionId + " with " + tTime + "ms caused by an instance of " + getMetaTileEntity().getClass());
+		}
+
+		mWorkUpdate = mInventoryChanged = mRunningThroughTick = false;
+	}
+
+	
+	@Override
+	public Packet getDescriptionPacket() {
+		issueClientUpdate();
+		return null;
+	}
+
+	
+	@Override
+	public boolean receiveClientEvent(int aEventID, int aValue) {
+		super.receiveClientEvent(aEventID, aValue);
+
+		if (hasValidMetaTileEntity()) {
+			try {
+				mMetaTileEntity.receiveClientEvent((byte) aEventID, (byte) aValue);
+			} catch (Throwable e) {
+				GT_Log.err.println("GT++ - Encountered Exception while receiving Data from the Server, the Client should've been crashed by now, but I prevented that. Please report immidietly to GregTech Intergalactical!!!");
+				e.printStackTrace(GT_Log.err);
+			}
+		}
+
+		if (isClientSide()) {
+			issueTextureUpdate();
+			switch (aEventID) {
+			case 0:
+				mFacing = (byte) (aValue & 7);
+				mActive = ((aValue & 8) != 0);
+				mRedstone = ((aValue & 16) != 0);
+				//mLockUpgrade	= ((aValue&32) != 0);
+				break;
+			case 1:
+				if (hasValidMetaTileEntity()) mMetaTileEntity.onValueUpdate((byte) aValue);
+				break;
+			case 2:
+				if (aValue > 16 || aValue < 0) aValue = 0;
+				mColor = (byte) aValue;
+				break;
+			case 3:
+				mSidedRedstone[0] = (byte) ((aValue & 1) > 0 ? 15 : 0);
+				mSidedRedstone[1] = (byte) ((aValue & 2) > 0 ? 15 : 0);
+				mSidedRedstone[2] = (byte) ((aValue & 4) > 0 ? 15 : 0);
+				mSidedRedstone[3] = (byte) ((aValue & 8) > 0 ? 15 : 0);
+				mSidedRedstone[4] = (byte) ((aValue & 16) > 0 ? 15 : 0);
+				mSidedRedstone[5] = (byte) ((aValue & 32) > 0 ? 15 : 0);
+				break;
+			case 4:
+				if (hasValidMetaTileEntity() && mTickTimer > 20)
+					mMetaTileEntity.doSound((byte) aValue, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5);
+				break;
+			case 5:
+				if (hasValidMetaTileEntity() && mTickTimer > 20)
+					mMetaTileEntity.startSoundLoop((byte) aValue, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5);
+				break;
+			case 6:
+				if (hasValidMetaTileEntity() && mTickTimer > 20)
+					mMetaTileEntity.stopSoundLoop((byte) aValue, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5);
+				break;
+			case 7:
+				mLightValue = (byte) aValue;
+				break;
+			}
+		}
+		return true;
+	}
+
+	public ArrayList<String> getDebugInfo(EntityPlayer aPlayer, int aLogLevel) {
+		ArrayList<String> tList = new ArrayList<String>();
+		if (aLogLevel > 2) {
+			tList.add("GT++ - Meta-ID: " + mID + (canAccessData() ? " valid" : " invalid") + (mMetaTileEntity == null ? " MetaTileEntity == null!" : " "));
+		}
+		if (aLogLevel > 1) {
+			if (mTimeStatistics.length > 0) {
+				double tAverageTime = 0;
+				for (int tTime : mTimeStatistics) tAverageTime += tTime;
+				tList.add("GT++ - This particular TileEntity has caused an average CPU-load of ~" + (tAverageTime / mTimeStatistics.length) + "ms over the last " + mTimeStatistics.length + " ticks.");
+			}
+			if (mLagWarningCount > 0) {
+				tList.add("GT++ - This TileEntity has also caused " + (mLagWarningCount >= 10 ? "more than 10" : mLagWarningCount) + " Lag Spike Warnings (anything taking longer than " + GregTech_API.MILLISECOND_THRESHOLD_UNTIL_LAG_WARNING + "ms) on the Server.");
+			}
+			tList.add("Is" + (mMetaTileEntity.isAccessAllowed(aPlayer) ? " " : " not ") + "accessible for you");
+		}
+		if (aLogLevel > 0) {
+			if (getSteamCapacity() > 0 && hasSteamEngineUpgrade())
+				tList.add(getStoredSteam() + " of " + getSteamCapacity() + " Steam");
+			tList.add("Machine is " + (mActive ? "active" : "inactive"));
+			if (!mHasEnoughEnergy)
+				tList.add("GT++ - ATTENTION: This Device consumes Energy at a higher Rate than you input. You could insert more to speed up the process.");
+		}
+		return mMetaTileEntity.getSpecialDebugInfo(this, aPlayer, aLogLevel, tList);
+	}
+
+	
+	@Override
+	public void issueTextureUpdate() {
+		mNeedsUpdate = true;
+	}
+
+	
+	@Override
+	public void issueBlockUpdate() {
+		mNeedsBlockUpdate = true;</