Examples with ITankUtil logisticspipes.interfaces.ITankUtil used on opensource projects

Example 1 with ITankUtil

use of logisticspipes.interfaces.ITankUtil in project LogisticsPipes by RS485.

the class FluidRoutedPipe method endReached.

public boolean endReached(LPTravelingItemServer arrivingItem, TileEntity tile) {
    if (canInsertToTanks() && MainProxy.isServer(getWorld())) {
        getCacheHolder().trigger(CacheTypes.Inventory);
        if (arrivingItem.getItemIdentifierStack() == null || !(arrivingItem.getItemIdentifierStack().getItem().isFluidContainer())) {
            return false;
        }
        if (getRouter().getSimpleID() != arrivingItem.getDestination()) {
            return false;
        }
        int filled;
        FluidIdentifierStack liquid = SimpleServiceLocator.logisticsFluidManager.getFluidFromContainer(arrivingItem.getItemIdentifierStack());
        if (isConnectableTank(tile, arrivingItem.output, false)) {
            // Try to put liquid into all adjacent tanks.
            for (Pair<NeighborTileEntity<TileEntity>, ITankUtil> util : PipeFluidUtil.INSTANCE.getAdjacentTanks(this, false)) {
                filled = util.getValue2().fill(liquid, true);
                liquid.lowerAmount(filled);
                if (liquid.getAmount() != 0) {
                    continue;
                }
                return true;
            }
            // Try inserting the liquid into the pipe side tank
            filled = ((PipeFluidTransportLogistics) transport).sideTanks[arrivingItem.output.ordinal()].fill(liquid.makeFluidStack(), true);
            if (filled == liquid.getAmount()) {
                return true;
            }
            liquid.lowerAmount(filled);
        }
        // Try inserting the liquid into the pipe internal tank
        filled = ((PipeFluidTransportLogistics) transport).internalTank.fill(liquid.makeFluidStack(), true);
        if (filled == liquid.getAmount()) {
            return true;
        }
        // If liquids still exist,
        liquid.lowerAmount(filled);
        // TODO: FIX THIS
        if (this instanceof IRequireReliableFluidTransport) {
            ((IRequireReliableFluidTransport) this).liquidNotInserted(liquid.getFluid(), liquid.getAmount());
        }
        IRoutedItem routedItem = SimpleServiceLocator.routedItemHelper.createNewTravelItem(SimpleServiceLocator.logisticsFluidManager.getFluidContainer(liquid));
        Pair<Integer, FluidSinkReply> replies = SimpleServiceLocator.logisticsFluidManager.getBestReply(liquid, getRouter(), routedItem.getJamList());
        if (replies == null) {
            // clear destination without marking item as lost
            routedItem.setDestination(0);
        } else {
            int dest = replies.getValue1();
            routedItem.setDestination(dest);
        }
        routedItem.setTransportMode(TransportMode.Passive);
        this.queueRoutedItem(routedItem, arrivingItem.output.getOpposite());
        return true;
    }
    return false;
}

Example 2 with ITankUtil

use of logisticspipes.interfaces.ITankUtil in project LogisticsPipes by RS485.

the class PipeFluidProvider method collectSpecificInterests.

@Override
public // work in progress, currently not active code.
void collectSpecificInterests(@Nonnull Collection<ItemIdentifier> itemidCollection) {
    for (Pair<NeighborTileEntity<TileEntity>, ITankUtil> pair : PipeFluidUtil.INSTANCE.getAdjacentTanks(this, false)) {
        boolean fallback = true;
        if (pair.getValue2() instanceof ISpecialTankUtil) {
            final ISpecialTankUtil util = (ISpecialTankUtil) pair.getValue2();
            fallback = false;
            ISpecialTankAccessHandler handler = util.getSpecialHandler();
            TileEntity tile = util.getTileEntity();
            handler.getAvailableLiquid(tile).keySet().stream().map(FluidIdentifier::getItemIdentifier).forEach(itemidCollection::add);
        }
        if (fallback) {
            if (pair.getValue2().containsTanks()) {
                pair.getValue2().tanks().map(tank -> FluidIdentifierStack.getFromStack(tank.getContents())).forEach(liquid -> {
                    if (liquid != null && liquid.getFluid() != null) {
                        if (pair.getValue2().canDrain(liquid.getFluid())) {
                            if (pair.getValue2().drain(1, false) != null) {
                                FluidIdentifier ident = liquid.getFluid();
                                itemidCollection.add(ident.getItemIdentifier());
                            }
                        }
                    }
                });
            }
        }
    }
}

Example 3 with ITankUtil

use of logisticspipes.interfaces.ITankUtil in project LogisticsPipes by RS485.

the class PipeFluidProvider method getAvailableFluids.

@Override
public Map<FluidIdentifier, Integer> getAvailableFluids() {
    Map<FluidIdentifier, Integer> map = new HashMap<>();
    for (Pair<NeighborTileEntity<TileEntity>, ITankUtil> pair : PipeFluidUtil.INSTANCE.getAdjacentTanks(this, false)) {
        boolean fallback = true;
        if (pair.getValue2() instanceof ISpecialTankUtil) {
            final ISpecialTankUtil util = (ISpecialTankUtil) pair.getValue2();
            fallback = false;
            ISpecialTankAccessHandler handler = util.getSpecialHandler();
            TileEntity tile = util.getTileEntity();
            Map<FluidIdentifier, Long> tmp = handler.getAvailableLiquid(tile);
            for (Entry<FluidIdentifier, Long> entry : tmp.entrySet()) {
                if (map.containsKey(entry.getKey())) {
                    long addition = ((long) map.get(entry.getKey())) + entry.getValue();
                    map.put(entry.getKey(), addition > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) addition);
                } else {
                    map.put(entry.getKey(), entry.getValue() > Integer.MAX_VALUE ? Integer.MAX_VALUE : entry.getValue().intValue());
                }
            }
        }
        if (fallback) {
            if (pair.getValue2().containsTanks()) {
                pair.getValue2().tanks().map(tank -> FluidIdentifierStack.getFromStack(tank.getContents())).forEach(liquid -> {
                    if (liquid != null && liquid.getFluid() != null) {
                        FluidIdentifier ident = liquid.getFluid();
                        if (pair.getValue2().canDrain(ident)) {
                            if (pair.getValue2().drain(ident.makeFluidIdentifierStack(1), false) != null) {
                                if (map.containsKey(ident)) {
                                    long addition = ((long) map.get(ident)) + liquid.getAmount();
                                    map.put(ident, addition > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) addition);
                                } else {
                                    map.put(ident, liquid.getAmount());
                                }
                            }
                        }
                    }
                });
            }
        }
    }
    Map<FluidIdentifier, Integer> result = new HashMap<>();
    // Reduce what has been reserved, add.
    for (Entry<FluidIdentifier, Integer> fluid : map.entrySet()) {
        int remaining = fluid.getValue() - getFluidOrderManager().totalFluidsCountInOrders(fluid.getKey());
        if (remaining < 1) {
            continue;
        }
        result.put(fluid.getKey(), remaining);
    }
    return result;
}

Example 4 with ITankUtil

use of logisticspipes.interfaces.ITankUtil in project LogisticsPipes by RS485.

the class PipeFluidProvider method enabledUpdateEntity.

@Override
public void enabledUpdateEntity() {
    super.enabledUpdateEntity();
    if (!getFluidOrderManager().hasOrders(ResourceType.PROVIDER) || !isNthTick(6)) {
        return;
    }
    LogisticsFluidOrder order = getFluidOrderManager().peekAtTopRequest(ResourceType.PROVIDER);
    AtomicInteger amountToSend = new AtomicInteger();
    AtomicInteger attemptedAmount = new AtomicInteger();
    amountToSend.set(Math.min(order.getAmount(), 5000));
    attemptedAmount.set(Math.min(order.getAmount(), 5000));
    for (Pair<NeighborTileEntity<TileEntity>, ITankUtil> pair : PipeFluidUtil.INSTANCE.getAdjacentTanks(this, false)) {
        if (amountToSend.get() <= 0) {
            break;
        }
        boolean fallback = true;
        if (pair.getValue2() instanceof ISpecialTankUtil) {
            ISpecialTankUtil util = (ISpecialTankUtil) pair.getValue2();
            fallback = false;
            ISpecialTankAccessHandler handler = util.getSpecialHandler();
            FluidStack drained = handler.drainFrom(pair.getValue1().getTileEntity(), order.getFluid(), amountToSend.get(), false);
            if (drained != null && drained.amount > 0 && order.getFluid().equals(FluidIdentifier.get(drained))) {
                drained = handler.drainFrom(pair.getValue1().getTileEntity(), order.getFluid(), amountToSend.get(), true);
                int amount = drained.amount;
                amountToSend.addAndGet(-amount);
                ItemIdentifierStack stack = SimpleServiceLocator.logisticsFluidManager.getFluidContainer(FluidIdentifierStack.getFromStack(drained));
                IRoutedItem item = SimpleServiceLocator.routedItemHelper.createNewTravelItem(stack);
                item.setDestination(order.getRouter().getSimpleID());
                item.setTransportMode(TransportMode.Active);
                this.queueRoutedItem(item, pair.getValue1().getDirection());
                getFluidOrderManager().sendSuccessfull(amount, false, item);
                if (amountToSend.get() <= 0) {
                    break;
                }
            }
        }
        if (fallback) {
            if (pair.getValue2().containsTanks()) {
                pair.getValue2().tanks().map(tank -> FluidIdentifierStack.getFromStack(tank.getContents())).forEach(fluidStack -> {
                    if (amountToSend.get() <= 0) {
                        return;
                    }
                    if (fluidStack != null && fluidStack.getFluid() != null) {
                        if (order.getFluid().equals(fluidStack.getFluid())) {
                            int amount = Math.min(fluidStack.getAmount(), amountToSend.get());
                            FluidIdentifierStack drained = pair.getValue2().drain(amount, false);
                            if (drained != null && drained.getAmount() > 0 && order.getFluid().equals(drained.getFluid())) {
                                drained = pair.getValue2().drain(amount, true);
                                while (drained.getAmount() < amountToSend.get()) {
                                    FluidIdentifierStack addition = pair.getValue2().drain(amountToSend.get() - drained.getAmount(), false);
                                    if (addition != null && addition.getAmount() > 0 && order.getFluid().equals(addition.getFluid())) {
                                        addition = pair.getValue2().drain(amountToSend.get() - drained.getAmount(), true);
                                        drained.raiseAmount(addition.getAmount());
                                    } else {
                                        break;
                                    }
                                }
                                amount = drained.getAmount();
                                amountToSend.addAndGet(-amount);
                                ItemIdentifierStack stack = SimpleServiceLocator.logisticsFluidManager.getFluidContainer(drained);
                                IRoutedItem item = SimpleServiceLocator.routedItemHelper.createNewTravelItem(stack);
                                item.setDestination(order.getRouter().getSimpleID());
                                item.setTransportMode(TransportMode.Active);
                                queueRoutedItem(item, pair.getValue1().getDirection());
                                getFluidOrderManager().sendSuccessfull(amount, false, item);
                            }
                        }
                    }
                });
            }
        }
    }
    if (amountToSend.get() >= attemptedAmount.get()) {
        getFluidOrderManager().sendFailed();
    }
}

Example 5 with ITankUtil

use of logisticspipes.interfaces.ITankUtil in project LogisticsPipes by RS485.

the class FluidRoutedPipe method enabledUpdateEntity.

@Override
public void enabledUpdateEntity() {
    super.enabledUpdateEntity();
    if (canInsertFromSideToTanks()) {
        int validDirections = 0;
        final List<Pair<NeighborTileEntity<TileEntity>, ITankUtil>> list = PipeFluidUtil.INSTANCE.getAdjacentTanks(this, true);
        for (Pair<NeighborTileEntity<TileEntity>, ITankUtil> pair : list) {
            if (pair.getValue2() instanceof LogisticsTileGenericPipe) {
                if (((LogisticsTileGenericPipe) pair.getValue2()).pipe instanceof CoreRoutedPipe) {
                    continue;
                }
            }
            FluidTank internalTank = ((PipeFluidTransportLogistics) transport).sideTanks[pair.getValue1().getDirection().ordinal()];
            validDirections++;
            if (internalTank.getFluid() == null) {
                continue;
            }
            int filled = pair.getValue2().fill(FluidIdentifierStack.getFromStack(internalTank.getFluid()), true);
            if (filled == 0) {
                continue;
            }
            FluidStack drain = internalTank.drain(filled, true);
            if (drain == null || filled != drain.amount) {
                if (LogisticsPipes.isDEBUG()) {
                    throw new UnsupportedOperationException("Fluid Multiplication");
                }
            }
        }
        if (validDirections == 0) {
            return;
        }
        FluidTank tank = ((PipeFluidTransportLogistics) transport).internalTank;
        FluidStack stack = tank.getFluid();
        if (stack == null) {
            return;
        }
        for (Pair<NeighborTileEntity<TileEntity>, ITankUtil> pair : list) {
            if (pair.getValue1().isLogisticsPipe()) {
                if (((LogisticsTileGenericPipe) pair.getValue1().getTileEntity()).pipe instanceof CoreRoutedPipe) {
                    continue;
                }
            }
            FluidTank tankSide = ((PipeFluidTransportLogistics) transport).sideTanks[pair.getValue1().getDirection().ordinal()];
            stack = tank.getFluid();
            if (stack == null) {
                continue;
            }
            stack = stack.copy();
            int filled = tankSide.fill(stack, true);
            if (filled == 0) {
                continue;
            }
            FluidStack drain = tank.drain(filled, true);
            if (drain == null || filled != drain.amount) {
                if (LogisticsPipes.isDEBUG()) {
                    throw new UnsupportedOperationException("Fluid Multiplication");
                }
            }
        }
    }
}