Add specialized item storage for drawer groups, #591

src/main/java/com/raoulvdberge/refinedstorage/RSConfig.java

@@ -161,7 +161,7 @@ public final class RSConfig {
         wirelessGridExtractUsage = config.getInt("extract", WIRELESS_GRID, 3, 0, Integer.MAX_VALUE, "The energy used by the Wireless Grid to extract items");
         //endregion
 
-        //region Wireless Grid
+        //region Wireless Crafting Monitor
         wirelessCraftingMonitorUsesEnergy = config.getBoolean("usesEnergy", WIRELESS_CRAFTING_MONITOR, true, "Whether the Wireless Crafting Monitor uses energy");
         wirelessCraftingMonitorOpenUsage = config.getInt("open", WIRELESS_CRAFTING_MONITOR, 35, 0, Integer.MAX_VALUE, "The energy used by the Wireless Crafting Monitor to open");
         wirelessCraftingMonitorCancelUsage = config.getInt("cancel", WIRELESS_CRAFTING_MONITOR, 4, 0, Integer.MAX_VALUE, "The energy used by the Wireless Crafting Monitor to cancel a task");

src/main/java/com/raoulvdberge/refinedstorage/tile/TileController.java

@@ -571,7 +571,7 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
                 remainder = storage.insertItem(remainder, size, simulate);
             }
 
-            if (remainder == null || remainder.stackSize < 0) {
+            if (remainder == null || remainder.stackSize <= 0) {
                 if (storage instanceof ItemStorageExternal && !simulate) {
                     ((ItemStorageExternal) storage).updateForced();
                 }
@@ -600,6 +600,7 @@ public class TileController extends TileBase implements INetworkMaster, IEnergyR
 
         if (!simulate && inserted > 0 && accessType != AccessType.INSERT) {
             itemStorage.add(stack, inserted, false);
+
             ItemStack checkSteps = ItemHandlerHelper.copyStackWithSize(stack, inserted);
 
             for (ICraftingTask task : craftingTasks) {

src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/ItemStorageDrawer.java

@@ -27,6 +27,35 @@ public class ItemStorageDrawer extends ItemStorageExternal {
 
     @Override
     public List<ItemStack> getStacks() {
+        return getStacks(drawer);
+    }
+
+    @Override
+    public ItemStack insertItem(ItemStack stack, int size, boolean simulate) {
+        return insertItem(externalStorage, drawer, stack, size, simulate);
+    }
+
+    @Override
+    public ItemStack extractItem(ItemStack stack, int size, int flags, boolean simulate) {
+        return extractItem(drawer, stack, size, flags, simulate);
+    }
+
+    @Override
+    public int getStored() {
+        return drawer.getStoredItemCount();
+    }
+
+    @Override
+    public int getPriority() {
+        return externalStorage.getPriority();
+    }
+
+    @Override
+    public AccessType getAccessType() {
+        return externalStorage.getAccessType();
+    }
+
+    public static List<ItemStack> getStacks(IDrawer drawer) {
         if (!drawer.isEmpty() && drawer.getStoredItemCount() > 0) {
             return Collections.singletonList(drawer.getStoredItemCopy());
         }
@@ -34,12 +63,11 @@ public class ItemStorageDrawer extends ItemStorageExternal {
         return Collections.emptyList();
     }
 
-    private boolean isVoidable() {
+    public static boolean isVoidable(IDrawer drawer) {
-        return drawer instanceof IVoidable && ((IVoidable) drawer).isVoid();
+        return drawer instanceof IVoidable & ((IVoidable) drawer).isVoid();
     }
 
-    @Override
+    public static ItemStack insertItem(TileExternalStorage externalStorage, IDrawer drawer, ItemStack stack, int size, boolean simulate) {
-    public ItemStack insertItem(ItemStack stack, int size, boolean simulate) {
         if (IFilterable.canTake(externalStorage.getItemFilters(), externalStorage.getMode(), externalStorage.getCompare(), stack) && drawer.canItemBeStored(stack)) {
             int stored = drawer.getStoredItemCount();
             int remainingSpace = drawer.getMaxCapacity(stack) - stored;
@@ -60,7 +88,7 @@ public class ItemStorageDrawer extends ItemStorageExternal {
 
             int returnSize = size - inserted;
 
-            if (isVoidable()) {
+            if (isVoidable(drawer)) {
                 returnSize = -returnSize;
             }
 
@@ -70,8 +98,7 @@ public class ItemStorageDrawer extends ItemStorageExternal {
         return ItemHandlerHelper.copyStackWithSize(stack, size);
     }
 
-    @Override
+    public static ItemStack extractItem(IDrawer drawer, ItemStack stack, int size, int flags, boolean simulate) {
-    public ItemStack extractItem(ItemStack stack, int size, int flags, boolean simulate) {
         if (API.instance().getComparer().isEqual(stack, drawer.getStoredItemPrototype(), flags) && drawer.canItemBeExtracted(stack)) {
             if (size > drawer.getStoredItemCount()) {
                 size = drawer.getStoredItemCount();
@@ -82,25 +109,10 @@ public class ItemStorageDrawer extends ItemStorageExternal {
             if (!simulate) {
                 drawer.setStoredItemCount(drawer.getStoredItemCount() - size);
             }
-            
+
             return ItemHandlerHelper.copyStackWithSize(stored, size);
         }
 
         return null;
     }
-
-    @Override
-    public int getStored() {
-        return drawer.getStoredItemCount();
-    }
-
-    @Override
-    public int getPriority() {
-        return externalStorage.getPriority();
-    }
-
-    @Override
-    public AccessType getAccessType() {
-        return externalStorage.getAccessType();
-    }
 }

src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/ItemStorageDrawerGroup.java

@@ -0,0 +1,113 @@
+package com.raoulvdberge.refinedstorage.tile.externalstorage;
+
+import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawerGroup;
+import net.minecraft.item.ItemStack;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ItemStorageDrawerGroup extends ItemStorageExternal {
+    private TileExternalStorage externalStorage;
+    private IDrawerGroup drawers;
+
+    public ItemStorageDrawerGroup(TileExternalStorage externalStorage, IDrawerGroup drawers) {
+        this.externalStorage = externalStorage;
+        this.drawers = drawers;
+    }
+
+    @Override
+    public List<ItemStack> getStacks() {
+        List<ItemStack> stacks = new ArrayList<>();
+
+        for (int i = 0; i < drawers.getDrawerCount(); ++i) {
+            if (drawers.isDrawerEnabled(i)) {
+                stacks.addAll(ItemStorageDrawer.getStacks(drawers.getDrawer(i)));
+            }
+        }
+
+        return stacks;
+    }
+
+    @Override
+    public int getStored() {
+        int stored = 0;
+
+        for (int i = 0; i < drawers.getDrawerCount(); ++i) {
+            if (drawers.isDrawerEnabled(i)) {
+                stored += drawers.getDrawer(i).getStoredItemCount();
+            }
+        }
+
+        return stored;
+    }
+
+    @Override
+    public int getPriority() {
+        return externalStorage.getPriority();
+    }
+
+    @Override
+    public int getCapacity() {
+        int capacity = 0;
+
+        for (int i = 0; i < drawers.getDrawerCount(); ++i) {
+            if (drawers.isDrawerEnabled(i)) {
+                capacity += drawers.getDrawer(i).getMaxCapacity();
+            }
+        }
+
+        return capacity;
+    }
+
+    @Nullable
+    @Override
+    public ItemStack insertItem(@Nonnull ItemStack stack, int size, boolean simulate) {
+        ItemStack remainder = stack;
+
+        for (int i = 0; i < drawers.getDrawerCount(); ++i) {
+            if (drawers.isDrawerEnabled(i)) {
+                remainder = ItemStorageDrawer.insertItem(externalStorage, drawers.getDrawer(i), stack, size, simulate);
+
+                if (remainder == null || remainder.stackSize <= 0) {
+                    break;
+                } else {
+                    size = remainder.stackSize;
+                }
+            }
+        }
+
+        return remainder;
+    }
+
+    @Nullable
+    @Override
+    public ItemStack extractItem(@Nonnull ItemStack stack, int size, int flags, boolean simulate) {
+        int toExtract = size;
+
+        ItemStack result = null;
+
+        for (int i = 0; i < drawers.getDrawerCount(); ++i) {
+            if (drawers.isDrawerEnabled(i)) {
+                ItemStack extracted = ItemStorageDrawer.extractItem(drawers.getDrawer(i), stack, toExtract, flags, simulate);
+
+                if (extracted != null) {
+                    if (result == null) {
+                        result = extracted;
+                    } else {
+                        result.stackSize += extracted.stackSize;
+                    }
+
+                    toExtract -= extracted.stackSize;
+                }
+
+                if (toExtract == 0) {
+                    break;
+                }
+            }
+        }
+
+        return result;
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/ItemStorageExternal.java

@@ -33,7 +33,7 @@ public abstract class ItemStorageExternal implements IItemStorage {
                 ItemStack cached = cache.get(i);
 
                 if (cached != null && actual == null) {
-                    // If the cached is not null but the actual is, we removed this item
+                    // If the cached is not null but the actual is, we remove this item
                     network.getItemStorageCache().remove(cached, cached.stackSize);
                 } else if (cached == null && actual != null) {
                     // If the cached is null and the actual isn't, we added this item
@@ -45,13 +45,12 @@ public abstract class ItemStorageExternal implements IItemStorage {
                     network.getItemStorageCache().remove(cached, cached.stackSize);
                     network.getItemStorageCache().add(actual, actual.stackSize, false);
                 } else if (cached.stackSize != actual.stackSize) {
-                    // If both items mismatch on item count, apply the change
                     int delta = actual.stackSize - cached.stackSize;
 
                     if (delta > 0) {
-                        network.getItemStorageCache().add(cached, delta, false);
+                        network.getItemStorageCache().add(actual, delta, false);
                     } else {
-                        network.getItemStorageCache().remove(cached, delta);
+                        network.getItemStorageCache().remove(actual, Math.abs(delta));
                     }
                 }
             }

src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/TileExternalStorage.java

@@ -88,8 +88,6 @@ public class TileExternalStorage extends TileMultipartNode implements IItemStora
     private List<ItemStorageExternal> itemStorages = new ArrayList<>();
     private List<FluidStorageExternal> fluidStorages = new ArrayList<>();
 
-    private int lastDrawerCount;
-
     public TileExternalStorage() {
         dataManager.addWatchedParameter(PRIORITY);
         dataManager.addWatchedParameter(COMPARE);
@@ -129,11 +127,11 @@ public class TileExternalStorage extends TileMultipartNode implements IItemStora
     @Override
     public void update() {
         if (!worldObj.isRemote && network != null) {
-            if (networkTicks == 0) {
+            if (networkTicks++ == 0) {
                 updateStorage(network);
-            }
 
-            networkTicks++;
+                return;
+            }
 
             for (ItemStorageExternal storage : itemStorages) {
                 storage.detectChanges(network);
@@ -150,12 +148,6 @@ public class TileExternalStorage extends TileMultipartNode implements IItemStora
             if (fluidChangeDetected) {
                 network.getFluidStorageCache().invalidate();
             }
-
-            if (getFacingTile() instanceof IDrawerGroup && lastDrawerCount != ((IDrawerGroup) getFacingTile()).getDrawerCount()) {
-                lastDrawerCount = ((IDrawerGroup) getFacingTile()).getDrawerCount();
-
-                updateStorage(network);
-            }
         }
 
         super.update();
@@ -248,13 +240,7 @@ public class TileExternalStorage extends TileMultipartNode implements IItemStora
 
         if (type == IType.ITEMS) {
             if (facing instanceof IDrawerGroup) {
-                IDrawerGroup group = (IDrawerGroup) facing;
+                itemStorages.add(new ItemStorageDrawerGroup(this, (IDrawerGroup) facing));
-
-                for (int i = 0; i < group.getDrawerCount(); ++i) {
-                    if (group.isDrawerEnabled(i)) {
-                        itemStorages.add(new ItemStorageDrawer(this, group.getDrawer(i)));
-                    }
-                }
             } else if (facing instanceof IDrawer) {
                 itemStorages.add(new ItemStorageDrawer(this, (IDrawer) facing));
             } else if (facing instanceof IDeepStorageUnit) {