2013-06-26 23:49:47 +02:00
|
|
|
package mekanism.common;
|
|
|
|
|
2013-08-25 03:22:45 +02:00
|
|
|
import java.util.ArrayList;
|
2013-06-26 23:49:47 +02:00
|
|
|
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;
|
|
|
|
import java.util.HashSet;
|
|
|
|
import java.util.Iterator;
|
|
|
|
import java.util.List;
|
|
|
|
import java.util.Set;
|
|
|
|
|
2013-08-27 00:49:32 +02:00
|
|
|
import mekanism.api.transmitters.DynamicNetwork;
|
|
|
|
import mekanism.api.transmitters.ITransmitter;
|
|
|
|
import mekanism.api.transmitters.TransmissionType;
|
|
|
|
import mekanism.common.tileentity.TileEntityMechanicalPipe;
|
2013-06-26 23:49:47 +02:00
|
|
|
import net.minecraft.tileentity.TileEntity;
|
|
|
|
import net.minecraftforge.common.ForgeDirection;
|
|
|
|
import net.minecraftforge.common.MinecraftForge;
|
|
|
|
import net.minecraftforge.event.Event;
|
2013-08-25 03:22:45 +02:00
|
|
|
import net.minecraftforge.fluids.Fluid;
|
|
|
|
import net.minecraftforge.fluids.FluidRegistry;
|
2013-07-20 18:10:14 +02:00
|
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
|
|
import net.minecraftforge.fluids.IFluidHandler;
|
|
|
|
import cpw.mods.fml.common.FMLCommonHandler;
|
2013-06-26 23:49:47 +02:00
|
|
|
|
2013-08-19 03:32:47 +02:00
|
|
|
public class FluidNetwork extends DynamicNetwork<IFluidHandler, FluidNetwork>
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-08-19 03:32:47 +02:00
|
|
|
public FluidNetwork(ITransmitter<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();
|
|
|
|
}
|
|
|
|
|
2013-08-19 03:32:47 +02:00
|
|
|
public FluidNetwork(Collection<ITransmitter<FluidNetwork>> collection)
|
|
|
|
{
|
|
|
|
transmitters.addAll(collection);
|
|
|
|
register();
|
|
|
|
}
|
|
|
|
|
2013-08-04 02:41:16 +02:00
|
|
|
public FluidNetwork(Set<FluidNetwork> networks)
|
|
|
|
{
|
|
|
|
for(FluidNetwork net : networks)
|
|
|
|
{
|
|
|
|
if(net != null)
|
|
|
|
{
|
2013-08-17 19:32:05 +02:00
|
|
|
addAllTransmitters(net.transmitters);
|
2013-08-04 02:41:16 +02:00
|
|
|
net.deregister();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
refresh();
|
|
|
|
register();
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
|
|
|
|
2013-10-20 06:04:11 +02:00
|
|
|
public synchronized int getTotalNeeded(List<TileEntity> ignored)
|
2013-08-25 03:22:45 +02:00
|
|
|
{
|
|
|
|
int toReturn = 0;
|
|
|
|
|
|
|
|
for(IFluidHandler handler : possibleAcceptors)
|
|
|
|
{
|
|
|
|
ForgeDirection side = acceptorDirections.get(handler).getOpposite();
|
|
|
|
|
|
|
|
for(Fluid fluid : FluidRegistry.getRegisteredFluids().values())
|
|
|
|
{
|
|
|
|
int filled = handler.fill(side, new FluidStack(fluid, Integer.MAX_VALUE), false);
|
|
|
|
|
|
|
|
toReturn += filled;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return toReturn;
|
|
|
|
}
|
|
|
|
|
2013-10-20 06:04:11 +02:00
|
|
|
public synchronized int emit(FluidStack fluidToSend, boolean doTransfer, TileEntity emitter)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-08-18 22:51:47 +02:00
|
|
|
List availableAcceptors = Arrays.asList(getAcceptors(fluidToSend).toArray());
|
2013-06-26 23:49:47 +02:00
|
|
|
|
|
|
|
Collections.shuffle(availableAcceptors);
|
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
int fluidSent = 0;
|
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;
|
2013-06-26 23:49:47 +02:00
|
|
|
|
|
|
|
for(Object obj : availableAcceptors)
|
|
|
|
{
|
2013-07-20 18:10:14 +02:00
|
|
|
if(obj instanceof IFluidHandler && obj != emitter)
|
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;
|
|
|
|
|
|
|
|
if(remaining > 0)
|
|
|
|
{
|
|
|
|
currentSending++;
|
|
|
|
remaining--;
|
|
|
|
}
|
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
fluidSent += acceptor.fill(acceptorDirections.get(acceptor), new FluidStack(fluidToSend.fluidID, currentSending), doTransfer);
|
2013-06-26 23:49:47 +02: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-07-20 18:10:14 +02:00
|
|
|
FluidStack sendStack = fluidToSend.copy();
|
|
|
|
sendStack.amount = fluidSent;
|
|
|
|
MinecraftForge.EVENT_BUS.post(new FluidTransferEvent(this, sendStack));
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
return fluidSent;
|
2013-06-26 23:49:47 +02: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>();
|
2013-06-26 23:49:47 +02:00
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
for(IFluidHandler acceptor : possibleAcceptors)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-07-20 18:10:14 +02:00
|
|
|
if(acceptor.canFill(acceptorDirections.get(acceptor).getOpposite(), fluidToSend.getFluid()))
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-07-28 01:32:46 +02:00
|
|
|
toReturn.add(acceptor);
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return toReturn;
|
|
|
|
}
|
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-08-19 03:32:47 +02:00
|
|
|
Set<ITransmitter<FluidNetwork>> iterPipes = (Set<ITransmitter<FluidNetwork>>)transmitters.clone();
|
2013-08-04 02:41:16 +02:00
|
|
|
Iterator it = iterPipes.iterator();
|
2013-06-26 23:49:47 +02:00
|
|
|
|
|
|
|
possibleAcceptors.clear();
|
|
|
|
acceptorDirections.clear();
|
|
|
|
|
|
|
|
while(it.hasNext())
|
|
|
|
{
|
2013-08-19 03:32:47 +02:00
|
|
|
ITransmitter<FluidNetwork> conductor = (ITransmitter<FluidNetwork>)it.next();
|
2013-06-26 23:49:47 +02:00
|
|
|
|
2013-08-04 02:41:16 +02:00
|
|
|
if(conductor == null || ((TileEntity)conductor).isInvalid())
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
|
|
|
it.remove();
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-19 03:32:47 +02:00
|
|
|
for(ITransmitter<FluidNetwork> pipe : iterPipes)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-08-27 00:49:32 +02:00
|
|
|
if(pipe instanceof TileEntityMechanicalPipe && ((TileEntityMechanicalPipe)pipe).isActive) continue;
|
2013-07-20 18:10:14 +02:00
|
|
|
IFluidHandler[] acceptors = PipeUtils.getConnectedAcceptors((TileEntity)pipe);
|
2013-06-26 23:49:47 +02:00
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
for(IFluidHandler acceptor : acceptors)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-08-19 03:32:47 +02:00
|
|
|
if(acceptor != null && !(acceptor instanceof ITransmitter))
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
|
|
|
possibleAcceptors.add(acceptor);
|
|
|
|
acceptorDirections.put(acceptor, ForgeDirection.getOrientation(Arrays.asList(acceptors).indexOf(acceptor)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-18 22:51:47 +02:00
|
|
|
@Override
|
2013-10-20 06:04:11 +02:00
|
|
|
public synchronized void merge(FluidNetwork network)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
|
|
|
if(network != null && network != this)
|
|
|
|
{
|
2013-08-04 02:41:16 +02:00
|
|
|
Set<FluidNetwork> networks = new HashSet<FluidNetwork>();
|
|
|
|
networks.add(this);
|
|
|
|
networks.add(network);
|
|
|
|
FluidNetwork newNetwork = new FluidNetwork(networks);
|
2013-06-26 23:49:47 +02:00
|
|
|
newNetwork.refresh();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
2013-06-26 23:49:47 +02:00
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
public final FluidStack fluidSent;
|
2013-06-26 23:49:47 +02:00
|
|
|
|
2013-07-20 18:10:14 +02:00
|
|
|
public FluidTransferEvent(FluidNetwork network, FluidStack fluid)
|
2013-06-26 23:49:47 +02:00
|
|
|
{
|
2013-07-20 18:10:14 +02:00
|
|
|
fluidNetwork = network;
|
|
|
|
fluidSent = fluid;
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|
|
|
|
}
|
2013-08-04 02:18:43 +02: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
|
|
|
}
|
2013-08-22 17:36:31 +02:00
|
|
|
|
|
|
|
@Override
|
|
|
|
protected FluidNetwork create(ITransmitter<FluidNetwork>... varTransmitters)
|
|
|
|
{
|
|
|
|
return new FluidNetwork(varTransmitters);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
protected FluidNetwork create(Collection<ITransmitter<FluidNetwork>> collection)
|
|
|
|
{
|
|
|
|
return new FluidNetwork(collection);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
protected FluidNetwork create(Set<FluidNetwork> networks)
|
|
|
|
{
|
|
|
|
return new FluidNetwork(networks);
|
|
|
|
}
|
2013-08-22 20:07:28 +02:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public TransmissionType getTransmissionType()
|
|
|
|
{
|
|
|
|
return TransmissionType.FLUID;
|
|
|
|
}
|
2013-08-23 20:23:08 +02:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public String getNeeded()
|
|
|
|
{
|
2013-08-25 03:22:45 +02:00
|
|
|
return "Fluid needed (any type): " + (float)getTotalNeeded(new ArrayList())/1000F + " buckets";
|
2013-08-23 20:23:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String getFlow()
|
|
|
|
{
|
|
|
|
return "Not defined yet for Fluid networks";
|
|
|
|
}
|
2013-06-26 23:49:47 +02:00
|
|
|
}
|