mirror of
https://github.com/GTNewHorizons/EnderIO.git
synced 2026-11-21 04:32:18 +00:00
328 lines
11 KiB
Java
328 lines
11 KiB
Java
package crazypants.enderio.conduit.liquid;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
import net.minecraftforge.fluids.FluidTankInfo;
|
|
import net.minecraftforge.fluids.IFluidHandler;
|
|
|
|
import com.enderio.core.common.util.BlockCoord;
|
|
|
|
import crazypants.enderio.conduit.AbstractConduitNetwork;
|
|
import crazypants.enderio.conduit.ConnectionMode;
|
|
|
|
public class EnderLiquidConduitNetwork extends AbstractConduitNetwork<ILiquidConduit, AbstractEnderLiquidConduit> {
|
|
|
|
private class TankIterator implements Iterator<NetworkTank> {
|
|
|
|
private int index = -1;
|
|
private int currentCount = 0;
|
|
|
|
public TankIterator start() {
|
|
currentCount = 0;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasNext() {
|
|
return !tanks.isEmpty() && currentCount < tanks.size();
|
|
}
|
|
|
|
@Override
|
|
public NetworkTank next() {
|
|
if (tanks.isEmpty()) {
|
|
return null;
|
|
}
|
|
currentCount++;
|
|
index++;
|
|
if (index >= tanks.size()) {
|
|
index = 0;
|
|
}
|
|
return tanks.get(index);
|
|
}
|
|
|
|
@Override
|
|
public void remove() {}
|
|
|
|
public void rewind() {
|
|
if (index == 0) index = tanks.size() - 1;
|
|
else index--;
|
|
currentCount--;
|
|
}
|
|
}
|
|
|
|
private final AbstractEnderLiquidConduit.Type type;
|
|
|
|
List<NetworkTank> tanks = new ArrayList<>();
|
|
Map<NetworkTankKey, NetworkTank> tankMap = new HashMap<>();
|
|
|
|
Map<NetworkTank, TankIterator> iterators;
|
|
|
|
boolean filling;
|
|
|
|
public EnderLiquidConduitNetwork(AbstractEnderLiquidConduit.Type type) {
|
|
super(AbstractEnderLiquidConduit.class, ILiquidConduit.class);
|
|
this.type = type;
|
|
}
|
|
|
|
public void connectionChanged(AbstractEnderLiquidConduit con, ForgeDirection conDir) {
|
|
NetworkTankKey key = new NetworkTankKey(con, conDir);
|
|
NetworkTank tank = new NetworkTank(con, conDir);
|
|
tanks.remove(tank); // remove old tank, NB: =/hash is only calced on location and dir
|
|
tankMap.remove(key);
|
|
tanks.add(tank);
|
|
tankMap.put(key, tank);
|
|
}
|
|
|
|
public boolean extractFrom(AbstractEnderLiquidConduit con, ForgeDirection conDir) {
|
|
NetworkTank tank = getTank(con, conDir);
|
|
if (tank == null || !tank.isValid()) {
|
|
return false;
|
|
}
|
|
|
|
FluidTankInfo[] tankInfos = tank.externalTank.getTankInfo(conDir.getOpposite());
|
|
if (tankInfos != null) {
|
|
for (FluidTankInfo tankInfo : tankInfos) {
|
|
if (tankInfo == null || tankInfo.fluid == null) {
|
|
continue;
|
|
}
|
|
|
|
FluidStack tryDrain = tankInfo.fluid.copy();
|
|
tryDrain.amount = type.getMaxExtractPerTick();
|
|
FluidStack drained = tank.externalTank.drain(conDir.getOpposite(), tryDrain, false);
|
|
if (drained == null || drained.amount <= 0
|
|
|| !matchedFilter(drained, con, conDir, true)
|
|
|| !tryDrain.isFluidEqual(drained)) {
|
|
continue;
|
|
}
|
|
|
|
int amountAccepted = fillFrom(tank, drained, true);
|
|
if (amountAccepted <= 0) {
|
|
continue;
|
|
}
|
|
|
|
tryDrain.amount = amountAccepted;
|
|
drained = tank.externalTank.drain(conDir.getOpposite(), tryDrain, true);
|
|
if (drained == null || drained.amount <= 0) {
|
|
continue;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
FluidStack drained = tank.externalTank.drain(conDir.getOpposite(), type.getMaxExtractPerTick(), false);
|
|
if (drained == null || drained.amount <= 0 || !matchedFilter(drained, con, conDir, true)) {
|
|
return false;
|
|
}
|
|
int amountAccepted = fillFrom(tank, drained, true);
|
|
if (amountAccepted <= 0) {
|
|
return false;
|
|
}
|
|
drained = tank.externalTank.drain(conDir.getOpposite(), amountAccepted, true);
|
|
return drained != null && drained.amount > 0;
|
|
}
|
|
|
|
private NetworkTank getTank(AbstractEnderLiquidConduit con, ForgeDirection conDir) {
|
|
return tankMap.get(new NetworkTankKey(con, conDir));
|
|
}
|
|
|
|
public int fillFrom(AbstractEnderLiquidConduit con, ForgeDirection conDir, FluidStack resource, boolean doFill) {
|
|
return fillFrom(getTank(con, conDir), resource, doFill);
|
|
}
|
|
|
|
public int fillFrom(NetworkTank tank, FluidStack resource, boolean doFill) {
|
|
|
|
if (filling) {
|
|
return 0;
|
|
}
|
|
|
|
try {
|
|
|
|
filling = true;
|
|
|
|
if (resource == null || tank == null || !matchedFilter(resource, tank.con, tank.conDir, true)) {
|
|
return 0;
|
|
}
|
|
resource = resource.copy();
|
|
resource.amount = Math.min(resource.amount, type.getMaxIoPerTick());
|
|
int filled = 0;
|
|
// TODO: Only change starting pos of iterator is doFill is true so a false then true returns the same
|
|
|
|
TankIterator iterator;
|
|
for (iterator = getIteratorForTank(tank).start(); iterator.hasNext();) {
|
|
NetworkTank target = iterator.next();
|
|
if (!target.equals(tank)
|
|
&& target.con.getOutputColor(target.conDir).equals(tank.con.getInputColor(tank.conDir))
|
|
&& target.acceptsOuput
|
|
&& target.isValid()
|
|
&& matchedFilter(resource, target.con, target.conDir, false)) {
|
|
// Use reused FluidStack instead of copying each iteration
|
|
int vol = target.externalTank.fill(target.tankDir, resource, doFill);
|
|
resource.amount -= vol;
|
|
filled += vol;
|
|
if (resource.amount <= 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!tank.con.isRoundRobin(tank.conDir)) iterator.rewind();
|
|
return filled;
|
|
|
|
} finally {
|
|
filling = false;
|
|
}
|
|
}
|
|
|
|
private boolean matchedFilter(FluidStack drained, AbstractEnderLiquidConduit con, ForgeDirection conDir,
|
|
boolean isInput) {
|
|
if (drained == null || con == null || conDir == null) {
|
|
return false;
|
|
}
|
|
FluidFilter filter = con.getFilter(conDir, isInput);
|
|
if (filter == null || filter.isEmpty()) {
|
|
return true;
|
|
}
|
|
return filter.matchesFilter(drained);
|
|
}
|
|
|
|
private TankIterator getIteratorForTank(NetworkTank tank) {
|
|
if (iterators == null) {
|
|
iterators = new HashMap<>();
|
|
}
|
|
TankIterator res = iterators.get(tank);
|
|
if (res == null) {
|
|
res = new TankIterator();
|
|
iterators.put(tank, res);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public FluidTankInfo[] getTankInfo(AbstractEnderLiquidConduit con, ForgeDirection conDir) {
|
|
List<FluidTankInfo> res = new ArrayList<>(tanks.size());
|
|
NetworkTank tank = getTank(con, conDir);
|
|
for (NetworkTank target : tanks) {
|
|
if (!target.equals(tank) && target.isValid()) {
|
|
FluidTankInfo[] tTanks = target.externalTank.getTankInfo(target.tankDir);
|
|
if (tTanks != null) {
|
|
for (FluidTankInfo info : tTanks) {
|
|
res.add(info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return res.toArray(new FluidTankInfo[res.size()]);
|
|
}
|
|
|
|
static class NetworkTankKey {
|
|
|
|
ForgeDirection conDir;
|
|
BlockCoord conduitLoc;
|
|
|
|
public NetworkTankKey(AbstractEnderLiquidConduit con, ForgeDirection conDir) {
|
|
this(con.getLocation(), conDir);
|
|
}
|
|
|
|
public NetworkTankKey(BlockCoord conduitLoc, ForgeDirection conDir) {
|
|
this.conDir = conDir;
|
|
this.conduitLoc = conduitLoc;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
final int prime = 31;
|
|
int result = 1;
|
|
result = prime * result + ((conDir == null) ? 0 : conDir.hashCode());
|
|
result = prime * result + ((conduitLoc == null) ? 0 : conduitLoc.hashCode());
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (obj == null) {
|
|
return false;
|
|
}
|
|
if (getClass() != obj.getClass()) {
|
|
return false;
|
|
}
|
|
NetworkTankKey other = (NetworkTankKey) obj;
|
|
if (conDir != other.conDir) {
|
|
return false;
|
|
}
|
|
if (conduitLoc == null) {
|
|
if (other.conduitLoc != null) {
|
|
return false;
|
|
}
|
|
} else if (!conduitLoc.equals(other.conduitLoc)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static class NetworkTank {
|
|
|
|
AbstractEnderLiquidConduit con;
|
|
ForgeDirection conDir;
|
|
IFluidHandler externalTank;
|
|
ForgeDirection tankDir;
|
|
BlockCoord conduitLoc;
|
|
boolean acceptsOuput;
|
|
|
|
public NetworkTank(AbstractEnderLiquidConduit con, ForgeDirection conDir) {
|
|
this.con = con;
|
|
this.conDir = conDir;
|
|
conduitLoc = con.getLocation();
|
|
tankDir = conDir.getOpposite();
|
|
externalTank = AbstractLiquidConduit
|
|
.getExternalFluidHandler(con.getBundle().getWorld(), conduitLoc.getLocation(conDir));
|
|
acceptsOuput = con.getConnectionMode(conDir).acceptsOutput();
|
|
}
|
|
|
|
public boolean isValid() {
|
|
return externalTank != null && con.getConnectionMode(conDir) != ConnectionMode.DISABLED;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
final int prime = 31;
|
|
int result = 1;
|
|
result = prime * result + ((conDir == null) ? 0 : conDir.hashCode());
|
|
result = prime * result + ((conduitLoc == null) ? 0 : conduitLoc.hashCode());
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (obj == null) {
|
|
return false;
|
|
}
|
|
if (getClass() != obj.getClass()) {
|
|
return false;
|
|
}
|
|
NetworkTank other = (NetworkTank) obj;
|
|
if (conDir != other.conDir) {
|
|
return false;
|
|
}
|
|
if (conduitLoc == null) {
|
|
if (other.conduitLoc != null) {
|
|
return false;
|
|
}
|
|
} else if (!conduitLoc.equals(other.conduitLoc)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|