Merge pull request #360 from way2muchnoise/mc1.10

Finish Disk Manipulator

src/main/java/refinedstorage/gui/GuiBase.java

@@ -93,7 +93,7 @@ public abstract class GuiBase extends GuiContainer {
             Slot slot = inventorySlots.inventorySlots.get(i);
 
             if (slot instanceof SlotItemHandler && ((SlotItemHandler) slot).getItemHandler() instanceof ItemHandlerFluid) {
-                FluidStack stack = ((ItemHandlerFluid) ((SlotItemHandler) slot).getItemHandler()).getFluids()[slot.getSlotIndex()];
+                FluidStack stack = ((ItemHandlerFluid) ((SlotItemHandler) slot).getItemHandler()).getFluidStackInSlot(slot.getSlotIndex());
 
                 if (stack != null) {
                     FLUID_RENDERER.draw(mc, guiLeft + slot.xDisplayPosition, guiTop + slot.yDisplayPosition, stack);

src/main/java/refinedstorage/gui/GuiDiskManipulator.java

@@ -36,5 +36,7 @@ public class GuiDiskManipulator extends GuiBase {
     public void drawForeground(int mouseX, int mouseY) {
         drawString(7, 7, t("block.refinedstorage:disk_manipulator.name"));
         drawString(7, 117, t("container.inventory"));
+        drawString(25, 45, t("gui.refinedstorage:fluid_interface.in"));
+        drawString(115, 45, t("gui.refinedstorage:fluid_interface.out"));
     }
 }

src/main/java/refinedstorage/inventory/ItemHandlerFluid.java

@@ -28,6 +28,10 @@ public class ItemHandlerFluid extends ItemHandlerBasic {
         }
     }
 
+    public FluidStack getFluidStackInSlot(int slot) {
+        return fluids[slot];
+    }
+
     public FluidStack[] getFluids() {
         return fluids;
     }

src/main/java/refinedstorage/proxy/CommonProxy.java

@@ -39,7 +39,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class CommonProxy {
-    public static final boolean ENABLE_DISK_MANIPULATOR = false;
+    public static final boolean ENABLE_DISK_MANIPULATOR = true;
 
     protected List<BlockCable> cableTypes = new ArrayList<>();
 

src/main/java/refinedstorage/tile/TileConstructor.java

@@ -92,7 +92,7 @@ public class TileConstructor extends TileMultipartNode implements IComparable, I
                     }
                 }
             } else if (type == IType.FLUIDS) {
-                FluidStack stack = fluidFilters.getFluids()[0];
+                FluidStack stack = fluidFilters.getFluidStackInSlot(0);
 
                 if (stack != null && stack.getFluid().canBePlacedInWorld()) {
                     BlockPos front = pos.offset(getDirection());

src/main/java/refinedstorage/tile/TileDetector.java

@@ -136,7 +136,7 @@ public class TileDetector extends TileNode implements IComparable, IType {
                     powered = mode == MODE_AUTOCRAFTING && !network.getCraftingTasks().isEmpty();
                 }
             } else if (type == IType.FLUIDS) {
-                FluidStack slot = fluidFilters.getFluids()[0];
+                FluidStack slot = fluidFilters.getFluidStackInSlot(0);
 
                 if (slot != null) {
                     FluidStack stack = network.getFluidStorage().get(slot, compare);

src/main/java/refinedstorage/tile/TileDiskManipulator.java

@@ -27,6 +27,8 @@ import refinedstorage.tile.data.ITileDataConsumer;
 import refinedstorage.tile.data.ITileDataProducer;
 import refinedstorage.tile.data.TileDataParameter;
 
+import java.util.ArrayList;
+
 public class TileDiskManipulator extends TileNode implements IComparable, IFilterable, IType {
     public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
     public static final TileDataParameter<Integer> MODE = IFilterable.createParameter();
@@ -49,6 +51,7 @@ public class TileDiskManipulator extends TileNode implements IComparable, IFilte
     private static final String NBT_COMPARE = "Compare";
     private static final String NBT_MODE = "Mode";
     private static final String NBT_TYPE = "Type";
+    private static final String NBT_IO_MODE = "IOMode";
 
     private int compare = 0;
     private int mode = IFilterable.WHITELIST;
@@ -190,28 +193,63 @@ public class TileDiskManipulator extends TileNode implements IComparable, IFilte
             return;
         }
         ItemStack extracted = null;
-        int ii = 0;
+        int i = 0;
         do {
             ItemStack stack = null;
-            while (storage.getItems().size() > ii && stack == null) {
+            while (storage.getItems().size() > i && stack == null) {
-                stack = storage.getItems().get(ii++);
+                stack = storage.getItems().get(i++);
             }
             if (stack != null) {
                 extracted = storage.extractItem(stack, 1, compare);
             }
-        } while (storage.getItems().size() > ii && extracted == null);
+        } while (storage.getItems().size() > i && extracted == null);
         if (extracted == null) {
             moveDriveToOutput(slot);
             return;
         }
-        ItemStack leftOver = network.insertItem(extracted, extracted.stackSize, false);
+        ItemStack remainder = network.insertItem(extracted, extracted.stackSize, false);
-        if (leftOver != null) {
+        if (remainder != null) {
-            storage.insertItem(leftOver, leftOver.stackSize, false);
+            storage.insertItem(remainder, remainder.stackSize, false);
         }
     }
 
     private void extractFromNetwork(ItemStorage storage, int slot) {
+        if (storage.getStored() == storage.getCapacity()) {
+            moveDriveToOutput(slot);
+            return;
+        }
+        ItemStack extracted = null;
+        int i = 0;
+        if (IFilterable.isEmpty(itemFilters)) {
+            ItemStack toExtract = null;
+            ArrayList<ItemStack> networkItems = new ArrayList<>(network.getItemStorage().getStacks());
+            int iii = 0;
+            while ((toExtract == null || toExtract.stackSize == 0) && iii < networkItems.size()) {
+                toExtract = networkItems.get(iii++);
+            }
+            if (toExtract != null) {
+                extracted = network.extractItem(toExtract, 1, compare);
+            }
+        } else {
+            while (itemFilters.getSlots() > i && extracted == null) {
+                ItemStack stack = null;
+                while (itemFilters.getSlots() > i && stack == null) {
+                    stack = itemFilters.getStackInSlot(i++);
+                }
+                if (stack != null) {
+                    extracted = network.extractItem(stack, 1, compare);
+                }
+            }
+        }
 
+        if (extracted == null) {
+            moveDriveToOutput(slot);
+            return;
+        }
+        ItemStack remainder = storage.insertItem(extracted, extracted.stackSize, false);
+        if (remainder != null) {
+            network.insertItem(remainder, remainder.stackSize, false);
+        }
     }
 
     private void insertIntoNetwork(FluidStorage storage, int slot) {
@@ -220,27 +258,63 @@ public class TileDiskManipulator extends TileNode implements IComparable, IFilte
             return;
         }
         FluidStack extracted = null;
-        int ii = 0;
+        int i = 0;
         do {
-            FluidStack stack = storage.getStacks().get(ii);
+            FluidStack stack = storage.getStacks().get(i);
-            while (stack == null && storage.getStacks().size() > ii) {
+            while (stack == null && storage.getStacks().size() > i) {
-                ii++;
+                i++;
             }
             if (stack != null) {
                 extracted = storage.extractFluid(stack, 1, compare);
             }
-        } while (extracted == null && storage.getStacks().size() > ii);
+        } while (extracted == null && storage.getStacks().size() > i);
         if (extracted == null) {
             moveDriveToOutput(slot);
             return;
         }
-        FluidStack leftOver = network.insertFluid(extracted, extracted.amount, false);
+        FluidStack remainder = network.insertFluid(extracted, extracted.amount, false);
-        if (leftOver != null) {
+        if (remainder != null) {
-            storage.insertFluid(leftOver, leftOver.amount, false);
+            storage.insertFluid(remainder, remainder.amount, false);
         }
     }
 
     private void extractFromNetwork(FluidStorage storage, int slot) {
+        if (storage.getStored() == storage.getCapacity()) {
+            moveDriveToOutput(slot);
+            return;
+        }
+        FluidStack extracted = null;
+        int i = 0;
+        if (IFilterable.isEmpty(itemFilters)) {
+            FluidStack toExtract = null;
+            ArrayList<FluidStack> networkFluids = new ArrayList<>(network.getFluidStorage().getStacks());
+            int j = 0;
+            while ((toExtract == null || toExtract.amount == 0) && j < networkFluids.size()) {
+                toExtract = networkFluids.get(j++);
+            }
+            if (toExtract != null) {
+                extracted = network.extractFluid(toExtract, 1, compare);
+            }
+        } else {
+            while (fluidFilters.getSlots() > i && extracted == null) {
+                FluidStack stack = null;
+                while (fluidFilters.getSlots() > i && stack == null) {
+                    stack = fluidFilters.getFluidStackInSlot(i++);
+                }
+                if (stack != null) {
+                    extracted = network.extractFluid(stack, 1, compare);
+                }
+            }
+        }
+
+        if (extracted == null) {
+            moveDriveToOutput(slot);
+            return;
+        }
+        FluidStack remainder = storage.insertFluid(extracted, extracted.amount, false);
+        if (remainder != null) {
+            network.insertFluid(remainder, remainder.amount, false);
+        }
     }
 
     private void moveDriveToOutput(int slot) {
@@ -326,6 +400,10 @@ public class TileDiskManipulator extends TileNode implements IComparable, IFilte
         if (tag.hasKey(NBT_TYPE)) {
             type = tag.getInteger(NBT_TYPE);
         }
+
+        if (tag.hasKey(NBT_IO_MODE)) {
+            ioMode = tag.getInteger(NBT_IO_MODE);
+        }
     }
 
     @Override
@@ -339,6 +417,7 @@ public class TileDiskManipulator extends TileNode implements IComparable, IFilte
         tag.setInteger(NBT_COMPARE, compare);
         tag.setInteger(NBT_MODE, mode);
         tag.setInteger(NBT_TYPE, type);
+        tag.setInteger(NBT_IO_MODE, ioMode);
 
         return tag;
     }

src/main/java/refinedstorage/tile/TileFluidInterface.java

@@ -110,7 +110,7 @@ public class TileFluidInterface extends TileNode implements IComparable {
                 }
             }
 
-            FluidStack stack = out.getFluids()[0];
+            FluidStack stack = out.getFluidStackInSlot(0);
 
             if (tankOut.getFluid() != null && (stack == null || (tankOut.getFluid().getFluid() != stack.getFluid()))) {
                 FluidStack remainder = tankOut.drainInternal(Fluid.BUCKET_VOLUME, true);

src/main/java/refinedstorage/tile/config/IFilterable.java

@@ -68,7 +68,7 @@ public interface IFilterable {
             int slots = 0;
 
             for (int i = 0; i < filters.getSlots(); ++i) {
-                FluidStack slot = filters.getFluids()[i];
+                FluidStack slot = filters.getFluidStackInSlot(i);
 
                 if (slot != null) {
                     slots++;
@@ -82,7 +82,7 @@ public interface IFilterable {
             return slots == 0;
         } else if (mode == BLACKLIST) {
             for (int i = 0; i < filters.getSlots(); ++i) {
-                FluidStack slot = filters.getFluids()[i];
+                FluidStack slot = filters.getFluidStackInSlot(i);
 
                 if (slot != null && CompareUtils.compareStack(slot, stack, compare)) {
                     return false;
@@ -95,6 +95,15 @@ public interface IFilterable {
         return false;
     }
 
+    static boolean isEmpty(IItemHandler filter) {
+        for (int i = 0; i < filter.getSlots(); i++) {
+            if (filter.getStackInSlot(i) != null) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     void setMode(int mode);
 
     int getMode();