Move source files

1 files changed, 555 insertions, 0 deletions

diff --git a/src/main/java/gregtech/api/items/GT_MetaBase_Item.java b/src/main/java/gregtech/api/items/GT_MetaBase_Item.java
new file mode 100644
index 0000000000..4a0cd6f655
--- /dev/null
+++ b/src/main/java/gregtech/api/items/GT_MetaBase_Item.java
@@ -0,0 +1,555 @@
+package gregtech.api.items;
+
+import static gregtech.api.enums.GT_Values.D1;
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.api.enums.SubTag;
+import gregtech.api.interfaces.IItemBehaviour;
+import gregtech.api.util.GT_LanguageManager;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Utility;
+import ic2.api.item.ElectricItem;
+import ic2.api.item.IElectricItem;
+import ic2.api.item.IElectricItemManager;
+import ic2.api.item.ISpecialElectricItem;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import net.minecraft.dispenser.IBlockSource;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.inventory.Container;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidContainerItem;
+
+public abstract class GT_MetaBase_Item extends GT_Generic_Item implements ISpecialElectricItem, IElectricItemManager, IFluidContainerItem {
+	/* ---------- CONSTRUCTOR AND MEMBER VARIABLES ---------- */
+	private final HashMap<Short, ArrayList<IItemBehaviour<GT_MetaBase_Item>>> mItemBehaviors = new HashMap<Short, ArrayList<IItemBehaviour<GT_MetaBase_Item>>>();
+	
+	/**
+	 * Creates the Item using these Parameters.
+	 * @param aUnlocalized The Unlocalized Name of this Item.
+	 * @param aGeneratedPrefixList The OreDict Prefixes you want to have generated.
+	 */
+	public GT_MetaBase_Item(String aUnlocalized) {
+		super(aUnlocalized, "Generated Item", null, false);
+        setHasSubtypes(true);
+        setMaxDamage(0);
+	}
+	
+	/**
+	 * Adds a special Item Behaviour to the Item.
+	 * 
+	 * Note: the boolean Behaviours sometimes won't be executed if another boolean Behaviour returned true before.
+	 * 
+	 * @param aMetaValue the Meta Value of the Item you want to add it to. [0 - 32765]
+	 * @param aBehavior the Click Behavior you want to add.
+	 * @return the Item itself for convenience in constructing.
+	 */
+	public final GT_MetaBase_Item addItemBehavior(int aMetaValue, IItemBehaviour<GT_MetaBase_Item> aBehavior) {
+		if (aMetaValue < 0 || aMetaValue >= 32766 || aBehavior == null) return this;
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)aMetaValue);
+		if (tList == null) {
+			tList = new ArrayList<IItemBehaviour<GT_MetaBase_Item>>(1);
+			mItemBehaviors.put((short)aMetaValue, tList);
+		}
+		tList.add(aBehavior);
+		return this;
+	}
+	
+	public abstract Long[] getElectricStats(ItemStack aStack);
+	public abstract Long[] getFluidContainerStats(ItemStack aStack);
+	
+	@Override
+	public boolean hasProjectile(SubTag aProjectileType, ItemStack aStack) {
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) if (tBehavior.hasProjectile(this, aProjectileType, aStack)) return true;
+    	return super.hasProjectile(aProjectileType, aStack);
+	}
+	
+	@Override
+	public EntityArrow getProjectile(SubTag aProjectileType, ItemStack aStack, World aWorld, double aX, double aY, double aZ) {
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) {
+			EntityArrow rArrow = tBehavior.getProjectile(this, aProjectileType, aStack, aWorld, aX, aY, aZ);
+			if (rArrow != null) return rArrow;
+		}
+    	return super.getProjectile(aProjectileType, aStack, aWorld, aX, aY, aZ);
+	}
+	
+	@Override
+	public EntityArrow getProjectile(SubTag aProjectileType, ItemStack aStack, World aWorld, EntityLivingBase aEntity, float aSpeed) {
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) {
+			EntityArrow rArrow = tBehavior.getProjectile(this, aProjectileType, aStack, aWorld, aEntity, aSpeed);
+			if (rArrow != null) return rArrow;
+		}
+    	return super.getProjectile(aProjectileType, aStack, aWorld, aEntity, aSpeed);
+	}
+	
+    @Override
+	public ItemStack onDispense(IBlockSource aSource, ItemStack aStack) {
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) if (tBehavior.canDispense(this, aSource, aStack)) return tBehavior.onDispense(this, aSource, aStack);
+    	return super.onDispense(aSource, aStack);
+    }
+    
+    @Override
+	public boolean isItemStackUsable(ItemStack aStack) {
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) if (!tBehavior.isItemStackUsable(this, aStack)) return false;
+    	return super.isItemStackUsable(aStack);
+    }
+    
+    @Override
+    public boolean onLeftClickEntity(ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) {
+    	use(aStack, 0, aPlayer);
+		isItemStackUsable(aStack);
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) try {
+			if (tBehavior.onLeftClickEntity(this, aStack, aPlayer, aEntity)) {
+				if (aStack.stackSize <= 0) aPlayer.destroyCurrentEquippedItem();
+				return true;
+			}
+			if (aStack.stackSize <= 0) {
+				aPlayer.destroyCurrentEquippedItem();
+				return false;
+			}
+		} catch(Throwable e) {
+			if (D1) e.printStackTrace(GT_Log.err);
+		}
+    	return false;
+    }
+    
+	@Override
+	public boolean onItemUse(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide, float hitX, float hitY, float hitZ) {
+		use(aStack, 0, aPlayer);
+		isItemStackUsable(aStack);
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) try {
+			if (tBehavior.onItemUse(this, aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ)) {
+				if (aStack.stackSize <= 0) aPlayer.destroyCurrentEquippedItem();
+				return true;
+			}
+			if (aStack.stackSize <= 0) {
+				aPlayer.destroyCurrentEquippedItem();
+				return false;
+			}
+		} catch(Throwable e) {
+			if (D1) e.printStackTrace(GT_Log.err);
+		}
+    	return false;
+	}
+	
+	@Override
+	public boolean onItemUseFirst(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide, float hitX, float hitY, float hitZ) {
+		use(aStack, 0, aPlayer);
+		isItemStackUsable(aStack);
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) try {
+			if (tBehavior.onItemUseFirst(this, aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ)) {
+				if (aStack.stackSize <= 0) aPlayer.destroyCurrentEquippedItem();
+				return true;
+			}
+			if (aStack.stackSize <= 0) {
+				aPlayer.destroyCurrentEquippedItem();
+				return false;
+			}
+		} catch(Throwable e) {
+			if (D1) e.printStackTrace(GT_Log.err);
+		}
+		return false;
+	}
+	
+    @Override
+	public ItemStack onItemRightClick(ItemStack aStack, World aWorld, EntityPlayer aPlayer) {
+    	use(aStack, 0, aPlayer);
+		isItemStackUsable(aStack);
+    	ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) try {
+			aStack = tBehavior.onItemRightClick(this, aStack, aWorld, aPlayer);
+		} catch(Throwable e) {
+			if (D1) e.printStackTrace(GT_Log.err);
+		}
+		return aStack;
+    }
+    
+	@Override
+    public final void addInformation(ItemStack aStack, EntityPlayer aPlayer, List aList, boolean aF3_H) {
+		String tKey = getUnlocalizedName(aStack) + ".tooltip", tString = GT_LanguageManager.getTranslation(tKey);
+		if (GT_Utility.isStringValid(tString) && !tKey.equals(tString)) aList.add(tString);
+		
+		Long[]
+		tStats = getElectricStats(aStack);
+		if (tStats != null) {
+			if (tStats[3] > 0) {
+				aList.add(EnumChatFormatting.AQUA + "Contains " + GT_Utility.formatNumbers(tStats[3]) + " EU   Tier: " + (tStats[2]>=0?tStats[2]:0) + EnumChatFormatting.GRAY);
+			} else {
+				long tCharge = getRealCharge(aStack);
+				if (tStats[3] == -2 && tCharge <= 0) {
+					aList.add(EnumChatFormatting.AQUA + "Empty. You should recycle it properly." + EnumChatFormatting.GRAY);
+				} else {
+					aList.add(EnumChatFormatting.AQUA + "" + GT_Utility.formatNumbers(tCharge) + " / " + GT_Utility.formatNumbers(Math.abs(tStats[0])) + " EU - Voltage: " + V[(int)(tStats[2]>=0?tStats[2]<V.length?tStats[2]:V.length-1:1)] + EnumChatFormatting.GRAY);
+				}
+			}
+		}
+		
+		tStats = getFluidContainerStats(aStack);
+		if (tStats != null && tStats[0] > 0) {
+			FluidStack tFluid = getFluidContent(aStack);
+			aList.add(EnumChatFormatting.BLUE + ((tFluid==null?"No Fluids Contained":GT_Utility.getFluidName(tFluid, true))) + EnumChatFormatting.GRAY);
+			aList.add(EnumChatFormatting.BLUE + ((tFluid==null?0:tFluid.amount) + "L / " + tStats[0] + "L") + EnumChatFormatting.GRAY);
+		}
+		
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) aList = tBehavior.getAdditionalToolTips(this, aList, aStack);
+		
+		addAdditionalToolTips(aList, aStack);
+	}
+	
+	@Override
+	public void onUpdate(ItemStack aStack, World aWorld, Entity aPlayer, int aTimer, boolean aIsInHand) {
+		ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short)getDamage(aStack));
+		if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) tBehavior.onUpdate(this, aStack, aWorld, aPlayer, aTimer, aIsInHand);
+	}
+	
+	@Override
+	public final boolean canProvideEnergy(ItemStack aStack) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null) return false;
+		return tStats[3] > 0 || (aStack.stackSize == 1 && (tStats[3] == -2 || tStats[3] == -3));
+	}
+	
+	@Override
+	public final double getMaxCharge(ItemStack aStack) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null) return 0;
+		return Math.abs(tStats[0]);
+	}
+	
+	@Override
+	public final double getTransferLimit(ItemStack aStack) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null) return 0;
+		return Math.max(tStats[1], tStats[3]);
+	}
+	
+	@Override
+	public final double charge(ItemStack aStack, double aCharge, int aTier, boolean aIgnoreTransferLimit, boolean aSimulate) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null || tStats[2] > aTier || !(tStats[3] == -1 || tStats[3] == -3 || (tStats[3] < 0 && aCharge == Integer.MAX_VALUE)) || aStack.stackSize != 1) return 0;
+		long tChargeBefore = getRealCharge(aStack), tNewCharge = aCharge==Integer.MAX_VALUE?Long.MAX_VALUE:Math.min(Math.abs(tStats[0]), tChargeBefore + (aIgnoreTransferLimit?(long)aCharge:Math.min(tStats[1], (long)aCharge)));
+		if (!aSimulate) setCharge(aStack, tNewCharge);
+		return tNewCharge-tChargeBefore;
+	}
+	
+	@Override
+	public final double discharge(ItemStack aStack, double aCharge, int aTier, boolean aIgnoreTransferLimit, boolean aBatteryAlike, boolean aSimulate) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null || tStats[2] > aTier) return 0;
+		if (aBatteryAlike && !canProvideEnergy(aStack)) return 0;
+		if (tStats[3] > 0) {
+			if (aCharge < tStats[3] || aStack.stackSize < 1) return 0;
+			if (!aSimulate) aStack.stackSize--;
+			return tStats[3];
+		}
+		long tChargeBefore = getRealCharge(aStack), tNewCharge = Math.max(0, tChargeBefore - (aIgnoreTransferLimit?(long)aCharge:Math.min(tStats[1], (long)aCharge)));
+		if (!aSimulate) setCharge(aStack, tNewCharge);
+		return tChargeBefore-tNewCharge;
+	}
+	
+	@Override
+	public final double getCharge(ItemStack aStack) {
+		return getRealCharge(aStack);
+	}
+	
+	@Override
+	public final boolean canUse(ItemStack aStack, double aAmount) {
+		return getRealCharge(aStack) >= aAmount;
+	}
+	
+	@Override
+	public final boolean use(ItemStack aStack, double aAmount, EntityLivingBase aPlayer) {
+		chargeFromArmor(aStack, aPlayer);
+		if (aPlayer instanceof EntityPlayer && ((EntityPlayer)aPlayer).capabilities.isCreativeMode) return true;
+		double tTransfer = discharge(aStack, aAmount, Integer.MAX_VALUE, true, false, true);
+		if (tTransfer == aAmount) {
+			discharge(aStack, aAmount, Integer.MAX_VALUE, true, false, false);
+			chargeFromArmor(aStack, aPlayer);
+			return true;
+		}
+		discharge(aStack, aAmount, Integer.MAX_VALUE, true, false, false);
+		chargeFromArmor(aStack, aPlayer);
+		return false;
+	}
+	
+	@Override
+	public final void chargeFromArmor(ItemStack aStack, EntityLivingBase aPlayer) {
+		if (aPlayer == null || aPlayer.worldObj.isRemote) return;
+		for (int i = 1; i < 5; i++) {
+			ItemStack tArmor = aPlayer.getEquipmentInSlot(i);
+			if (GT_ModHandler.isElectricItem(tArmor)) {
+				IElectricItem tArmorItem = (IElectricItem)tArmor.getItem();
+				if (tArmorItem.canProvideEnergy(tArmor) && tArmorItem.getTier(tArmor) >= getTier(aStack)) {
+					double tCharge = ElectricItem.manager.discharge(tArmor, charge(aStack, Integer.MAX_VALUE-1, Integer.MAX_VALUE, true, true), Integer.MAX_VALUE, true, true, false);
+					if (tCharge > 0) {
+						charge(aStack, tCharge, Integer.MAX_VALUE, true, false);
+						if (aPlayer instanceof EntityPlayer) {
+							Container tContainer = ((EntityPlayer)aPlayer).openContainer;
+							if (tContainer != null) tContainer.detectAndSendChanges();
+						}
+					}
+				}
+			}
+		}
+	}
+	/*
+	
+	@Override
+	public final int getMaxCharge(ItemStack aStack) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null) return 0;
+		return (int)Math.abs(tStats[0]);
+	}
+	
+	@Override
+	public final int getTransferLimit(ItemStack aStack) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null) return 0;
+		return (int)Math.max(tStats[1], tStats[3]);
+	}
+	
+	@Override
+	public final int charge(ItemStack aStack, int aCharge, int aTier, boolean aIgnoreTransferLimit, boolean aSimulate) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null || tStats[2] > aTier || !(tStats[3] == -1 || tStats[3] == -3 || (tStats[3] < 0 && aCharge == Integer.MAX_VALUE)) || aStack.stackSize != 1) return 0;
+		long tChargeBefore = getRealCharge(aStack), tNewCharge = aCharge==Integer.MAX_VALUE?Long.MAX_VALUE:Math.min(Math.abs(tStats[0]), tChargeBefore + (aIgnoreTransferLimit?aCharge:Math.min(tStats[1], aCharge)));
+		if (!aSimulate) setCharge(aStack, tNewCharge);
+		return (int)(tNewCharge-tChargeBefore);
+	}
+	
+	@Override
+	public final int discharge(ItemStack aStack, int aCharge, int aTier, boolean aIgnoreTransferLimit, boolean aSimulate) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null || tStats[2] > aTier) return 0;
+		if (tStats[3] > 0) {
+			if (aCharge < tStats[3] || aStack.stackSize < 1) return 0;
+			if (!aSimulate) aStack.stackSize--;
+			return (int)(long)tStats[3];
+		}
+		long tChargeBefore = getRealCharge(aStack), tNewCharge = Math.max(0, tChargeBefore - (aIgnoreTransferLimit?aCharge:Math.min(tStats[1], aCharge)));
+		if (!aSimulate) setCharge(aStack, tNewCharge);
+		return (int)(tChargeBefore-tNewCharge);
+	}
+	
+	@Override
+	public final int getCharge(ItemStack aStack) {
+		return (int)Math.min(Integer.MAX_VALUE, getRealCharge(aStack));
+	}
+	
+	@Override
+	public final boolean canUse(ItemStack aStack, int aAmount) {
+		return getRealCharge(aStack) >= aAmount;
+	}
+	
+	@Override
+	public final boolean use(ItemStack aStack, int aAmount, EntityLivingBase aPlayer) {
+		chargeFromArmor(aStack, aPlayer);
+		if (aPlayer instanceof EntityPlayer && ((EntityPlayer)aPlayer).capabilities.isCreativeMode) return true;
+		int tTransfer = discharge(aStack, aAmount, Integer.MAX_VALUE, true, true);
+		if (tTransfer == aAmount) {
+			discharge(aStack, aAmount, Integer.MAX_VALUE, true, false);
+			chargeFromArmor(aStack, aPlayer);
+			return true;
+		}
+		discharge(aStack, aAmount, Integer.MAX_VALUE, true, false);
+		chargeFromArmor(aStack, aPlayer);
+		return false;
+	}
+	
+	@Override
+	public final void chargeFromArmor(ItemStack aStack, EntityLivingBase aPlayer) {
+		if (aPlayer == null || aPlayer.worldObj.isRemote) return;
+		for (int i = 1; i < 5; i++) {
+			ItemStack tArmor = aPlayer.getEquipmentInSlot(i);
+			if (GT_ModHandler.isElectricItem(tArmor)) {
+				IElectricItem tArmorItem = (IElectricItem)tArmor.getItem();
+				if (tArmorItem.canProvideEnergy(tArmor) && tArmorItem.getTier(tArmor) >= getTier(aStack)) {
+					int tCharge = ElectricItem.manager.discharge(tArmor, charge(aStack, Integer.MAX_VALUE-1, Integer.MAX_VALUE, true, true), Integer.MAX_VALUE, true, false);
+					if (tCharge > 0) {
+						charge(aStack, tCharge, Integer.MAX_VALUE, true, false);
+						if (aPlayer instanceof EntityPlayer) {
+							Container tContainer = ((EntityPlayer)aPlayer).openContainer;
+							if (tContainer != null) tContainer.detectAndSendChanges();
+						}
+					}
+				}
+			}
+		}
+	}
+	*/
+	public final long getRealCharge(ItemStack aStack) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null) return 0;
+		if (tStats[3] > 0) return (int)(long)tStats[3];
+		NBTTagCompound tNBT = aStack.getTagCompound();
+		return tNBT==null?0:tNBT.getLong("GT.ItemCharge");
+	}
+	
+	public final boolean setCharge(ItemStack aStack, long aCharge) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats == null || tStats[3] > 0) return false;
+		NBTTagCompound tNBT = aStack.getTagCompound();
+		if (tNBT == null) tNBT = new NBTTagCompound();
+		tNBT.removeTag("GT.ItemCharge");
+		aCharge = Math.min(tStats[0]<0?Math.abs(tStats[0] / 2):aCharge, Math.abs(tStats[0]));
+		if (aCharge > 0) {
+			aStack.setItemDamage(getChargedMetaData(aStack));
+			tNBT.setLong("GT.ItemCharge", aCharge);
+		} else {
+			aStack.setItemDamage(getEmptyMetaData(aStack));
+		}
+		if (tNBT.hasNoTags()) aStack.setTagCompound(null); else aStack.setTagCompound(tNBT);
+		isItemStackUsable(aStack);
+		return true;
+	}
+	
+	public short getChargedMetaData(ItemStack aStack) {return (short)aStack.getItemDamage();}
+	public short getEmptyMetaData(ItemStack aStack) {return (short)aStack.getItemDamage();}
+	
+	@Override
+	public FluidStack getFluid(ItemStack aStack) {
+		return getFluidContent(aStack);
+	}
+	
+	@Override
+	public int getCapacity(ItemStack aStack) {
+		Long[] tStats = getFluidContainerStats(aStack);
+		return tStats==null?0:(int)Math.max(0, tStats[0]);
+	}
+	
+	@Override
+	public int fill(ItemStack aStack, FluidStack aFluid, boolean doFill) {
+		if (aStack == null || aStack.stackSize != 1) return 0;
+		
+		ItemStack tStack = GT_Utility.fillFluidContainer(aFluid, aStack, false, false);
+		if (tStack != null) {
+			aStack.setItemDamage(tStack.getItemDamage());
+			aStack.func_150996_a(tStack.getItem());
+			return GT_Utility.getFluidForFilledItem(tStack, false).amount;
+		}
+		
+		Long[] tStats = getFluidContainerStats(aStack);
+		if (tStats == null || tStats[0] <= 0 || aFluid == null || aFluid.getFluid().getID() <= 0 || aFluid.amount <= 0) return 0;
+		
+		FluidStack tFluid = getFluidContent(aStack);
+		
+		if (tFluid == null || tFluid.getFluid().getID() <= 0) {
+			if (aFluid.amount <= tStats[0]) {
+				if (doFill) {
+					setFluidContent(aStack, aFluid);
+				}
+				return aFluid.amount;
+			}
+			if (doFill) {
+				tFluid = aFluid.copy();
+				tFluid.amount = (int)(long)tStats[0];
+				setFluidContent(aStack, tFluid);
+			}
+			return (int)(long)tStats[0];
+		}
+		
+		if (!tFluid.isFluidEqual(aFluid)) return 0;
+		
+		int space = (int)(long)tStats[0] - tFluid.amount;
+		if (aFluid.amount <= space) {
+			if (doFill) {
+				tFluid.amount += aFluid.amount;
+				setFluidContent(aStack, tFluid);
+			}
+			return aFluid.amount;
+		}
+		if (doFill) {
+			tFluid.amount = (int)(long)tStats[0];
+			setFluidContent(aStack, tFluid);
+		}
+		return space;
+	}
+	
+	@Override
+	public FluidStack drain(ItemStack aStack, int maxDrain, boolean doDrain) {
+		if (aStack == null || aStack.stackSize != 1) return null;
+		
+		FluidStack tFluid = GT_Utility.getFluidForFilledItem(aStack, false);
+		if (tFluid != null && maxDrain >= tFluid.amount) {
+			ItemStack tStack = GT_Utility.getContainerItem(aStack, false);
+			if (tStack == null) {
+				aStack.stackSize = 0;
+				return tFluid;
+			}
+			aStack.setItemDamage(tStack.getItemDamage());
+			aStack.func_150996_a(tStack.getItem());
+			return tFluid;
+		}
+		
+		Long[] tStats = getFluidContainerStats(aStack);
+		if (tStats == null || tStats[0] <= 0) return null;
+		
+		tFluid = getFluidContent(aStack);
+		if (tFluid == null) return null;
+		
+		int used = maxDrain;
+		if (tFluid.amount < used) used = tFluid.amount;
+		if (doDrain) {
+			tFluid.amount -= used;
+			setFluidContent(aStack, tFluid);
+		}
+		
+		FluidStack drained = tFluid.copy();
+		drained.amount = used;
+		return drained;
+	}
+	
+	public FluidStack getFluidContent(ItemStack aStack) {
+		Long[] tStats = getFluidContainerStats(aStack);
+		if (tStats == null || tStats[0] <= 0) return GT_Utility.getFluidForFilledItem(aStack, false);
+		NBTTagCompound tNBT = aStack.getTagCompound();
+		return tNBT==null?null:FluidStack.loadFluidStackFromNBT(tNBT.getCompoundTag("GT.FluidContent"));
+	}
+	
+	public void setFluidContent(ItemStack aStack, FluidStack aFluid) {
+		NBTTagCompound tNBT = aStack.getTagCompound();
+		if (tNBT == null) tNBT = new NBTTagCompound(); else tNBT.removeTag("GT.FluidContent");
+		if (aFluid != null && aFluid.amount > 0) tNBT.setTag("GT.FluidContent", aFluid.writeToNBT(new NBTTagCompound()));
+		if (tNBT.hasNoTags()) aStack.setTagCompound(null); else aStack.setTagCompound(tNBT);
+		isItemStackUsable(aStack);
+	}
+	
+	@Override
+	public int getItemStackLimit(ItemStack aStack) {
+		Long[] tStats = getElectricStats(aStack);
+		if (tStats != null && (tStats[3] == -1 || tStats[3] == -3) && getRealCharge(aStack) > 0) return 1;
+		tStats = getFluidContainerStats(aStack);
+		if (tStats != null) return (int)(long)tStats[1];
+		return 64;
+	}
+	
+	@Override public final Item getChargedItem(ItemStack itemStack) {return this;}
+	@Override public final Item getEmptyItem(ItemStack itemStack) {return this;}
+    @Override public final int getTier(ItemStack aStack) {Long[] tStats = getElectricStats(aStack); return (int)(tStats==null?Integer.MAX_VALUE:tStats[2]);}
+	@Override public final String getToolTip(ItemStack aStack) {return null;} // This has its own ToolTip Handler, no need to let the IC2 Handler screw us up at this Point
+	@Override public final IElectricItemManager getManager(ItemStack aStack) {return this;} // We are our own Manager
+	@Override public final boolean getShareTag() {return true;} // just to be sure.
+	@Override public int getItemEnchantability() {return 0;}
+	@Override public boolean isBookEnchantable(ItemStack aStack, ItemStack aBook) {return false;}
+	@Override public boolean getIsRepairable(ItemStack aStack, ItemStack aMaterial) {return false;}
+}
\ No newline at end of file