From 7ced60c1a0943d198672ffb0f1690debc46126a7 Mon Sep 17 00:00:00 2001 From: HenryLoenwind Date: Sat, 7 Feb 2015 20:40:00 +0100 Subject: [PATCH] New way to insert items into inventories * Behaves more like expected; existing stacks are filled first * Unified code; only one implementationf for ISidedInventory and IInventory * Less resource intensive; objects are only created when really needed --- .../machine/vacuum/TileVacuumChest.java | 2 +- src/main/java/crazypants/util/ItemUtil.java | 170 +++++++++++------- 2 files changed, 102 insertions(+), 70 deletions(-) diff --git a/src/main/java/crazypants/enderio/machine/vacuum/TileVacuumChest.java b/src/main/java/crazypants/enderio/machine/vacuum/TileVacuumChest.java index 57a49c9f..4219f7c6 100644 --- a/src/main/java/crazypants/enderio/machine/vacuum/TileVacuumChest.java +++ b/src/main/java/crazypants/enderio/machine/vacuum/TileVacuumChest.java @@ -80,7 +80,7 @@ public class TileVacuumChest extends TileEntityEio implements IEntitySelector, I EntityItem item = (EntityItem) entity; ItemStack stack = item.getEntityItem().copy(); - int numInserted = ItemUtil.doInsertItem(this, stack); + int numInserted = ItemUtil.doInsertItem(this, stack, null); stack.stackSize -= numInserted; item.setEntityItemStack(stack); if(stack.stackSize == 0) { diff --git a/src/main/java/crazypants/util/ItemUtil.java b/src/main/java/crazypants/util/ItemUtil.java index f1840d10..d15cc760 100644 --- a/src/main/java/crazypants/util/ItemUtil.java +++ b/src/main/java/crazypants/util/ItemUtil.java @@ -47,9 +47,9 @@ public class ItemUtil { return 0; } if(into instanceof ISidedInventory) { - return ItemUtil.doInsertItem((ISidedInventory) into, item, side); + return ItemUtil.doInsertItemInv((ISidedInventory) into, item, side); } else if(into instanceof IInventory) { - return ItemUtil.doInsertItem(getInventory((IInventory) into), item); + return ItemUtil.doInsertItemInv(getInventory((IInventory) into), item, side); } else if(into instanceof IItemDuct) { return ItemUtil.doInsertItem((IItemDuct) into, item, side); } @@ -72,93 +72,77 @@ public class ItemUtil { return startedWith - remaining.stackSize; } - public static int doInsertItem(ISidedInventory sidedInv, ItemStack item, ForgeDirection inventorySide) { + /* + * Insert items into an IInventory or an ISidedInventory. + */ + private static int doInsertItemInv(IInventory inv, ItemStack item, ForgeDirection inventorySide) { + ISidedInventory sidedInv = inv instanceof ISidedInventory ? (ISidedInventory) inv : null; + ISlotIterator slots; - if(inventorySide == null) { - inventorySide = ForgeDirection.UNKNOWN; - } - - int[] slots = sidedInv.getAccessibleSlotsFromSide(inventorySide.ordinal()); - if(slots == null) { - return 0; + if (sidedInv != null) { + if(inventorySide == null) { + inventorySide = ForgeDirection.UNKNOWN; + } + slots = new sidedSlotter(sidedInv.getAccessibleSlotsFromSide(inventorySide.ordinal())); + } else { + slots = new invSlotter(inv.getSizeInventory()); } + int numInserted = 0; int numToInsert = item.stackSize; - for (int i = 0; i < slots.length && numToInsert > 0; i++) { - int slot = slots[i]; - if(sidedInv.canInsertItem(slot, item, inventorySide.ordinal())) { - ItemStack contents = sidedInv.getStackInSlot(slot); - ItemStack toInsert = item.copy(); - toInsert.stackSize = Math.min(toInsert.stackSize, sidedInv.getInventoryStackLimit()); - toInsert.stackSize = Math.min(toInsert.stackSize, toInsert.getMaxStackSize()); // some inventories like using itemstacks with invalid stack sizes - toInsert.stackSize = Math.min(toInsert.stackSize, numToInsert); - int inserted = 0; - if(contents == null) { - inserted = toInsert.stackSize; - } else { - if(contents.isItemEqual(item) && ItemStack.areItemStackTagsEqual(contents, item)) { - int space = sidedInv.getInventoryStackLimit() - contents.stackSize; - space = Math.min(space, contents.getMaxStackSize() - contents.stackSize); - inserted += Math.min(space, toInsert.stackSize); - toInsert.stackSize = contents.stackSize + inserted; - } else { - toInsert.stackSize = 0; - } - } - if(inserted > 0) { - numInserted += inserted; - numToInsert -= inserted; - sidedInv.setInventorySlotContents(slot, toInsert); + // PASS1: Try to add to an existing stack + while (numToInsert > 0 && slots.hasNext()) { + int slot = slots.nextSlot(); + if(sidedInv == null || sidedInv.canInsertItem(slot, item, inventorySide.ordinal())) { + ItemStack contents = inv.getStackInSlot(slot); + if(contents != null && areStackMergable(contents, item)) { + int freeSpace = Math.min(inv.getInventoryStackLimit(), contents.getMaxStackSize()) - contents.stackSize; // some inventories like using itemstacks with invalid stack sizes + if (freeSpace > 0) { + int noToInsert = Math.min(numToInsert, freeSpace); + ItemStack toInsert = item.copy(); + toInsert.stackSize = contents.stackSize + noToInsert; + // isItemValidForSlot() may check the stacksize, so give it the number the stack would have in the end. + // If it does something funny, like "only even numbers", we are screwed. + if(sidedInv != null || inv.isItemValidForSlot(slot, toInsert)) { + numInserted += noToInsert; + numToInsert -= noToInsert; + inv.setInventorySlotContents(slot, toInsert); + } + } } } } - if(numInserted > 0) { - sidedInv.markDirty(); - } - return numInserted; - } - public static int doInsertItem(IInventory inv, ItemStack item) { - int numInserted = 0; - int numToInsert = item.stackSize; - for (int slot = 0; slot < inv.getSizeInventory() && numToInsert > 0; slot++) { - ItemStack contents = inv.getStackInSlot(slot); - if(!isStackFull(contents)) { - ItemStack toInsert = item.copy(); - toInsert.stackSize = Math.min(toInsert.stackSize, inv.getInventoryStackLimit()); - toInsert.stackSize = Math.min(toInsert.stackSize, toInsert.getMaxStackSize()); // some inventories like using itemstacks with invalid stack sizes - toInsert.stackSize = Math.min(toInsert.stackSize, numToInsert); - int inserted = 0; + slots.reset(); + // PASS2: Try to insert into an empty slot + while (numToInsert > 0 && slots.hasNext()) { + int slot = slots.nextSlot(); + if(sidedInv == null || sidedInv.canInsertItem(slot, item, inventorySide.ordinal())) { + ItemStack contents = inv.getStackInSlot(slot); if(contents == null) { - inserted = toInsert.stackSize; - } else { - if(contents.isItemEqual(item) && ItemStack.areItemStackTagsEqual(contents, item)) { - int space = inv.getInventoryStackLimit() - contents.stackSize; - space = Math.min(space, contents.getMaxStackSize() - contents.stackSize); - inserted += Math.min(space, toInsert.stackSize); - toInsert.stackSize = contents.stackSize + inserted; - } else { - toInsert.stackSize = 0; + ItemStack toInsert = item.copy(); + toInsert.stackSize = min(numToInsert, inv.getInventoryStackLimit(), toInsert.getMaxStackSize()); // some inventories like using itemstacks with invalid stack sizes + if(sidedInv != null || inv.isItemValidForSlot(slot, toInsert)) { + numInserted += toInsert.stackSize; + numToInsert -= toInsert.stackSize; + inv.setInventorySlotContents(slot, toInsert); } } - if(!inv.isItemValidForSlot(slot, toInsert)) { - inserted = 0; - } - - if(inserted > 0) { - numInserted += inserted; - numToInsert -= inserted; - inv.setInventorySlotContents(slot, toInsert); - } } } + if(numInserted > 0) { inv.markDirty(); } return numInserted; + } + private static int min(int i1, int i2, int i3) { + return i1 < i2 ? (i1 < i3 ? i1 : i3) : (i2 < i3 ? i2 : i3); + } + public static boolean isStackFull(ItemStack contents) { if(contents == null) { return false; @@ -221,4 +205,52 @@ public class ItemUtil { return ItemStack.areItemStackTagsEqual(s1, s2); } + private interface ISlotIterator { + int nextSlot(); + boolean hasNext(); + void reset(); + } + + private static class invSlotter implements ISlotIterator { + final private int size; + private int current; + invSlotter(int size) { + this.size = size; + this.current = 0; + } + @Override + public int nextSlot() { + return current++; + } + @Override + public void reset() { + current = 0; + } + @Override + public boolean hasNext() { + return current < size; + } + } + + private static class sidedSlotter implements ISlotIterator { + final private int[] slots; + private int current; + sidedSlotter(int[] slots) { + this.slots = slots; + this.current = 0; + } + @Override + public int nextSlot() { + return slots[current++]; + } + @Override + public void reset() { + current = 0; + } + @Override + public boolean hasNext() { + return slots != null && current < slots.length; + } + } + }