public IItemHandler getItemHandler(EnumFacing face) { if (InventoryHelper.hasItemHandlerCap(tile, face)) { IItemHandler capability = InventoryHelper.getItemHandlerCap(tile, face); if (capability != null) { return capability; } } return EmptyHandler.INSTANCE; }
public static ItemStack insertStackIntoInventory(IItemHandler handler, ItemStack stack, boolean simulate) { return insertStackIntoInventory(handler, stack, simulate, false); }
@Override public boolean isEmpty() { return InventoryHelper.isEmpty(stackList); }
public static ItemStack addToInventory(TileEntity tile, EnumFacing side, ItemStack stack) { if (stack.isEmpty()) { return ItemStack.EMPTY; } if (hasItemHandlerCap(tile, side.getOpposite())) { stack = insertStackIntoInventory(getItemHandlerCap(tile, side.getOpposite()), stack, false); } return stack; }
protected boolean outputBuffer() { if (getTransferOut()) { for (int i = 0; i < 6; i++) { if (sideCache[i] == 1) { EnumFacing side = EnumFacing.VALUES[i]; TileEntity curTile = BlockHelper.getAdjacentTileEntity(this, side); /* Add to Adjacent Inventory */ if (InventoryHelper.isAccessibleOutput(curTile, side)) { LinkedList<ItemStack> newStuffed = new LinkedList<>(); for (ItemStack curItem : stuffedItems) { if (curItem.isEmpty()) { curItem = ItemStack.EMPTY; } else { curItem = InventoryHelper.addToInventory(curTile, side, curItem); } if (!curItem.isEmpty()) { newStuffed.add(curItem); } } stuffedItems = newStuffed; } } } } return isStuffingEmpty(); }
TileEntity adjInv = BlockHelper.getAdjacentTileEntity(this, side); if (InventoryHelper.isAccessibleInput(adjInv, side)) { IItemHandler inv = InventoryHelper.getItemHandlerCap(adjInv, side.getOpposite()); if (inv == null) { return false;
public IItemHandler getCachedInv() { if (myTile == null) { return EmptyHandler.INSTANCE; } IItemHandler handler = InventoryHelper.getItemHandlerCap(myTile, EnumFacing.VALUES[side ^ 1]); return handler == null ? EmptyHandler.INSTANCE : handler; }
@Nullable @Override public Cache cacheTile(@Nonnull TileEntity tile, byte side) { Attachment attachment = parent.getAttachment(side); if (attachment != null && !attachment.allowDuctConnection()) { return null; } if (InventoryHelper.hasItemHandlerCap(tile, EnumFacing.VALUES[side ^ 1])) { return new Cache(tile, attachment); } return null; }
/** * Shortcut method for above, assumes ending slot is length - 1 */ public static boolean addItemStackToInventory(ItemStack[] inventory, ItemStack stack, int startIndex) { return addItemStackToInventory(inventory, stack, startIndex, inventory.length - 1); }
@Override protected boolean mergeItemStack(ItemStack stack, int slotMin, int slotMax, boolean ascending) { return InventoryHelper.mergeItemStack(this.inventorySlots, stack, slotMin, slotMax, ascending); }
public boolean transferItem(int slot, int amount, EnumFacing side) { if (inventory[slot].isEmpty() || slot > inventory.length) { return false; } ItemStack initialStack = inventory[slot].copy(); initialStack.setCount(Math.min(amount, initialStack.getCount())); TileEntity adjInv = BlockHelper.getAdjacentTileEntity(this, side); if (InventoryHelper.isAccessibleOutput(adjInv, side)) { ItemStack inserted = InventoryHelper.addToInventory(adjInv, side, initialStack); if (inserted.getCount() >= initialStack.getCount()) { return false; } inventory[slot].shrink(initialStack.getCount() - inserted.getCount()); if (inventory[slot].getCount() <= 0) { inventory[slot] = ItemStack.EMPTY; } return true; } return false; }
/** * Shortcut method for above, assumes starting slot is 0. */ public static boolean addItemStackToInventory(ItemStack[] inventory, ItemStack stack) { return addItemStackToInventory(inventory, stack, 0); }
public static boolean mergeItemStack(List<Slot> slots, ItemStack stack, int start, int length, boolean reverse) { return mergeItemStack(slots, stack, start, length, reverse, true); }
public boolean areEquivalentHandlers(@Nonnull IItemHandler itemHandler, int side) { EnumFacing facing = EnumFacing.VALUES[side]; return InventoryHelper.hasItemHandlerCap(tile, facing) && itemHandler.equals(InventoryHelper.getItemHandlerCap(tile, facing)); } }
@Override public boolean isEmpty() { return InventoryHelper.isEmpty(stackList); }
public static ItemStack insertItemStackIntoInventory(IItemHandler inventory, ItemStack stack, int side, int cap) { if (cap < 0 || cap == Integer.MAX_VALUE) { return InventoryHelper.insertStackIntoInventory(inventory, stack, false); } int toInsert = cap - getNumItems(inventory, side, stack, cap); if (toInsert <= 0) { return stack; } if (stack.getCount() < toInsert) { return InventoryHelper.insertStackIntoInventory(inventory, stack, false); } else { ItemStack remaining = InventoryHelper.insertStackIntoInventory(inventory, stack.splitStack(toInsert), false); if (!remaining.isEmpty()) { stack.grow(remaining.getCount()); } return stack; } }
public static boolean isAccessibleInput(TileEntity tile, EnumFacing side) { return hasItemHandlerCap(tile, side.getOpposite()) && getItemHandlerCap(tile, side.getOpposite()).getSlots() > 0; }
@Override public boolean isEmpty() { return InventoryHelper.isEmpty(inventory); }
public static ItemStack simulateInsertItemStackIntoInventory(IItemHandler inventory, ItemStack stack, int side, int cap) { if (cap < 0 || cap == Integer.MAX_VALUE) { return InventoryHelper.insertStackIntoInventory(inventory, stack, true); } int toInsert = cap - getNumItems(inventory, side, stack, cap); if (toInsert <= 0) { return stack; } if (stack.getCount() <= toInsert) { return InventoryHelper.insertStackIntoInventory(inventory, stack, true); } else { ItemStack remaining = InventoryHelper.insertStackIntoInventory(inventory, stack.splitStack(toInsert), true); if (!remaining.isEmpty()) { stack.grow(remaining.getCount()); } return stack; } }
public static boolean isAccessibleOutput(TileEntity tile, EnumFacing side) { return hasItemHandlerCap(tile, side.getOpposite()) && getItemHandlerCap(tile, side.getOpposite()).getSlots() > 0; }