@Override
public void readFromByteBuff(ByteBuf buf) {
super.readFromByteBuff(buf);
fill = buf.readBoolean();
tank.readFromByteBuff(buf);
inventory.readFromByteBuff(buf);
}
@Override
public void writeToNBT(NBTTagCompound nbtTagCompound) {
super.writeToNBT(nbtTagCompound);
nbtTagCompound.setBoolean("fill", fill);
inventory.writeToNBT(nbtTagCompound);
nbtTagCompound.setTag("tank", tank.writeToNBT(new NBTTagCompound()));
}
@Override
public void writeToByteBuff(ByteBuf buf) {
super.writeToByteBuff(buf);
buf.writeBoolean(fill);
tank.writeToByteBuff(buf);
inventory.writeToByteBuff(buf);
}
@Override
public void readFromNBT(NBTTagCompound nbtTagCompound) {
super.readFromNBT(nbtTagCompound);
fill = nbtTagCompound.getBoolean("fill");
inventory.readFromNBT(nbtTagCompound);
if (nbtTagCompound.hasKey("tank", Constants.NBT.TAG_COMPOUND))
tank.readFromNBT(nbtTagCompound.getCompoundTag("tank"));
}
public int getProgress() {
ItemStack stack = inventory.getStackInSlot(0);
if (stack == null) return 0;
Item item = stack.getItem();
FluidStack fluidstack = null;
int capacity = 0;
if (item instanceof IFluidContainerItem) {
IFluidContainerItem iFluidContainerItem = (IFluidContainerItem) stack.getItem();
fluidstack = iFluidContainerItem.getFluid(stack);
capacity = iFluidContainerItem.getCapacity(stack);
} else if (FluidContainerRegistry.isContainer(stack)) {
fluidstack = FluidContainerRegistry.getFluidForFilledItem(stack);
capacity =
FluidContainerRegistry.getContainerCapacity(fill ? tank.getFluid() : fluidstack, stack);
}
if (fluidstack == null || capacity <= 0) {
if (fill) return 0;
return 16;
}
if (fill) return (int) ((fluidstack.amount * 16D) / capacity);
return (int) (((capacity - fluidstack.amount) * 16D) / capacity);
}
@Override
public void updateEntity() {
super.updateEntity();
if (worldObj.isRemote) return;
ItemStack stack = inventory.getStackInSlot(0);
if (stack != null) {
Item stackItem = stack.getItem();
if (stackItem instanceof IFluidContainerItem) {
IFluidContainerItem iFluidContainerItem = (IFluidContainerItem) stackItem;
if (fill) {
if (!tank.isEmpty()) {
int amount = 128;
if (tank.getFluidAmount() < amount) amount = tank.getFluidAmount();
if (energy >= amount) {
drain(
ForgeDirection.UNKNOWN,
iFluidContainerItem.fill(stack, new FluidStack(tank.getFluid(), amount), true),
true);
energy -= amount;
}
}
} else {
FluidStack contained = iFluidContainerItem.getFluid(stack);
if (!fill && !tank.isFull() && contained != null && contained.amount > 0) {
int amount = 64;
if (tank.getFreeSpace() < amount) amount = tank.getFreeSpace();
if (amount > contained.amount) amount = contained.amount;
iFluidContainerItem.drain(
stack, fill(ForgeDirection.UNKNOWN, new FluidStack(contained, amount), true), true);
}
}
} else if (FluidContainerRegistry.isContainer(stack)) {
if (fill) {
if (!tank.isEmpty()) {
int amount = FluidContainerRegistry.getContainerCapacity(tank.getFluid(), stack);
if (amount > 0 && energy >= amount && tank.getFluidAmount() >= amount) {
ItemStack filledContainer =
FluidContainerRegistry.fillFluidContainer(
new FluidStack(tank.getFluid(), amount), stack);
if (filledContainer != null
&& filledContainer.getItem() != null
&& filledContainer.stackSize > 0) {
energy -= amount;
drain(ForgeDirection.UNKNOWN, amount, true);
inventory.setInventorySlotContents(0, filledContainer.copy());
}
}
}
} else {
FluidStack contained = FluidContainerRegistry.getFluidForFilledItem(stack);
if (contained != null
&& contained.amount > 0
&& tank.getFreeSpace() >= contained.amount) {
if (fill(ForgeDirection.UNKNOWN, contained, false) == contained.amount) {
fill(ForgeDirection.UNKNOWN, contained, true);
ItemStack drainedContainer = FluidContainerRegistry.drainFluidContainer(stack);
if (drainedContainer != null
&& drainedContainer.getItem() != null
&& drainedContainer.stackSize > 0)
inventory.setInventorySlotContents(0, drainedContainer.copy());
}
}
}
}
if (getProgress() >= 16) {
stack = getStackInSlot(0);
if (stack != null) {
ItemStack outputStack = getStackInSlot(1);
if (outputStack == null || outputStack.getItem() == null || outputStack.stackSize <= 0) {
ItemStack copyStack = stack.copy();
copyStack.stackSize = 1;
inventory.setInventorySlotContents(1, copyStack);
inventory.decrStackSize(0, 1);
}
}
}
}
}
@Override
public void closeInventory() {
inventory.openInventory();
}
@Override
public int getInventoryStackLimit() {
return inventory.getInventoryStackLimit();
}
@Override
public boolean hasCustomInventoryName() {
return inventory.hasCustomInventoryName();
}
@Override
public String getInventoryName() {
return inventory.getInventoryName();
}
@Override
public void setInventorySlotContents(int slotId, ItemStack itemstack) {
inventory.setInventorySlotContents(slotId, itemstack);
}
@Override
public ItemStack getStackInSlotOnClosing(int var1) {
return inventory.getStackInSlotOnClosing(var1);
}
@Override
public ItemStack decrStackSize(int slotId, int count) {
return inventory.decrStackSize(slotId, count);
}
@Override
public ItemStack getStackInSlot(int slotId) {
return inventory.getStackInSlot(slotId);
}
@Override
public int getSizeInventory() {
return inventory.getSizeInventory();
}