Files
Mekanism-Community-Edition/src/main/java/mekanism/common/transmitters/grid/FluidNetwork.java
T
Xander bbcea85fc4 Respect NONE connection mode for Pipe Connections (#5387)
* prevent Out of Bounds exception in factory ItemMeshDefinition

* prevent Out of Bounds error in item stack display name

* Respect NONE connection between pipes. Fixes #4781

* prevent fluid/gas pipes from connecting if their contents arent the same (part 1)

* prevent some case of incorrect network merges that would convert/void a fluid/gas

* Add a way to check if a network is compatible with an buffer
Used for checking the orphan's buffer against the external network

* rename some generic type variables for readability

* introduce BUFFER generic type variable

* Fix missing null check causing new pipes not being able to be added to a network

* More checks for when there is an invalid factory

* bump api version & use a constant for all

* add default method to not break binary compat

* Refresh if a connection exists if a transmitter failed to combine two networks
Fallback to the network's buffer as if we have not saved any data yet the TE's buffer may still be null

* Add a way to get the pipes buffer falling back to the network, rather than doing it from the same method. This ensures that there is no accidental leakage where the count of the buffer matters

* Return a null buffer for pressurized tube buffer if the stack is empty

* Allow merging of networks when they are able to connect again
Visuals still need a minor update to sync the type it should be rendering

* Update network visuals when networks merge

* allow unconnected sides to have their mode set - except logistical transporters which already used that function, they only can un-NONE their unconnected sides
2019-04-20 13:38:14 +08:00

344 lines
10 KiB
Java

package mekanism.common.transmitters.grid;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.annotation.Nullable;
import mekanism.api.Coord4D;
import mekanism.api.transmitters.DynamicNetwork;
import mekanism.api.transmitters.IGridTransmitter;
import mekanism.common.Mekanism;
import mekanism.common.util.CapabilityUtils;
import mekanism.common.util.LangUtils;
import mekanism.common.util.PipeUtils;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
import net.minecraftforge.fluids.capability.IFluidHandler;
import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.common.eventhandler.Event;
import org.apache.commons.lang3.tuple.Pair;
public class FluidNetwork extends DynamicNetwork<IFluidHandler, FluidNetwork, FluidStack> {
public int transferDelay = 0;
public boolean didTransfer;
public boolean prevTransfer;
public float fluidScale;
public Fluid refFluid;
public FluidStack buffer;
public int prevStored;
public int prevTransferAmount = 0;
public FluidNetwork() {
}
public FluidNetwork(Collection<FluidNetwork> networks) {
for (FluidNetwork net : networks) {
if (net != null) {
adoptTransmittersAndAcceptorsFrom(net);
net.deregister();
}
}
fluidScale = getScale();
register();
}
@Override
public void adoptTransmittersAndAcceptorsFrom(FluidNetwork net) {
if (net.buffer != null) {
if (buffer == null) {
buffer = net.buffer.copy();
} else {
if (buffer.getFluid() == net.buffer.getFluid()) {
buffer.amount += net.buffer.amount;
} else if (net.buffer.amount > buffer.amount) {
buffer = net.buffer.copy();
}
}
net.buffer = null;
}
super.adoptTransmittersAndAcceptorsFrom(net);
}
@Nullable
public FluidStack getBuffer() {
return buffer;
}
@Override
public void absorbBuffer(IGridTransmitter<IFluidHandler, FluidNetwork, FluidStack> transmitter) {
FluidStack fluid = transmitter.getBuffer();
if (fluid == null || fluid.getFluid() == null || fluid.amount == 0) {
return;
}
if (buffer == null || buffer.getFluid() == null || buffer.amount == 0) {
buffer = fluid.copy();
fluid.amount = 0;
return;
}
//TODO better multiple buffer impl
if (buffer.isFluidEqual(fluid)) {
buffer.amount += fluid.amount;
}
fluid.amount = 0;
}
@Override
public void clampBuffer() {
if (buffer != null && buffer.amount > getCapacity()) {
buffer.amount = capacity;
}
}
@Override
protected void updateMeanCapacity() {
int numCables = transmitters.size();
double sum = 0;
for (IGridTransmitter<IFluidHandler, FluidNetwork, FluidStack> pipe : transmitters) {
sum += pipe.getCapacity();
}
meanCapacity = sum / (double) numCables;
}
public int getFluidNeeded() {
return getCapacity() - (buffer != null ? buffer.amount : 0);
}
public int tickEmit(FluidStack fluidToSend, boolean doTransfer) {
List<Pair<Coord4D, IFluidHandler>> availableAcceptors = new ArrayList<>(getAcceptors(fluidToSend));
Collections.shuffle(availableAcceptors);
int fluidSent = 0;
if (!availableAcceptors.isEmpty()) {
int divider = availableAcceptors.size();
int remaining = fluidToSend.amount % divider;
int sending = (fluidToSend.amount - remaining) / divider;
for (Pair<Coord4D, IFluidHandler> pair : availableAcceptors) {
int currentSending = sending;
IFluidHandler acceptor = pair.getRight();
EnumSet<EnumFacing> sides = acceptorDirections.get(pair.getLeft());
if (remaining > 0) {
currentSending++;
remaining--;
}
for (EnumFacing side : sides) {
int prev = fluidSent;
if (acceptor != null) {
fluidSent += acceptor.fill(PipeUtils.copy(fluidToSend, currentSending), doTransfer);
}
if (fluidSent > prev) {
break;
}
}
}
}
if (doTransfer && fluidSent > 0 && FMLCommonHandler.instance().getEffectiveSide().isServer()) {
didTransfer = true;
transferDelay = 2;
}
if (fluidSent > fluidToSend.amount) {
Mekanism.logger.error("Some fluid handler took more fluid than we gave it?!");
Mekanism.logger.error("Handler list:");
for (Pair<Coord4D, IFluidHandler> pair : availableAcceptors) {
Mekanism.logger.error(pair.getRight().toString());
}
fluidSent = fluidToSend.amount;
}
return fluidSent;
}
public int emit(FluidStack fluidToSend, boolean doTransfer) {
if (fluidToSend == null || (buffer != null && buffer.getFluid() != fluidToSend.getFluid())) {
return 0;
}
int toUse = Math.min(getFluidNeeded(), fluidToSend.amount);
if (doTransfer) {
if (buffer == null) {
buffer = fluidToSend.copy();
buffer.amount = toUse;
} else {
buffer.amount += toUse;
}
}
return toUse;
}
@Override
public void onUpdate() {
super.onUpdate();
if (FMLCommonHandler.instance().getEffectiveSide().isServer()) {
prevTransferAmount = 0;
if (transferDelay == 0) {
didTransfer = false;
} else {
transferDelay--;
}
int stored = buffer != null ? buffer.amount : 0;
if (stored != prevStored) {
needsUpdate = true;
}
prevStored = stored;
if (didTransfer != prevTransfer || needsUpdate) {
MinecraftForge.EVENT_BUS.post(new FluidTransferEvent(this, buffer, didTransfer));
needsUpdate = false;
}
prevTransfer = didTransfer;
if (buffer != null) {
prevTransferAmount = tickEmit(buffer, true);
if (buffer != null) {
buffer.amount -= prevTransferAmount;
if (buffer.amount <= 0) {
buffer = null;
}
}
}
}
}
@Override
public void clientTick() {
super.clientTick();
fluidScale = Math.max(fluidScale, getScale());
if (didTransfer && fluidScale < 1) {
fluidScale = Math.max(getScale(), Math.min(1, fluidScale + 0.02F));
} else if (!didTransfer && fluidScale > 0) {
fluidScale = getScale();
if (fluidScale == 0) {
buffer = null;
}
}
}
@Override
public Set<Pair<Coord4D, IFluidHandler>> getAcceptors(Object data) {
FluidStack fluidToSend = (FluidStack) data;
Set<Pair<Coord4D, IFluidHandler>> toReturn = new HashSet<>();
if (FMLCommonHandler.instance().getEffectiveSide().isClient()) {
return toReturn;
}
for (Coord4D coord : possibleAcceptors.keySet()) {
EnumSet<EnumFacing> sides = acceptorDirections.get(coord);
TileEntity tile = coord.getTileEntity(getWorld());
if (sides == null || sides.isEmpty()) {
continue;
}
for (EnumFacing side : sides) {
if (!CapabilityUtils.hasCapability(tile, CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side)) {
continue;
}
IFluidHandler acceptor = CapabilityUtils
.getCapability(tile, CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side);
if (acceptor != null && PipeUtils.canFill(acceptor, fluidToSend)) {
toReturn.add(Pair.of(coord, acceptor));
break;
}
}
}
return toReturn;
}
public float getScale() {
return Math.min(1, (buffer == null || getCapacity() == 0 ? 0 : (float) buffer.amount / getCapacity()));
}
@Override
public String toString() {
return "[FluidNetwork] " + transmitters.size() + " transmitters, " + possibleAcceptors.size() + " acceptors.";
}
@Override
public String getNeededInfo() {
return (float) getFluidNeeded() / 1000F + " buckets";
}
@Override
public String getStoredInfo() {
return buffer != null ? LangUtils.localizeFluidStack(buffer) + " (" + buffer.amount + " mB)" : "None";
}
@Override
public String getFlowInfo() {
return prevTransferAmount + " mB/t";
}
@Override
public boolean isCompatibleWith(FluidNetwork other) {
return super.isCompatibleWith(other) && (this.buffer == null || other.buffer == null || this.buffer
.isFluidEqual(other.buffer));
}
@Override
public boolean compatibleWithBuffer(FluidStack buffer) {
return super.compatibleWithBuffer(buffer) && (this.buffer == null || buffer == null || this.buffer.isFluidEqual(buffer));
}
public static class FluidTransferEvent extends Event {
public final FluidNetwork fluidNetwork;
public final FluidStack fluidType;
public final boolean didTransfer;
public FluidTransferEvent(FluidNetwork network, FluidStack type, boolean did) {
fluidNetwork = network;
fluidType = type;
didTransfer = did;
}
}
}