@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);
}
}
}
}
}
public FluidStack getFluid() {
return tank.getFluid();
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid) {
return tank.getFluidType() == fluid;
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
return tank.drain(maxDrain, doDrain);
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
return tank.drain(resource, doDrain);
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
return tank.fill(resource, doFill);
}
