2013-06-26 23:49:47 +02:00
|
|
|
package mekanism.common;
|
|
|
|
|
|
|
|
import java.util.Arrays;
|
2013-08-19 03:32:47 +02:00
|
|
|
import java.util.Collection;
|
2013-06-26 23:49:47 +02:00
|
|
|
import java.util.Collections;
|
2014-08-15 22:21:58 +02:00
|
|
|
import java.util.EnumSet;
|
2013-06-26 23:49:47 +02:00
|
|
|
import java.util.HashSet;
|
|
|
|
import java.util.Iterator;
|
|
|
|
import java.util.List;
|
2014-08-09 19:42:13 +02:00
|
|
|
import java.util.Map;
|
2013-06-26 23:49:47 +02:00
|
|
|
import java.util.Set;
|
|
|
|
|
2014-06-19 14:34:57 +02:00
|
|
|
import mekanism.api.Coord4D;
|
2013-08-27 00:49:32 +02:00
|
|
|
import mekanism.api.transmitters.DynamicNetwork;
|
2013-12-21 01:12:33 +01:00
|
|
|
import mekanism.api.transmitters.IGridTransmitter;
|
2013-12-18 02:28:25 +01:00
|
|
|
import mekanism.api.transmitters.ITransmitterNetwork;
|
2013-08-27 00:49:32 +02:00
|
|
|
import mekanism.api.transmitters.TransmissionType;
|
2014-08-09 19:42:13 +02:00
|
|
|
import mekanism.api.util.ListUtils;
|
2014-08-30 03:34:50 +02:00
|
|
|
import mekanism.common.util.LangUtils;
|
2013-12-15 04:50:37 +01:00
|
|
|
import mekanism.common.util.PipeUtils;
|
2013-06-26 23:49:47 +02:00
|
|
|
import net.minecraft.tileentity.TileEntity;
|
|
|
|
import net.minecraftforge.common.MinecraftForge;
|
2014-06-02 23:57:40 +02:00
|
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
2013-08-25 03:22:45 +02:00
|
|
|
import net.minecraftforge.fluids.Fluid;
|
2013-07-20 18:10:14 +02:00
|
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
|
|
import net.minecraftforge.fluids.IFluidHandler;
|
|
|
|
import cpw.mods.fml.common.FMLCommonHandler;
|
2014-06-02 23:57:40 +02:00
|
|
|
import cpw.mods.fml.common.eventhandler.Event;
|
2013-06-26 23:49:47 +02:00
|
|
|
|
2013-12-06 13:57:26 +01:00
|
|
|
public class FluidNetwork extends DynamicNetwork<IFluidHandler, FluidNetwork>
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-11-25 06:00:26 +01:00
|
|
|
public int transferDelay = 0;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-11-29 03:43:53 +01:00
|
|
|
public boolean didTransfer;
|
|
|
|
public boolean prevTransfer;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-11-29 03:43:53 +01:00
|
|
|
public float fluidScale;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 00:20:18 +01:00
|
|
|
public Fluid refFluid;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-14 06:36:52 +01:00
|
|
|
public FluidStack fluidStored;
|
2013-12-18 00:20:18 +01:00
|
|
|
public int prevStored;
|
2014-01-07 04:17:59 +01:00
|
|
|
|
|
|
|
public int prevTransferAmount = 0;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-21 01:12:33 +01:00
|
|
|
public FluidNetwork(IGridTransmitter<FluidNetwork>... varPipes)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-08-17 19:32:05 +02:00
|
|
|
transmitters.addAll(Arrays.asList(varPipes));
|
2013-08-04 02:41:16 +02:00
|
|
|
register();
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-21 01:12:33 +01:00
|
|
|
public FluidNetwork(Collection<IGridTransmitter<FluidNetwork>> collection)
|
2013-08-19 03:32:47 +02:00
|
|
|
{
|
|
|
|
transmitters.addAll(collection);
|
|
|
|
register();
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-08-04 02:41:16 +02:00
|
|
|
public FluidNetwork(Set<FluidNetwork> networks)
|
|
|
|
{
|
|
|
|
for(FluidNetwork net : networks)
|
|
|
|
{
|
|
|
|
if(net != null)
|
|
|
|
{
|
2013-12-18 17:19:30 +01:00
|
|
|
if(FMLCommonHandler.instance().getEffectiveSide().isClient())
|
2013-11-29 19:04:39 +01:00
|
|
|
{
|
2013-12-18 17:19:30 +01:00
|
|
|
if(net.refFluid != null && net.fluidScale > fluidScale)
|
2013-12-17 18:53:33 +01:00
|
|
|
{
|
2013-12-18 17:19:30 +01:00
|
|
|
refFluid = net.refFluid;
|
|
|
|
fluidScale = net.fluidScale;
|
2013-12-17 18:53:33 +01:00
|
|
|
fluidStored = net.fluidStored;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 17:19:30 +01:00
|
|
|
net.fluidScale = 0;
|
|
|
|
net.refFluid = null;
|
|
|
|
net.fluidStored = null;
|
2013-12-17 18:53:33 +01:00
|
|
|
}
|
2013-12-18 17:19:30 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
if(net.fluidStored != null)
|
|
|
|
{
|
|
|
|
if(fluidStored == null)
|
|
|
|
{
|
|
|
|
fluidStored = net.fluidStored;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
fluidStored.amount += net.fluidStored.amount;
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 17:19:30 +01:00
|
|
|
net.fluidStored = null;
|
2013-12-17 18:53:33 +01:00
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-08-17 19:32:05 +02:00
|
|
|
addAllTransmitters(net.transmitters);
|
2013-08-04 02:41:16 +02:00
|
|
|
net.deregister();
|
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 13:24:59 +01:00
|
|
|
fluidScale = getScale();
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-08-04 02:41:16 +02:00
|
|
|
register();
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2014-04-01 20:16:07 +02:00
|
|
|
@Override
|
|
|
|
protected synchronized void updateMeanCapacity()
|
|
|
|
{
|
|
|
|
int numCables = transmitters.size();
|
|
|
|
double sum = 0;
|
|
|
|
|
|
|
|
for(IGridTransmitter<FluidNetwork> pipe : transmitters)
|
|
|
|
{
|
|
|
|
sum += pipe.getCapacity();
|
|
|
|
}
|
|
|
|
|
|
|
|
meanCapacity = sum / (double)numCables;
|
|
|
|
}
|
|
|
|
|
2014-03-08 02:00:25 +01:00
|
|
|
@Override
|
|
|
|
public void onNetworksCreated(List<FluidNetwork> networks)
|
|
|
|
{
|
2013-12-18 17:19:30 +01:00
|
|
|
if(fluidStored != null && FMLCommonHandler.instance().getEffectiveSide().isServer())
|
2013-12-18 02:28:25 +01:00
|
|
|
{
|
2014-03-08 02:00:25 +01:00
|
|
|
int[] caps = new int[networks.size()];
|
|
|
|
int cap = 0;
|
|
|
|
|
|
|
|
for(FluidNetwork network : networks)
|
|
|
|
{
|
|
|
|
caps[networks.indexOf(network)] = network.getCapacity();
|
|
|
|
cap += network.getCapacity();
|
|
|
|
}
|
|
|
|
|
|
|
|
fluidStored.amount = Math.min(cap, fluidStored.amount);
|
|
|
|
|
|
|
|
int[] values = ListUtils.calcPercentInt(ListUtils.percent(caps), fluidStored.amount);
|
|
|
|
|
|
|
|
for(FluidNetwork network : networks)
|
|
|
|
{
|
|
|
|
int index = networks.indexOf(network);
|
|
|
|
|
|
|
|
if(values[index] > 0)
|
|
|
|
{
|
|
|
|
network.fluidStored = new FluidStack(fluidStored.getFluid(), values[index]);
|
|
|
|
network.fluidScale = network.getScale();
|
|
|
|
network.refFluid = fluidStored.getFluid();
|
|
|
|
}
|
|
|
|
}
|
2013-12-18 02:28:25 +01:00
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
|
|
|
fluidScale = 0;
|
|
|
|
fluidStored = null;
|
|
|
|
refFluid = null;
|
|
|
|
}
|
|
|
|
|
2013-12-14 06:36:52 +01:00
|
|
|
public synchronized int getFluidNeeded()
|
|
|
|
{
|
|
|
|
return getCapacity()-(fluidStored != null ? fluidStored.amount : 0);
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-14 06:36:52 +01:00
|
|
|
public synchronized int tickEmit(FluidStack fluidToSend, boolean doTransfer)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-08-18 22:51:47 +02:00
|
|
|
List availableAcceptors = Arrays.asList(getAcceptors(fluidToSend).toArray());
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-06-26 23:49:47 +02:00
|
|
|
Collections.shuffle(availableAcceptors);
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
int fluidSent = 0;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-06-26 23:49:47 +02:00
|
|
|
if(!availableAcceptors.isEmpty())
|
|
|
|
{
|
|
|
|
int divider = availableAcceptors.size();
|
2013-07-20 18:10:14 +02:00
|
|
|
int remaining = fluidToSend.amount % divider;
|
|
|
|
int sending = (fluidToSend.amount-remaining)/divider;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-06-26 23:49:47 +02:00
|
|
|
for(Object obj : availableAcceptors)
|
|
|
|
{
|
2013-12-14 06:36:52 +01:00
|
|
|
if(obj instanceof IFluidHandler)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-07-20 18:10:14 +02:00
|
|
|
IFluidHandler acceptor = (IFluidHandler)obj;
|
2013-06-26 23:49:47 +02:00
|
|
|
int currentSending = sending;
|
2014-08-15 22:21:58 +02:00
|
|
|
EnumSet<ForgeDirection> sides = acceptorDirections.get(Coord4D.get((TileEntity)acceptor));
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-06-26 23:49:47 +02:00
|
|
|
if(remaining > 0)
|
|
|
|
{
|
|
|
|
currentSending++;
|
|
|
|
remaining--;
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2014-08-15 22:21:58 +02:00
|
|
|
for(ForgeDirection side : sides)
|
|
|
|
{
|
|
|
|
int prev = fluidSent;
|
|
|
|
|
|
|
|
fluidSent += acceptor.fill(side.getOpposite(), new FluidStack(fluidToSend.fluidID, currentSending), doTransfer);
|
|
|
|
|
|
|
|
if(fluidSent > prev)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
if(doTransfer && fluidSent > 0 && FMLCommonHandler.instance().getEffectiveSide().isServer())
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-11-29 03:43:53 +01:00
|
|
|
didTransfer = true;
|
|
|
|
transferDelay = 2;
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
return fluidSent;
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-14 06:36:52 +01:00
|
|
|
public synchronized int emit(FluidStack fluidToSend, boolean doTransfer)
|
|
|
|
{
|
|
|
|
if(fluidToSend == null || (fluidStored != null && fluidStored.getFluid() != fluidToSend.getFluid()))
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-14 06:36:52 +01:00
|
|
|
int toUse = Math.min(getFluidNeeded(), fluidToSend.amount);
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-14 06:36:52 +01:00
|
|
|
if(doTransfer)
|
|
|
|
{
|
|
|
|
if(fluidStored == null)
|
|
|
|
{
|
|
|
|
fluidStored = fluidToSend.copy();
|
|
|
|
fluidStored.amount = toUse;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
fluidStored.amount += toUse;
|
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-14 06:36:52 +01:00
|
|
|
return toUse;
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-11-25 06:00:26 +01:00
|
|
|
@Override
|
2013-12-21 20:54:12 +01:00
|
|
|
public void onUpdate()
|
2013-11-25 06:00:26 +01:00
|
|
|
{
|
2013-12-21 20:54:12 +01:00
|
|
|
super.onUpdate();
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-11-25 06:00:26 +01:00
|
|
|
if(FMLCommonHandler.instance().getEffectiveSide().isServer())
|
|
|
|
{
|
2014-03-20 01:54:21 +01:00
|
|
|
prevTransferAmount = 0;
|
|
|
|
|
2013-11-25 06:00:26 +01:00
|
|
|
if(transferDelay == 0)
|
|
|
|
{
|
2013-11-29 03:43:53 +01:00
|
|
|
didTransfer = false;
|
2013-11-25 06:00:26 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
transferDelay--;
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 00:20:18 +01:00
|
|
|
int stored = fluidStored != null ? fluidStored.amount : 0;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 00:20:18 +01:00
|
|
|
if(stored != prevStored)
|
2013-12-14 21:30:41 +01:00
|
|
|
{
|
|
|
|
needsUpdate = true;
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 00:20:18 +01:00
|
|
|
prevStored = stored;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-11-29 03:43:53 +01:00
|
|
|
if(didTransfer != prevTransfer || needsUpdate)
|
2013-11-25 06:00:26 +01:00
|
|
|
{
|
2013-12-18 00:20:18 +01:00
|
|
|
MinecraftForge.EVENT_BUS.post(new FluidTransferEvent(this, fluidStored, didTransfer));
|
2013-11-29 03:43:53 +01:00
|
|
|
needsUpdate = false;
|
2013-11-25 06:00:26 +01:00
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-11-29 03:43:53 +01:00
|
|
|
prevTransfer = didTransfer;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-14 06:36:52 +01:00
|
|
|
if(fluidStored != null)
|
|
|
|
{
|
2014-03-20 01:54:21 +01:00
|
|
|
prevTransferAmount = tickEmit(fluidStored, true);
|
2014-08-31 21:30:41 +02:00
|
|
|
if(fluidStored != null)
|
2013-12-14 06:36:52 +01:00
|
|
|
{
|
2014-08-31 21:30:41 +02:00
|
|
|
fluidStored.amount -= prevTransferAmount;
|
|
|
|
|
|
|
|
if(fluidStored.amount <= 0)
|
|
|
|
{
|
|
|
|
fluidStored = null;
|
|
|
|
}
|
2013-12-14 06:36:52 +01:00
|
|
|
}
|
|
|
|
}
|
2013-11-29 03:43:53 +01:00
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-11-29 03:43:53 +01:00
|
|
|
@Override
|
|
|
|
public void clientTick()
|
|
|
|
{
|
|
|
|
super.clientTick();
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 00:20:18 +01:00
|
|
|
fluidScale = Math.max(fluidScale, getScale());
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-11-29 03:43:53 +01:00
|
|
|
if(didTransfer && fluidScale < 1)
|
|
|
|
{
|
2013-12-18 00:20:18 +01:00
|
|
|
fluidScale = Math.max(getScale(), Math.min(1, fluidScale+0.02F));
|
2013-11-29 03:43:53 +01:00
|
|
|
}
|
|
|
|
else if(!didTransfer && fluidScale > 0)
|
|
|
|
{
|
2013-12-18 02:28:25 +01:00
|
|
|
fluidScale = getScale();
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-11-29 03:43:53 +01:00
|
|
|
if(fluidScale == 0)
|
|
|
|
{
|
2013-12-18 00:20:18 +01:00
|
|
|
fluidStored = null;
|
2013-11-29 03:43:53 +01:00
|
|
|
}
|
2013-11-25 06:00:26 +01:00
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-08-18 22:51:47 +02:00
|
|
|
@Override
|
2013-10-20 06:04:11 +02:00
|
|
|
public synchronized Set<IFluidHandler> getAcceptors(Object... data)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-08-18 22:51:47 +02:00
|
|
|
FluidStack fluidToSend = (FluidStack)data[0];
|
2013-07-20 18:10:14 +02:00
|
|
|
Set<IFluidHandler> toReturn = new HashSet<IFluidHandler>();
|
2014-08-15 22:21:58 +02:00
|
|
|
|
|
|
|
if(FMLCommonHandler.instance().getEffectiveSide().isClient())
|
|
|
|
{
|
|
|
|
return toReturn;
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2014-08-15 22:21:58 +02:00
|
|
|
for(Coord4D coord : ((Map<Coord4D, IFluidHandler>)possibleAcceptors.clone()).keySet())
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2014-08-15 22:21:58 +02:00
|
|
|
EnumSet<ForgeDirection> sides = acceptorDirections.get(coord);
|
|
|
|
IFluidHandler acceptor = (IFluidHandler)coord.getTileEntity(getWorld());
|
|
|
|
|
|
|
|
if(sides == null || sides.isEmpty())
|
2013-12-12 22:54:55 +01:00
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2014-08-15 22:21:58 +02:00
|
|
|
for(ForgeDirection side : sides)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2014-08-15 22:21:58 +02:00
|
|
|
if(acceptor.canFill(side.getOpposite(), fluidToSend.getFluid()))
|
|
|
|
{
|
|
|
|
toReturn.add(acceptor);
|
|
|
|
break;
|
|
|
|
}
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-06-26 23:49:47 +02:00
|
|
|
return toReturn;
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-08-18 22:51:47 +02:00
|
|
|
@Override
|
2013-10-20 06:04:11 +02:00
|
|
|
public synchronized void refresh()
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-12-21 01:12:33 +01:00
|
|
|
Set<IGridTransmitter<FluidNetwork>> iterPipes = (Set<IGridTransmitter<FluidNetwork>>)transmitters.clone();
|
2013-08-04 02:41:16 +02:00
|
|
|
Iterator it = iterPipes.iterator();
|
2014-03-24 06:56:31 +01:00
|
|
|
boolean networkChanged = false;
|
2013-06-26 23:49:47 +02:00
|
|
|
|
|
|
|
while(it.hasNext())
|
|
|
|
{
|
2013-12-21 01:12:33 +01:00
|
|
|
IGridTransmitter<FluidNetwork> conductor = (IGridTransmitter<FluidNetwork>)it.next();
|
2013-06-26 23:49:47 +02:00
|
|
|
|
2014-06-19 14:42:11 +02:00
|
|
|
if(conductor == null || conductor.getTile().isInvalid())
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
|
|
|
it.remove();
|
2014-03-24 06:56:31 +01:00
|
|
|
networkChanged = true;
|
2013-08-17 19:32:05 +02:00
|
|
|
transmitters.remove(conductor);
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
|
|
|
else {
|
2013-08-27 01:04:00 +02:00
|
|
|
conductor.setTransmitterNetwork(this);
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2014-06-19 14:34:57 +02:00
|
|
|
if(networkChanged)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2014-06-19 14:34:57 +02:00
|
|
|
updateCapacity();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public synchronized void refresh(IGridTransmitter<FluidNetwork> transmitter)
|
|
|
|
{
|
2014-06-19 14:42:11 +02:00
|
|
|
IFluidHandler[] acceptors = PipeUtils.getConnectedAcceptors(transmitter.getTile());
|
2014-06-19 14:34:57 +02:00
|
|
|
|
|
|
|
clearAround(transmitter);
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2014-06-19 14:34:57 +02:00
|
|
|
for(IFluidHandler acceptor : acceptors)
|
|
|
|
{
|
|
|
|
ForgeDirection side = ForgeDirection.getOrientation(Arrays.asList(acceptors).indexOf(acceptor));
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2014-06-19 14:34:57 +02:00
|
|
|
if(side != null && acceptor != null && !(acceptor instanceof IGridTransmitter) && transmitter.canConnectToAcceptor(side, true))
|
|
|
|
{
|
|
|
|
possibleAcceptors.put(Coord4D.get((TileEntity)acceptor), acceptor);
|
2014-08-15 22:21:58 +02:00
|
|
|
addSide(Coord4D.get((TileEntity)acceptor), ForgeDirection.getOrientation(Arrays.asList(acceptors).indexOf(acceptor)));
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
public static class FluidTransferEvent extends Event
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-07-20 18:10:14 +02:00
|
|
|
public final FluidNetwork fluidNetwork;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 00:20:18 +01:00
|
|
|
public final FluidStack fluidType;
|
2013-11-29 03:43:53 +01:00
|
|
|
public final boolean didTransfer;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 00:20:18 +01:00
|
|
|
public FluidTransferEvent(FluidNetwork network, FluidStack type, boolean did)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-07-20 18:10:14 +02:00
|
|
|
fluidNetwork = network;
|
2013-11-25 06:00:26 +01:00
|
|
|
fluidType = type;
|
2013-11-29 03:43:53 +01:00
|
|
|
didTransfer = did;
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-14 21:30:41 +01:00
|
|
|
public float getScale()
|
|
|
|
{
|
2013-12-17 21:54:06 +01:00
|
|
|
return Math.min(1, (fluidStored == null || getCapacity() == 0 ? 0 : (float)fluidStored.amount/getCapacity()));
|
2013-12-14 21:30:41 +01:00
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-06-26 23:49:47 +02:00
|
|
|
@Override
|
|
|
|
public String toString()
|
|
|
|
{
|
2013-08-17 19:32:05 +02:00
|
|
|
return "[FluidNetwork] " + transmitters.size() + " transmitters, " + possibleAcceptors.size() + " acceptors.";
|
2013-08-04 02:18:43 +02:00
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-08-22 17:36:31 +02:00
|
|
|
@Override
|
2014-03-08 02:00:25 +01:00
|
|
|
protected FluidNetwork create(Collection<IGridTransmitter<FluidNetwork>> collection)
|
2013-08-22 17:36:31 +02:00
|
|
|
{
|
2013-11-29 03:43:53 +01:00
|
|
|
FluidNetwork network = new FluidNetwork(collection);
|
2013-12-18 02:28:25 +01:00
|
|
|
network.refFluid = refFluid;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 17:19:30 +01:00
|
|
|
if(fluidStored != null)
|
2013-12-17 18:53:33 +01:00
|
|
|
{
|
|
|
|
if(network.fluidStored == null)
|
|
|
|
{
|
|
|
|
network.fluidStored = fluidStored;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
network.fluidStored.amount += fluidStored.amount;
|
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2014-04-01 20:16:07 +02:00
|
|
|
network.updateCapacity();
|
2013-12-18 13:24:59 +01:00
|
|
|
network.fluidScale = network.getScale();
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-11-29 03:43:53 +01:00
|
|
|
return network;
|
2013-08-22 17:36:31 +02:00
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 02:28:25 +01:00
|
|
|
@Override
|
|
|
|
public boolean canMerge(List<ITransmitterNetwork<?, ?>> networks)
|
|
|
|
{
|
|
|
|
Fluid found = null;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 02:28:25 +01:00
|
|
|
for(ITransmitterNetwork<?, ?> network : networks)
|
|
|
|
{
|
|
|
|
if(network instanceof FluidNetwork)
|
|
|
|
{
|
|
|
|
FluidNetwork net = (FluidNetwork)network;
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 02:28:25 +01:00
|
|
|
if(net.fluidStored != null)
|
|
|
|
{
|
|
|
|
if(found != null && found != net.fluidStored.getFluid())
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 02:28:25 +01:00
|
|
|
found = net.fluidStored.getFluid();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2013-12-18 02:28:25 +01:00
|
|
|
return true;
|
|
|
|
}
|
2013-08-22 17:36:31 +02:00
|
|
|
|
2013-08-22 20:07:28 +02:00
|
|
|
@Override
|
|
|
|
public TransmissionType getTransmissionType()
|
|
|
|
{
|
|
|
|
return TransmissionType.FLUID;
|
|
|
|
}
|
2013-08-23 20:23:08 +02:00
|
|
|
|
|
|
|
@Override
|
2014-07-09 21:31:57 +02:00
|
|
|
public String getNeededInfo()
|
2013-08-23 20:23:08 +02:00
|
|
|
{
|
2014-07-09 21:31:57 +02:00
|
|
|
return (float)getFluidNeeded()/1000F + " buckets";
|
2013-08-23 20:23:08 +02:00
|
|
|
}
|
2014-03-08 02:00:25 +01:00
|
|
|
|
2014-01-07 04:17:59 +01:00
|
|
|
@Override
|
2014-07-09 21:31:57 +02:00
|
|
|
public String getStoredInfo()
|
2014-01-07 04:17:59 +01:00
|
|
|
{
|
2014-08-30 03:34:50 +02:00
|
|
|
return fluidStored != null ? LangUtils.localizeFluidStack(fluidStored) + " (" + fluidStored.amount + " mB)" : "None";
|
2014-01-07 04:17:59 +01:00
|
|
|
}
|
|
|
|
|
2013-08-23 20:23:08 +02:00
|
|
|
@Override
|
2014-07-09 21:31:57 +02:00
|
|
|
public String getFlowInfo()
|
2013-08-23 20:23:08 +02:00
|
|
|
{
|
2014-07-09 21:31:57 +02:00
|
|
|
return Integer.toString(prevTransferAmount) + " mB/t";
|
2013-08-23 20:23:08 +02:00
|
|
|
}
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|