555 lines
22 KiB
Java
555 lines
22 KiB
Java
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;}
|
|
} |