Hi everyone.

I'm having some difficulty with Inventory management for machines. Basically, it started out as pipes pulling from both the "input" and "output" slots, so I extended ItemStackHandler to this:

Now, it works in that pipes can no longer take the input, but a new problem has occurred within the GUI container: I can no longer take the input item out by dragging it! 

 

public class InventoryHandlerEx extends ItemStackHandler {


    SlotInfo[] slotInformation;

    public InventoryHandlerEx()
    {
        super(1);

        slotInformation = new SlotInfo[1];


    }
    public InventoryHandlerEx(int size) {
        super(size);

        slotInformation = new SlotInfo[size];

    }


    @Override
    @Nonnull
    public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate)
    {


        if (!canInsert(slot))
            return stack;


        return super.insertItem(slot,stack,simulate);
    }

    @Override
    @Nonnull
    public ItemStack extractItem(int slot, int amount, boolean simulate)
    {

        if (slot == 0)
            return ItemStack.EMPTY;

        if (!canExtract(slot))
            return ItemStack.EMPTY;

        return super.extractItem(slot,amount,simulate);

    }

    public boolean canInsert(int slot)
    {
        return slotInformation[slot].insert == true ? true : false;
    }

    public boolean canExtract(int slot)
    {
        return slotInformation[slot].extract == true ? true : false;
    }

    public void setSlotInformation(int slot, SlotInfo info)
    {
        slotInformation[slot] = info;
    }

Container Code:
 

public class ContainerTest<T extends BaseTile> extends Container {

    private T te;
    private IInventory pi;


    private int[] cachedFields;


    public ContainerTest(IInventory playerInventory, T te)
    {
        this.te = te;
        this.pi = playerInventory;
        addPlayerSlots(playerInventory);
        addOwnSlots();

    }


    private void addPlayerSlots(IInventory playerInventory) {
        // Slots for the main inventory
        for (int row = 0; row < 3; ++row) {
            for (int col = 0; col < 9; ++col) {
                int x = 8 + col * 18;
                int y = row * 18 + 84;
                this.addSlotToContainer(new Slot(playerInventory, col + row * 9 + 10, x, y));
            }
        }

        // Slots for the hotbar
        for (int row = 0; row < 9; ++row) {
            int x = 8 + row * 18;
            int y = 72 + 70;
            this.addSlotToContainer(new Slot(playerInventory, row, x, y));
        }
    }

    private void addOwnSlots() {
        //((T)this.te).
        InventoryHandlerEx itemHandler = (InventoryHandlerEx)this.te.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
        //IItemHandler itemHandler = this.te.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
        int x = 80;
        int y = 12;

        addSlotToContainer(new SlotItemHandler(itemHandler,0,80,12));
        addSlotToContainer(new SlotOutput(itemHandler,1,80,58));

        /*
        // Add our own slots
        int slotIndex = 0;
        for (int i = 0; i < itemHandler.getSlots(); i++) {
            addSlotToContainer(new SlotItemHandler(itemHandler, slotIndex, x, y));
            slotIndex++;
            //x += 18;
            y += 46;
        }
        */
    }

    @Override
    public ItemStack transferStackInSlot(EntityPlayer player, int index)
    {
        ItemStack itemstack = ItemStack.EMPTY;
        Slot slot = inventorySlots.get(index);





        if (slot != null && slot.getHasStack()) {
            ItemStack itemstack1 = slot.getStack();
            itemstack = itemstack1.copy();

            int containerSlots = inventorySlots.size() - player.inventory.mainInventory.size();

            if (index < containerSlots) {
                if (!this.mergeItemStack(itemstack1, containerSlots, inventorySlots.size(), true)) {
                    return ItemStack.EMPTY;
                }
            } else if (!this.mergeItemStack(itemstack1, 0, containerSlots, false)) {
                return ItemStack.EMPTY;
            }

            if (itemstack1.getCount() == 0) {
                slot.putStack(ItemStack.EMPTY);
            } else {
                slot.onSlotChanged();
            }

            if (itemstack1.getCount() == itemstack.getCount()) {
                return ItemStack.EMPTY;
            }

            slot.onTake(player, itemstack1);
        }

        return itemstack;

    }

    @Override
    public void detectAndSendChanges() {
        super.detectAndSendChanges();

        boolean allFieldsHaveChanged = false;
        boolean[] fieldHasChanged = new boolean[te.getFieldCount()];

        if (cachedFields == null)
        {
            allFieldsHaveChanged = true;
            cachedFields = new int[te.getFieldCount()];
        }

        for (int i = 0;i < cachedFields.length;i++)
        {
            if (allFieldsHaveChanged || cachedFields[i] != te.getField(i))
            {
                cachedFields[i] = te.getField(i);
                fieldHasChanged[i] = true;
            }
        }

        for (IContainerListener temp : listeners)
        {
            for (int fID = 0; fID < te.getFieldCount();fID++)
            {
                if (fieldHasChanged[fID])
                {
                    temp.sendWindowProperty(this,fID,cachedFields[fID]);
                }
            }
        }

    }


    @SideOnly(Side.CLIENT)
    @Override
    public void updateProgressBar(int id, int data) {
        te.setField(id, data);
    }



    @Override
    public boolean canInteractWith(EntityPlayer playerIn) {
        return true;//te.canInteractWith(playerIn);
    }

How would I go about letting (only) the GUI be able to click/shift-click/drag the input items out?

Edited April 22, 20196 yr by Munku
Holy formatting batman!

That's why I have this class:

https://github.com/Draco18s/ReasonableRealism/blob/1.12.1/src/main/java/com/draco18s/hardlib/api/internal/CommonContainer.java

I solved it once, never need to mess with it ever again. 

The issue here is that SlotItemHandler references IItemHandler#extractItem to check whether the item can be extracted and since you are using one custom IItemHandler that will always return something based on the slot id it returns false and you can't extract items from the slot.

You need to return a wrapper based on the side your capability is accessed from. If it is accessed from a null side chances are it's your container or something else that should always have access to all slots regardless. Pipes will never pass null.

Edited April 23, 20196 yr by V0idWa1k3r