diff options
Diffstat (limited to 'src/main/java/common/tileentities/TE_TFFTMultiHatch.java')
| -rw-r--r-- | src/main/java/common/tileentities/TE_TFFTMultiHatch.java | 219 |
1 files changed, 219 insertions, 0 deletions
diff --git a/src/main/java/common/tileentities/TE_TFFTMultiHatch.java b/src/main/java/common/tileentities/TE_TFFTMultiHatch.java new file mode 100644 index 0000000000..837898ab61 --- /dev/null +++ b/src/main/java/common/tileentities/TE_TFFTMultiHatch.java @@ -0,0 +1,219 @@ +package common.tileentities; + +import java.util.Iterator; +import java.util.List; + +import common.blocks.Block_TFFTStorageFieldBlockT1; +import common.blocks.Block_TFFTStorageFieldBlockT2; +import common.blocks.Block_TFFTStorageFieldBlockT3; +import common.blocks.Block_TFFTStorageFieldBlockT4; +import common.blocks.Block_TFFTStorageFieldBlockT5; +import kekztech.MultiFluidHandler; +import net.minecraft.block.Block; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; + +public class TE_TFFTMultiHatch extends TileEntity implements IFluidHandler { + + private static final int OUTPUT_PER_SECOND = 1000; // L/s + + private MultiFluidHandler mfh; + private int tickCounter = 0; + private boolean autoOutput = false; + + public void setMultiFluidHandler(MultiFluidHandler mfh) { + System.out.println("Set MFH"); + this.mfh = mfh; + } + + public void toggleAutoOutput() { + autoOutput = autoOutput ? false : true; + } + + @Override + public void updateEntity() { + if(!autoOutput || mfh == null) { + return; + } + + tickCounter++; + if(tickCounter >= 20) { + + final ForgeDirection d = getOutwardsFacingDirection(); + if(d == ForgeDirection.UNKNOWN) { + return; + } + final TileEntity t = this.getWorldObj().getTileEntity( + this.xCoord + d.offsetX, + this.yCoord + d.offsetY, + this.zCoord + d.offsetZ); + + if(t != null && t instanceof IFluidHandler) { + + final IFluidHandler fh = (IFluidHandler) t; + + // Cycle through fluids + final Iterator<FluidStack> volumes = mfh.getFluids().iterator(); + while(volumes.hasNext()) { + final FluidStack volume = volumes.next(); + + // Remember for later + final int oVolume = volume.amount; + + // Use API methods + if(fh.canFill(d.getOpposite(), volume.getFluid())) { + + // Test how much can be output + final FluidStack copy = volume.copy(); + copy.amount = Math.min(copy.amount, OUTPUT_PER_SECOND); + + final int drawn = mfh.pullFluid(copy, false); + copy.amount = drawn; + + // Test how much can be filled (and fill if possible) + copy.amount = fh.fill(d.getOpposite(), copy, true); + + // Actually deplete storage + mfh.pullFluid(copy, true); + + // Prevent ConcurrentModificationException + if(copy.amount >= oVolume) { + break; + } + } + } + } + + tickCounter = 0; + } + } + + private ForgeDirection getOutwardsFacingDirection() { + // TODO Revisit this once the hatch has a facing side + // Look up which side has the storage field block and choose the other side. + // This is important so the tank doesn't output into itself in case + // there is another hatch next to this one. + for(ForgeDirection direction : ForgeDirection.values()) { + + final Block b = this.getWorldObj().getBlock(this.xCoord + direction.offsetX, this.yCoord + direction.offsetY, this.zCoord + direction.offsetZ); + if(b != null && ( + b.equals(Block_TFFTStorageFieldBlockT1.getInstance()) + || b.equals(Block_TFFTStorageFieldBlockT2.getInstance()) + || b.equals(Block_TFFTStorageFieldBlockT3.getInstance()) + || b.equals(Block_TFFTStorageFieldBlockT4.getInstance()) + || b.equals(Block_TFFTStorageFieldBlockT5.getInstance()))) { + return direction.getOpposite(); + } + } + return ForgeDirection.UNKNOWN; + } + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + return (mfh != null) ? mfh.pushFluid(resource, doFill) : 0; + } + + @Override + public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) { + return (mfh != null) ? new FluidStack(resource.getFluid(), mfh.pullFluid(resource, doDrain)) : null; + } + + /** + * Drains fluid out of 0th internal tank. + * If the TFFT Controller contains an Integrated Circuit, drain fluid + * from the slot equal to the circuit configuration. + * + * @param from + * Orientation the fluid is drained to. + * @param maxDrain + * Maximum amount of fluid to drain. + * @param doDrain + * If false, drain will only be simulated. + * @return FluidStack representing the Fluid and amount that was (or would have been, if + * simulated) drained. + */ + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + if(mfh != null) { + final FluidStack drain = mfh.getFluid(0); + if(drain != null) { + // If there's no integrated circuit in the TFFT controller, output slot 0 + final byte selectedSlot = (mfh.getSelectedFluid() == -1) ? 0 : mfh.getSelectedFluid(); + + return new FluidStack( + drain.getFluid(), + mfh.pullFluid(new FluidStack(drain.getFluid(), maxDrain), selectedSlot, doDrain) + ); + } + } + return null; + } + + @Override + public boolean canFill(ForgeDirection from, Fluid fluid) { + return (mfh != null) ? mfh.couldPush(new FluidStack(fluid, 1)) : false; + } + + @Override + public boolean canDrain(ForgeDirection from, Fluid fluid) { + return (mfh != null) ? mfh.contains(new FluidStack(fluid, 1)) : false; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection from) { + if(mfh == null) { + return null; + } + final List<FluidStack> fluids = mfh.getFluids(); + final FluidTankInfo[] tankInfo = new FluidTankInfo[fluids.size()]; + for(int i = 0; i < tankInfo.length; i++) { + tankInfo[i] = new FluidTankInfo(fluids.get(i), mfh.getCapacity()); + } + return tankInfo; + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + nbt = (nbt == null) ? new NBTTagCompound() : nbt; + + super.writeToNBT(nbt); + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + nbt = (nbt == null) ? new NBTTagCompound() : nbt; + + super.readFromNBT(nbt); + } + + + + + + + + + + + + + + + + + + + + + + + + + + +} |