mirror of
https://github.com/Thorfusion/Mekanism-Community-Edition.git
synced 2026-11-22 04:52:25 +00:00
742 lines
17 KiB
Java
742 lines
17 KiB
Java
package mekanism.common.tile;
|
|
|
|
import io.netty.buffer.ByteBuf;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashSet;
|
|
import java.util.Set;
|
|
|
|
import mekanism.api.Coord4D;
|
|
import mekanism.api.IEvaporationSolar;
|
|
import mekanism.api.Range4D;
|
|
import mekanism.client.SparkleAnimation.INodeChecker;
|
|
import mekanism.common.Mekanism;
|
|
import mekanism.common.PacketHandler;
|
|
import mekanism.common.base.IActiveState;
|
|
import mekanism.common.base.ITankManager;
|
|
import mekanism.common.capabilities.Capabilities;
|
|
import mekanism.common.config.MekanismConfig.general;
|
|
import mekanism.common.content.tank.TankUpdateProtocol;
|
|
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
|
|
import mekanism.common.recipe.RecipeHandler;
|
|
import mekanism.common.recipe.RecipeHandler.Recipe;
|
|
import mekanism.common.recipe.inputs.FluidInput;
|
|
import mekanism.common.recipe.machines.ThermalEvaporationRecipe;
|
|
import mekanism.common.util.CapabilityUtils;
|
|
import mekanism.common.util.FluidContainerUtils;
|
|
import mekanism.common.util.FluidContainerUtils.FluidChecker;
|
|
import mekanism.common.util.MekanismUtils;
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.NonNullList;
|
|
import net.minecraft.util.math.AxisAlignedBB;
|
|
import net.minecraftforge.fluids.Fluid;
|
|
import net.minecraftforge.fluids.FluidRegistry;
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
import net.minecraftforge.fluids.FluidTank;
|
|
import net.minecraftforge.fml.common.FMLCommonHandler;
|
|
import net.minecraftforge.fml.relauncher.Side;
|
|
import net.minecraftforge.fml.relauncher.SideOnly;
|
|
|
|
public class TileEntityThermalEvaporationController extends TileEntityThermalEvaporationBlock implements IActiveState, ITankManager
|
|
{
|
|
public static final int MAX_OUTPUT = 10000;
|
|
public static final int MAX_SOLARS = 4;
|
|
public static final int MAX_HEIGHT = 18;
|
|
|
|
public FluidTank inputTank = new FluidTank(0);
|
|
public FluidTank outputTank = new FluidTank(MAX_OUTPUT);
|
|
|
|
public Set<Coord4D> tankParts = new HashSet<Coord4D>();
|
|
public IEvaporationSolar[] solars = new IEvaporationSolar[4];
|
|
|
|
public boolean temperatureSet = false;
|
|
|
|
public double partialInput = 0;
|
|
public double partialOutput = 0;
|
|
|
|
public float biomeTemp = 0;
|
|
public float temperature = 0;
|
|
public float heatToAbsorb = 0;
|
|
|
|
public float lastGain = 0;
|
|
|
|
public int height = 0;
|
|
|
|
public boolean structured = false;
|
|
public boolean controllerConflict = false;
|
|
public boolean isLeftOnFace;
|
|
public int renderY;
|
|
|
|
public boolean updatedThisTick = false;
|
|
|
|
public int clientSolarAmount;
|
|
public boolean clientStructured;
|
|
|
|
public boolean cacheStructure = false;
|
|
|
|
public float prevScale;
|
|
|
|
public float totalLoss = 0;
|
|
|
|
public TileEntityThermalEvaporationController()
|
|
{
|
|
super("ThermalEvaporationController");
|
|
|
|
inventory = NonNullList.withSize(4, ItemStack.EMPTY);
|
|
}
|
|
|
|
@Override
|
|
public void onUpdate()
|
|
{
|
|
super.onUpdate();
|
|
|
|
if(!world.isRemote)
|
|
{
|
|
updatedThisTick = false;
|
|
|
|
if(ticker == 5)
|
|
{
|
|
refresh();
|
|
}
|
|
|
|
if(structured)
|
|
{
|
|
updateTemperature();
|
|
}
|
|
|
|
manageBuckets();
|
|
|
|
ThermalEvaporationRecipe recipe = getRecipe();
|
|
|
|
if(canOperate(recipe))
|
|
{
|
|
int outputNeeded = outputTank.getCapacity()-outputTank.getFluidAmount();
|
|
int inputStored = inputTank.getFluidAmount();
|
|
double outputRatio = (double)recipe.recipeOutput.output.amount/(double)recipe.recipeInput.ingredient.amount;
|
|
|
|
double tempMult = Math.max(0, getTemperature())*general.evaporationTempMultiplier;
|
|
double inputToUse = (tempMult*recipe.recipeInput.ingredient.amount)*((float)height/(float)MAX_HEIGHT);
|
|
inputToUse = Math.min(inputTank.getFluidAmount(), inputToUse);
|
|
inputToUse = Math.min(inputToUse, outputNeeded/outputRatio);
|
|
|
|
lastGain = (float)inputToUse/(float)recipe.recipeInput.ingredient.amount;
|
|
partialInput += inputToUse;
|
|
|
|
if(partialInput >= 1)
|
|
{
|
|
int inputInt = (int)Math.floor(partialInput);
|
|
inputTank.drain(inputInt, true);
|
|
partialInput %= 1;
|
|
partialOutput += ((double)inputInt)/recipe.recipeInput.ingredient.amount;
|
|
}
|
|
|
|
if(partialOutput >= 1)
|
|
{
|
|
int outputInt = (int)Math.floor(partialOutput);
|
|
outputTank.fill(new FluidStack(recipe.recipeOutput.output.getFluid(), outputInt), true);
|
|
partialOutput %= 1;
|
|
}
|
|
}
|
|
else {
|
|
lastGain = 0;
|
|
}
|
|
|
|
if(structured)
|
|
{
|
|
if(Math.abs((float)inputTank.getFluidAmount()/inputTank.getCapacity()-prevScale) > 0.01)
|
|
{
|
|
Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList<Object>())), new Range4D(Coord4D.get(this)));
|
|
prevScale = (float)inputTank.getFluidAmount()/inputTank.getCapacity();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public ThermalEvaporationRecipe getRecipe()
|
|
{
|
|
return RecipeHandler.getThermalEvaporationRecipe(new FluidInput(inputTank.getFluid()));
|
|
}
|
|
|
|
@Override
|
|
public void onChunkUnload()
|
|
{
|
|
super.onChunkUnload();
|
|
|
|
refresh();
|
|
}
|
|
|
|
@Override
|
|
public void onNeighborChange(Block block)
|
|
{
|
|
super.onNeighborChange(block);
|
|
|
|
refresh();
|
|
}
|
|
|
|
public boolean hasRecipe(Fluid fluid)
|
|
{
|
|
if(fluid == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return Recipe.THERMAL_EVAPORATION_PLANT.containsRecipe(fluid);
|
|
}
|
|
|
|
protected void refresh()
|
|
{
|
|
if(!world.isRemote)
|
|
{
|
|
if(!updatedThisTick)
|
|
{
|
|
clearStructure();
|
|
structured = buildStructure();
|
|
|
|
if(structured != clientStructured)
|
|
{
|
|
Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(this)));
|
|
clientStructured = structured;
|
|
}
|
|
|
|
if(structured)
|
|
{
|
|
inputTank.setCapacity(getMaxFluid());
|
|
|
|
if(inputTank.getFluid() != null)
|
|
{
|
|
inputTank.getFluid().amount = Math.min(inputTank.getFluid().amount, getMaxFluid());
|
|
}
|
|
}
|
|
else {
|
|
clearStructure();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean canOperate(ThermalEvaporationRecipe recipe)
|
|
{
|
|
if(!structured || height < 3 || height > MAX_HEIGHT || inputTank.getFluid() == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return recipe != null && recipe.canOperate(inputTank, outputTank);
|
|
|
|
}
|
|
|
|
private void manageBuckets()
|
|
{
|
|
if(outputTank.getFluid() != null)
|
|
{
|
|
if(FluidContainerUtils.isFluidContainer(inventory.get(2)))
|
|
{
|
|
FluidContainerUtils.handleContainerItemFill(this, outputTank, 2, 3);
|
|
}
|
|
}
|
|
|
|
if(structured)
|
|
{
|
|
if(FluidContainerUtils.isFluidContainer(inventory.get(0)))
|
|
{
|
|
FluidContainerUtils.handleContainerItemEmpty(this, inputTank, 0, 1, new FluidChecker() {
|
|
@Override
|
|
public boolean isValid(Fluid f)
|
|
{
|
|
return hasRecipe(f);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateTemperature()
|
|
{
|
|
if(!temperatureSet)
|
|
{
|
|
biomeTemp = world.getBiomeForCoordsBody(getPos()).getFloatTemperature(getPos());
|
|
temperatureSet = true;
|
|
}
|
|
|
|
heatToAbsorb += getActiveSolars()*general.evaporationSolarMultiplier;
|
|
temperature += heatToAbsorb/(float)height;
|
|
|
|
float biome = biomeTemp-0.5F;
|
|
float base = biome > 0 ? biome*20 : biomeTemp*40;
|
|
|
|
if(Math.abs(temperature-base) < 0.001)
|
|
{
|
|
temperature = base;
|
|
}
|
|
|
|
float incr = (float)Math.sqrt(Math.abs(temperature-base))*(float)general.evaporationHeatDissipation;
|
|
|
|
if(temperature > base)
|
|
{
|
|
incr = -incr;
|
|
}
|
|
|
|
float prev = temperature;
|
|
temperature = (float)Math.min(general.evaporationMaxTemp, temperature + incr/(float)height);
|
|
|
|
if(incr < 0)
|
|
{
|
|
totalLoss = prev-temperature;
|
|
}
|
|
else {
|
|
totalLoss = 0;
|
|
}
|
|
|
|
heatToAbsorb = 0;
|
|
|
|
MekanismUtils.saveChunk(this);
|
|
}
|
|
|
|
public float getTemperature()
|
|
{
|
|
return temperature;
|
|
}
|
|
|
|
public int getActiveSolars()
|
|
{
|
|
if(world.isRemote)
|
|
{
|
|
return clientSolarAmount;
|
|
}
|
|
|
|
int ret = 0;
|
|
|
|
for(IEvaporationSolar solar : solars)
|
|
{
|
|
if(solar != null && solar.seesSun())
|
|
{
|
|
ret++;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
public boolean buildStructure()
|
|
{
|
|
EnumFacing right = MekanismUtils.getRight(facing);
|
|
EnumFacing left = MekanismUtils.getLeft(facing);
|
|
|
|
height = 0;
|
|
controllerConflict = false;
|
|
updatedThisTick = true;
|
|
|
|
Coord4D startPoint = Coord4D.get(this);
|
|
|
|
while(startPoint.offset(EnumFacing.UP).getTileEntity(world) instanceof TileEntityThermalEvaporationBlock)
|
|
{
|
|
startPoint = startPoint.offset(EnumFacing.UP);
|
|
}
|
|
|
|
Coord4D test = startPoint.offset(EnumFacing.DOWN).offset(right, 2);
|
|
isLeftOnFace = test.getTileEntity(world) instanceof TileEntityThermalEvaporationBlock;
|
|
|
|
startPoint = startPoint.offset(left, isLeftOnFace ? 1 : 2);
|
|
|
|
if(!scanTopLayer(startPoint))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
height = 1;
|
|
|
|
Coord4D middlePointer = startPoint.offset(EnumFacing.DOWN);
|
|
|
|
while(scanLowerLayer(middlePointer))
|
|
{
|
|
middlePointer = middlePointer.offset(EnumFacing.DOWN);
|
|
}
|
|
|
|
renderY = middlePointer.yCoord+1;
|
|
|
|
if(height < 3 || height > MAX_HEIGHT)
|
|
{
|
|
height = 0;
|
|
return false;
|
|
}
|
|
|
|
structured = true;
|
|
|
|
markDirty();
|
|
|
|
return true;
|
|
}
|
|
|
|
public boolean scanTopLayer(Coord4D current)
|
|
{
|
|
EnumFacing right = MekanismUtils.getRight(facing);
|
|
EnumFacing back = MekanismUtils.getBack(facing);
|
|
|
|
for(int x = 0; x < 4; x++)
|
|
{
|
|
for(int z = 0; z < 4; z++)
|
|
{
|
|
Coord4D pointer = current.offset(right, x).offset(back, z);
|
|
TileEntity pointerTile = pointer.getTileEntity(world);
|
|
|
|
int corner = getCorner(x, z);
|
|
|
|
if(corner != -1)
|
|
{
|
|
if(addSolarPanel(pointer.getTileEntity(world), corner))
|
|
{
|
|
continue;
|
|
}
|
|
else if(pointer.offset(EnumFacing.UP).getTileEntity(world) instanceof TileEntityThermalEvaporationBlock || !addTankPart(pointerTile))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
if((x == 1 || x == 2) && (z == 1 || z == 2))
|
|
{
|
|
if(!pointer.isAirBlock(world))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
if(pointer.offset(EnumFacing.UP).getTileEntity(world) instanceof TileEntityThermalEvaporationBlock || !addTankPart(pointerTile))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public int getMaxFluid()
|
|
{
|
|
return height*4*TankUpdateProtocol.FLUID_PER_TANK;
|
|
}
|
|
|
|
public int getCorner(int x, int z)
|
|
{
|
|
if(x == 0 && z == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
else if(x == 0 && z == 3)
|
|
{
|
|
return 1;
|
|
}
|
|
else if(x == 3 && z == 0)
|
|
{
|
|
return 2;
|
|
}
|
|
else if(x == 3 && z == 3)
|
|
{
|
|
return 3;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public boolean scanLowerLayer(Coord4D current)
|
|
{
|
|
EnumFacing right = MekanismUtils.getRight(facing);
|
|
EnumFacing back = MekanismUtils.getBack(facing);
|
|
|
|
boolean foundCenter = false;
|
|
|
|
for(int x = 0; x < 4; x++)
|
|
{
|
|
for(int z = 0; z < 4; z++)
|
|
{
|
|
Coord4D pointer = current.offset(right, x).offset(back, z);
|
|
TileEntity pointerTile = pointer.getTileEntity(world);
|
|
|
|
if((x == 1 || x == 2) && (z == 1 || z == 2))
|
|
{
|
|
if(pointerTile instanceof TileEntityThermalEvaporationBlock)
|
|
{
|
|
if(!foundCenter)
|
|
{
|
|
if(x == 1 && z == 1)
|
|
{
|
|
foundCenter = true;
|
|
}
|
|
else {
|
|
height = -1;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if(foundCenter || !pointer.isAirBlock(world))
|
|
{
|
|
height = -1;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if(!addTankPart(pointerTile))
|
|
{
|
|
height = -1;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
height++;
|
|
|
|
return !foundCenter;
|
|
}
|
|
|
|
public boolean addTankPart(TileEntity tile)
|
|
{
|
|
if(tile instanceof TileEntityThermalEvaporationBlock && (tile == this || !(tile instanceof TileEntityThermalEvaporationController)))
|
|
{
|
|
if(tile != this)
|
|
{
|
|
((TileEntityThermalEvaporationBlock)tile).addToStructure(Coord4D.get(this));
|
|
tankParts.add(Coord4D.get(tile));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else {
|
|
if(tile != this && tile instanceof TileEntityThermalEvaporationController)
|
|
{
|
|
controllerConflict = true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public boolean addSolarPanel(TileEntity tile, int i)
|
|
{
|
|
if(tile != null && !tile.isInvalid() && CapabilityUtils.hasCapability(tile, Capabilities.EVAPORATION_SOLAR_CAPABILITY, EnumFacing.DOWN))
|
|
{
|
|
solars[i] = CapabilityUtils.getCapability(tile, Capabilities.EVAPORATION_SOLAR_CAPABILITY, EnumFacing.DOWN);
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public int getScaledTempLevel(int i)
|
|
{
|
|
return (int)(i*Math.min(1, getTemperature()/general.evaporationMaxTemp));
|
|
}
|
|
|
|
public Coord4D getRenderLocation()
|
|
{
|
|
if(!structured)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
EnumFacing right = MekanismUtils.getRight(facing);
|
|
Coord4D startPoint = Coord4D.get(this).offset(right);
|
|
startPoint = isLeftOnFace ? startPoint.offset(right) : startPoint;
|
|
|
|
startPoint = startPoint.offset(right.getOpposite()).offset(MekanismUtils.getBack(facing));
|
|
startPoint.yCoord = renderY;
|
|
|
|
return startPoint;
|
|
}
|
|
|
|
@Override
|
|
public void handlePacketData(ByteBuf dataStream)
|
|
{
|
|
super.handlePacketData(dataStream);
|
|
|
|
if(FMLCommonHandler.instance().getEffectiveSide().isClient())
|
|
{
|
|
if(dataStream.readBoolean())
|
|
{
|
|
inputTank.setFluid(new FluidStack(FluidRegistry.getFluid(PacketHandler.readString(dataStream)), dataStream.readInt()));
|
|
}
|
|
else {
|
|
inputTank.setFluid(null);
|
|
}
|
|
|
|
if(dataStream.readBoolean())
|
|
{
|
|
outputTank.setFluid(new FluidStack(FluidRegistry.getFluid(PacketHandler.readString(dataStream)), dataStream.readInt()));
|
|
}
|
|
else {
|
|
outputTank.setFluid(null);
|
|
}
|
|
|
|
structured = dataStream.readBoolean();
|
|
controllerConflict = dataStream.readBoolean();
|
|
clientSolarAmount = dataStream.readInt();
|
|
height = dataStream.readInt();
|
|
temperature = dataStream.readFloat();
|
|
biomeTemp = dataStream.readFloat();
|
|
isLeftOnFace = dataStream.readBoolean();
|
|
lastGain = dataStream.readFloat();
|
|
totalLoss = dataStream.readFloat();
|
|
renderY = dataStream.readInt();
|
|
|
|
if(structured != clientStructured)
|
|
{
|
|
inputTank.setCapacity(getMaxFluid());
|
|
MekanismUtils.updateBlock(world, getPos());
|
|
|
|
if(structured)
|
|
{
|
|
Mekanism.proxy.doGenericSparkle(this, new INodeChecker() {
|
|
@Override
|
|
public boolean isNode(TileEntity tile)
|
|
{
|
|
return tile instanceof TileEntityThermalEvaporationBlock;
|
|
}
|
|
});
|
|
}
|
|
|
|
clientStructured = structured;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ArrayList<Object> getNetworkedData(ArrayList<Object> data)
|
|
{
|
|
super.getNetworkedData(data);
|
|
|
|
if(inputTank.getFluid() != null)
|
|
{
|
|
data.add(true);
|
|
data.add(FluidRegistry.getFluidName(inputTank.getFluid()));
|
|
data.add(inputTank.getFluid().amount);
|
|
}
|
|
else {
|
|
data.add(false);
|
|
}
|
|
|
|
if(outputTank.getFluid() != null)
|
|
{
|
|
data.add(true);
|
|
data.add(FluidRegistry.getFluidName(outputTank.getFluid()));
|
|
data.add(outputTank.getFluid().amount);
|
|
}
|
|
else {
|
|
data.add(false);
|
|
}
|
|
|
|
data.add(structured);
|
|
data.add(controllerConflict);
|
|
data.add(getActiveSolars());
|
|
data.add(height);
|
|
data.add(temperature);
|
|
data.add(biomeTemp);
|
|
data.add(isLeftOnFace);
|
|
data.add(lastGain);
|
|
data.add(totalLoss);
|
|
data.add(renderY);
|
|
|
|
return data;
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbtTags)
|
|
{
|
|
super.readFromNBT(nbtTags);
|
|
|
|
inputTank.readFromNBT(nbtTags.getCompoundTag("waterTank"));
|
|
outputTank.readFromNBT(nbtTags.getCompoundTag("brineTank"));
|
|
|
|
temperature = nbtTags.getFloat("temperature");
|
|
|
|
partialInput = nbtTags.getDouble("partialWater");
|
|
partialOutput = nbtTags.getDouble("partialBrine");
|
|
}
|
|
|
|
@Override
|
|
public NBTTagCompound writeToNBT(NBTTagCompound nbtTags)
|
|
{
|
|
super.writeToNBT(nbtTags);
|
|
|
|
nbtTags.setTag("waterTank", inputTank.writeToNBT(new NBTTagCompound()));
|
|
nbtTags.setTag("brineTank", outputTank.writeToNBT(new NBTTagCompound()));
|
|
|
|
nbtTags.setFloat("temperature", temperature);
|
|
|
|
nbtTags.setDouble("partialWater", partialInput);
|
|
nbtTags.setDouble("partialBrine", partialOutput);
|
|
|
|
return nbtTags;
|
|
}
|
|
|
|
@Override
|
|
public boolean canSetFacing(int side)
|
|
{
|
|
return side != 0 && side != 1;
|
|
}
|
|
|
|
@Override
|
|
public TileEntityThermalEvaporationController getController()
|
|
{
|
|
return structured ? this : null;
|
|
}
|
|
|
|
public void clearStructure()
|
|
{
|
|
for(Coord4D tankPart : tankParts)
|
|
{
|
|
TileEntity tile = tankPart.getTileEntity(world);
|
|
|
|
if(tile instanceof TileEntityThermalEvaporationBlock)
|
|
{
|
|
((TileEntityThermalEvaporationBlock)tile).controllerGone();
|
|
}
|
|
}
|
|
|
|
tankParts.clear();
|
|
solars = new IEvaporationSolar[] {null, null, null, null};
|
|
}
|
|
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public AxisAlignedBB getRenderBoundingBox()
|
|
{
|
|
return INFINITE_EXTENT_AABB;
|
|
}
|
|
|
|
@Override
|
|
public boolean getActive()
|
|
{
|
|
return structured;
|
|
}
|
|
|
|
@Override
|
|
public void setActive(boolean active) {}
|
|
|
|
@Override
|
|
public boolean renderUpdate()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean lightUpdate()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public Object[] getTanks()
|
|
{
|
|
return new Object[] {inputTank, outputTank};
|
|
}
|
|
}
|