Examples with ItemIdentifier logisticspipes.utils.item.ItemIdentifier used on opensource projects

Example 46 with ItemIdentifier

use of logisticspipes.utils.item.ItemIdentifier in project LogisticsPipes by RS485.

the class InventoryUtil method getItemsAndCount.

@Override
public Map<ItemIdentifier, Integer> getItemsAndCount() {
    Map<ItemIdentifier, Integer> items = new LinkedHashMap<>();
    for (int i = _cropStart; i < _inventory.getSizeInventory() - _cropEnd; i++) {
        ItemStack stack = _inventory.getStackInSlot(i);
        if (stack == null) {
            continue;
        }
        ItemIdentifier itemId = ItemIdentifier.get(stack);
        int stackSize = stack.stackSize - (_hideOnePerStack ? 1 : 0);
        Integer currentSize = items.get(itemId);
        if (currentSize == null) {
            items.put(itemId, stackSize - (_hideOne ? 1 : 0));
        } else {
            items.put(itemId, currentSize + stackSize);
        }
    }
    return items;
}

Example 47 with ItemIdentifier

use of logisticspipes.utils.item.ItemIdentifier in project LogisticsPipes by RS485.

the class NameLookupCommand method executeCommand.

@Override
public void executeCommand(ICommandSender sender, String[] args) {
    if (args.length < 2) {
        throw new MissingArgumentException();
    }
    String idString = args[0];
    String metaString = args[1];
    int id = Integer.valueOf(idString);
    int meta = Integer.valueOf(metaString);
    ItemIdentifier item = ItemIdentifier.get(Item.getItemById(id), meta, null);
    sender.addChatMessage(new ChatComponentText("Name: " + item.getFriendlyNameCC()));
}

Example 48 with ItemIdentifier

use of logisticspipes.utils.item.ItemIdentifier in project LogisticsPipes by RS485.

the class ModuleProvider method sendStack.

// returns -1 on permanently failed, don't try another stack this tick
// returns 0 on "unable to do this delivery"
private int sendStack(ItemIdentifierStack stack, int maxCount, int destination, IAdditionalTargetInformation info) {
    ItemIdentifier item = stack.getItem();
    IInventoryUtil inv = _service.getPointedInventory(_extractionMode, true);
    if (inv == null) {
        _service.getItemOrderManager().sendFailed();
        return 0;
    }
    int available = inv.itemCount(item);
    if (available == 0) {
        _service.getItemOrderManager().sendFailed();
        return 0;
    }
    int wanted = Math.min(available, stack.getStackSize());
    wanted = Math.min(wanted, maxCount);
    wanted = Math.min(wanted, item.getMaxStackSize());
    IRouter dRtr = SimpleServiceLocator.routerManager.getRouterUnsafe(destination, false);
    if (dRtr == null) {
        _service.getItemOrderManager().sendFailed();
        return 0;
    }
    SinkReply reply = LogisticsManager.canSink(dRtr, null, true, stack.getItem(), null, true, false);
    boolean defersend = false;
    if (reply != null) {
        // some pipes are not aware of the space in the adjacent inventory, so they return null
        if (reply.maxNumberOfItems < wanted) {
            wanted = reply.maxNumberOfItems;
            if (wanted <= 0) {
                _service.getItemOrderManager().deferSend();
                return 0;
            }
            defersend = true;
        }
    }
    if (!_service.canUseEnergy(wanted * neededEnergy())) {
        return -1;
    }
    ItemStack removed = inv.getMultipleItems(item, wanted);
    if (removed == null || removed.stackSize == 0) {
        _service.getItemOrderManager().sendFailed();
        return 0;
    }
    int sent = removed.stackSize;
    _service.useEnergy(sent * neededEnergy());
    IRoutedItem sendedItem = _service.sendStack(removed, destination, itemSendMode(), info);
    _service.getItemOrderManager().sendSuccessfull(sent, defersend, sendedItem);
    return sent;
}

Example 49 with ItemIdentifier

use of logisticspipes.utils.item.ItemIdentifier in project LogisticsPipes by RS485.

the class ModuleProvider method getAllItems.

@Override
public void getAllItems(Map<ItemIdentifier, Integer> items, List<IFilter> filters) {
    IInventoryUtil inv = _service.getPointedInventory(_extractionMode, true);
    if (inv == null) {
        return;
    }
    Map<ItemIdentifier, Integer> currentInv = inv.getItemsAndCount();
    //Skip already added items from this provider, skip filtered items, Reduce what has been reserved, add.
    outer: for (Entry<ItemIdentifier, Integer> currItem : currentInv.entrySet()) {
        if (items.containsKey(currItem.getKey())) {
            // Already provided by the previous module
            continue;
        }
        if (!filterAllowsItem(currItem.getKey())) {
            continue;
        }
        for (IFilter filter : filters) {
            if (filter.isBlocked() == filter.isFilteredItem(currItem.getKey().getUndamaged()) || filter.blockProvider()) {
                continue outer;
            }
        }
        int remaining = currItem.getValue() - _service.getItemOrderManager().totalItemsCountInOrders(currItem.getKey());
        if (remaining < 1) {
            continue;
        }
        items.put(currItem.getKey(), remaining);
    }
}

Example 50 with ItemIdentifier

use of logisticspipes.utils.item.ItemIdentifier in project LogisticsPipes by RS485.

the class ModuleQuickSort method tick.

@Override
public void tick() {
    if (--currentTick > 0) {
        return;
    }
    if (stalled) {
        currentTick = stalledDelay;
    } else {
        currentTick = normalDelay;
    }
    //Extract Item
    IInventoryUtil invUtil = _service.getPointedInventory(true);
    if (invUtil == null) {
        return;
    }
    if (!_service.canUseEnergy(500)) {
        stalled = true;
        return;
    }
    if (invUtil instanceof SpecialInventoryHandler) {
        Map<ItemIdentifier, Integer> items = invUtil.getItemsAndCount();
        if (lastSuceededStack >= items.size()) {
            lastSuceededStack = 0;
        }
        if (lastStackLookedAt >= items.size()) {
            lastStackLookedAt = 0;
        }
        int lookedAt = 0;
        for (Entry<ItemIdentifier, Integer> item : items.entrySet()) {
            // spool to current place
            lookedAt++;
            if (lookedAt <= lastStackLookedAt) {
                continue;
            }
            LinkedList<Integer> jamList = new LinkedList<>();
            Pair<Integer, SinkReply> reply = _service.hasDestination(item.getKey(), false, jamList);
            if (reply == null) {
                if (lastStackLookedAt == lastSuceededStack) {
                    stalled = true;
                }
                lastStackLookedAt++;
                return;
            }
            if (!_service.useEnergy(500)) {
                stalled = true;
                lastStackLookedAt++;
                return;
            }
            stalled = false;
            //send up to one stack
            int maxItemsToSend = item.getKey().getMaxStackSize();
            int availableItems = Math.min(maxItemsToSend, item.getValue());
            while (reply != null) {
                int count = availableItems;
                if (reply.getValue2().maxNumberOfItems != 0) {
                    count = Math.min(count, reply.getValue2().maxNumberOfItems);
                }
                ItemStack stackToSend = invUtil.getMultipleItems(item.getKey(), count);
                if (stackToSend == null || stackToSend.stackSize == 0) {
                    break;
                }
                availableItems -= stackToSend.stackSize;
                _service.sendStack(stackToSend, reply, ItemSendMode.Fast);
                _service.spawnParticle(Particles.OrangeParticle, 8);
                if (availableItems <= 0) {
                    break;
                }
                jamList.add(reply.getValue1());
                reply = _service.hasDestination(item.getKey(), false, jamList);
            }
            if (availableItems > 0) {
                //if we didn't send maxItemsToSend, try next item next time
                lastSuceededStack = lastStackLookedAt;
                lastStackLookedAt++;
            } else {
                lastSuceededStack = lastStackLookedAt - 1;
                if (lastSuceededStack < 0) {
                    lastSuceededStack = items.size() - 1;
                }
            }
            return;
        }
    } else {
        if ((!(invUtil instanceof SpecialInventoryHandler) && invUtil.getSizeInventory() == 0) || !_service.canUseEnergy(500)) {
            stalled = true;
            return;
        }
        if (lastSuceededStack >= invUtil.getSizeInventory()) {
            lastSuceededStack = 0;
        }
        //incremented at the end of the previous loop.
        if (lastStackLookedAt >= invUtil.getSizeInventory()) {
            lastStackLookedAt = 0;
        }
        ItemStack slot = invUtil.getStackInSlot(lastStackLookedAt);
        while (slot == null) {
            lastStackLookedAt++;
            if (lastStackLookedAt >= invUtil.getSizeInventory()) {
                lastStackLookedAt = 0;
            }
            slot = invUtil.getStackInSlot(lastStackLookedAt);
            if (lastStackLookedAt == lastSuceededStack) {
                stalled = true;
                send();
                // then we have been around the list without sending, halt for now
                return;
            }
        }
        send();
        // begin duplicate code
        List<Integer> jamList = new LinkedList<>();
        Pair<Integer, SinkReply> reply = _service.hasDestination(ItemIdentifier.get(slot), false, jamList);
        if (reply == null) {
            if (lastStackLookedAt == lastSuceededStack) {
                stalled = true;
            }
            lastStackLookedAt++;
            return;
        }
        if (!_service.useEnergy(500)) {
            stalled = true;
            lastStackLookedAt++;
            return;
        }
        stalled = false;
        //don't directly modify the stack in the inv
        int sizePrev;
        slot = slot.copy();
        sizePrev = slot.stackSize;
        boolean partialSend = false;
        while (reply != null) {
            int count = slot.stackSize;
            if (reply.getValue2().maxNumberOfItems > 0) {
                count = Math.min(count, reply.getValue2().maxNumberOfItems);
            }
            ItemStack stackToSend = slot.splitStack(count);
            _service.sendStack(stackToSend, reply, ItemSendMode.Fast);
            _service.spawnParticle(Particles.OrangeParticle, 8);
            if (slot.stackSize == 0) {
                break;
            }
            jamList.add(reply.getValue1());
            reply = _service.hasDestination(ItemIdentifier.get(slot), false, jamList);
        }
        ItemStack returned = null;
        int amountToExtract = sizePrev - slot.stackSize;
        if (slot.stackSize > 0) {
            partialSend = true;
        }
        returned = invUtil.decrStackSize(lastStackLookedAt, amountToExtract);
        if (returned.stackSize != amountToExtract) {
            throw new UnsupportedOperationException("Couldn't extract the already sended items from the inventory.");
        }
        lastSuceededStack = lastStackLookedAt;
        // end duplicate code
        lastStackLookedAt++;
        if (partialSend) {
            if (lastStackLookedAt >= invUtil.getSizeInventory()) {
                lastStackLookedAt = 0;
            }
            while (lastStackLookedAt != lastSuceededStack) {
                ItemStack tstack = invUtil.getStackInSlot(lastStackLookedAt);
                if (tstack != null && !slot.isItemEqual(tstack)) {
                    break;
                }
                lastStackLookedAt++;
                if (lastStackLookedAt >= invUtil.getSizeInventory()) {
                    lastStackLookedAt = 0;
                }
            }
        }
    }
}