PipeFluidsWood.java

/**
 * Copyright (c) 2011-2015, SpaceToad and the BuildCraft Team
 * http://www.mod-buildcraft.com
 * <p/>
 * BuildCraft is distributed under the terms of the Minecraft Mod Public
 * License 1.0, or MMPL. Please check the contents of the license located in
 * http://www.mod-buildcraft.com/MMPL-1.0.txt
 */
package buildcraft.transport.pipes;

import io.netty.buffer.ByteBuf;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.tileentity.TileEntity;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;

import cofh.api.energy.IEnergyHandler;
import buildcraft.BuildCraftTransport;
import buildcraft.api.core.IIconProvider;
import buildcraft.api.core.ISerializable;
import buildcraft.api.transport.IPipeTile;
import buildcraft.transport.Pipe;
import buildcraft.transport.PipeIconProvider;
import buildcraft.transport.PipeTransportFluids;

public class PipeFluidsWood extends Pipe<PipeTransportFluids> implements IEnergyHandler, ISerializable {
	public int liquidToExtract;

	protected int standardIconIndex = PipeIconProvider.TYPE.PipeFluidsWood_Standard.ordinal();
	protected int solidIconIndex = PipeIconProvider.TYPE.PipeAllWood_Solid.ordinal();

	private PipeLogicWood logic = new PipeLogicWood(this) {
		@Override
		protected boolean isValidConnectingTile(TileEntity tile) {
			if (tile instanceof IPipeTile) {
				return false;
			}
			if (!(tile instanceof IFluidHandler)) {
				return false;
			}

			return true;
		}
	};

	public PipeFluidsWood(Item item) {
		super(new PipeTransportFluids(), item);

		transport.initFromPipe(getClass());
	}

	@Override
	public boolean blockActivated(EntityPlayer entityplayer, ForgeDirection side) {
		return logic.blockActivated(entityplayer, side);
	}

	@Override
	public void onNeighborBlockChange(int blockId) {
		logic.onNeighborBlockChange();
		super.onNeighborBlockChange(blockId);
	}

	@Override
	public void initialize() {
		logic.initialize();
		super.initialize();
	}

	private TileEntity getConnectingTile() {
		int meta = container.getBlockMetadata();
		return meta >= 6 ? null : container.getTile(ForgeDirection.getOrientation(meta));
	}

	@Override
	public void updateEntity() {
		super.updateEntity();

		if (liquidToExtract <= 0) {
			return;
		}

		TileEntity tile = getConnectingTile();

		if (tile == null || !(tile instanceof IFluidHandler)) {
			liquidToExtract = 0;
		} else {
			extractFluid((IFluidHandler) tile, ForgeDirection.getOrientation(container.getBlockMetadata()));

			// We always subtract the flowRate to ensure that the buffer goes down reasonably quickly.
			liquidToExtract -= transport.getFlowRate();

			if (liquidToExtract < 0) {
				liquidToExtract = 0;
			}
		}
	}

	public int extractFluid(IFluidHandler fluidHandler, ForgeDirection side) {
		int amount = liquidToExtract > transport.getFlowRate() ? transport.getFlowRate() : liquidToExtract;
		FluidTankInfo tankInfo = transport.getTankInfo(side)[0];
		FluidStack extracted;

		if (tankInfo.fluid != null) {
			extracted = fluidHandler.drain(side.getOpposite(), new FluidStack(tankInfo.fluid, amount), false);
		} else {
			extracted = fluidHandler.drain(side.getOpposite(), amount, false);
		}

		int inserted = 0;

		if (extracted != null) {
			inserted = transport.fill(side, extracted, true);
			if (inserted > 0) {
				extracted.amount = inserted;
				fluidHandler.drain(side.getOpposite(), extracted, true);
			}
		}

		return inserted;
	}

	protected int getEnergyMultiplier() {
		return 5 * BuildCraftTransport.pipeFluidsBaseFlowRate;
	}

	protected int getMaxExtractionFluid() {
		return 100 * BuildCraftTransport.pipeFluidsBaseFlowRate;
	}

	@Override
	@SideOnly(Side.CLIENT)
	public IIconProvider getIconProvider() {
		return BuildCraftTransport.instance.pipeIconProvider;
	}

	@Override
	public int getIconIndex(ForgeDirection direction) {
		if (direction == ForgeDirection.UNKNOWN) {
			return standardIconIndex;
		} else {
			int metadata = container.getBlockMetadata();

			if (metadata == direction.ordinal()) {
				return solidIconIndex;
			} else {
				return standardIconIndex;
			}
		}
	}

	@Override
	public boolean outputOpen(ForgeDirection to) {
		int meta = container.getBlockMetadata();
		return super.outputOpen(to) && meta != to.ordinal();
	}

	@Override
	public boolean canConnectEnergy(ForgeDirection from) {
		return true;
	}

	@Override
	public int receiveEnergy(ForgeDirection from, int maxReceive,
							 boolean simulate) {
		TileEntity tile = getConnectingTile();
		if (tile == null || !(tile instanceof IFluidHandler)) {
			return 0;
		}

		int maxToReceive = (getMaxExtractionFluid() - liquidToExtract) / getEnergyMultiplier();
		int received = Math.min(maxReceive, maxToReceive);
		if (!simulate) {
			liquidToExtract += getEnergyMultiplier() * received;
		}
		return received;
	}

	@Override
	public int extractEnergy(ForgeDirection from, int maxExtract,
							 boolean simulate) {
		return 0;
	}

	@Override
	public int getEnergyStored(ForgeDirection from) {
		return 0;
	}

	@Override
	public int getMaxEnergyStored(ForgeDirection from) {
		return 1000 / getEnergyMultiplier();
	}

	@Override
	public void writeData(ByteBuf data) {
		data.writeShort(liquidToExtract);
	}

	@Override
	public void readData(ByteBuf data) {
		liquidToExtract = data.readShort();
	}
}