Fluid mode in exporter

src/main/java/refinedstorage/container/ContainerExporter.java

@@ -4,7 +4,7 @@ import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.SlotItemHandler;
-import refinedstorage.container.slot.SlotSpecimen;
+import refinedstorage.container.slot.SlotSpecimenType;
 import refinedstorage.tile.TileExporter;
 
 public class ContainerExporter extends ContainerBase {
@@ -16,7 +16,7 @@ public class ContainerExporter extends ContainerBase {
         }
 
         for (int i = 0; i < 9; ++i) {
-            addSlotToContainer(new SlotSpecimen(exporter.getFilters(), i, 8 + (18 * i), 20));
+            addSlotToContainer(new SlotSpecimenType(exporter, i, 8 + (18 * i), 20));
         }
 
         addPlayerInventory(8, 55);

src/main/java/refinedstorage/gui/GuiExporter.java

@@ -4,6 +4,7 @@ import refinedstorage.api.storage.CompareUtils;
 import refinedstorage.container.ContainerExporter;
 import refinedstorage.gui.sidebutton.SideButtonCompare;
 import refinedstorage.gui.sidebutton.SideButtonRedstoneMode;
+import refinedstorage.gui.sidebutton.SideButtonType;
 import refinedstorage.tile.TileExporter;
 
 public class GuiExporter extends GuiBase {
@@ -15,6 +16,8 @@ public class GuiExporter extends GuiBase {
     public void init(int x, int y) {
         addSideButton(new SideButtonRedstoneMode(TileExporter.REDSTONE_MODE));
 
+        addSideButton(new SideButtonType(TileExporter.TYPE));
+
         addSideButton(new SideButtonCompare(TileExporter.COMPARE, CompareUtils.COMPARE_DAMAGE));
         addSideButton(new SideButtonCompare(TileExporter.COMPARE, CompareUtils.COMPARE_NBT));
     }

src/main/java/refinedstorage/tile/TileExporter.java

@@ -5,31 +5,42 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumFacing;
 import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.IFluidHandler;
 import net.minecraftforge.items.CapabilityItemHandler;
 import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.ItemHandlerHelper;
 import refinedstorage.RefinedStorage;
 import refinedstorage.apiimpl.autocrafting.CraftingTaskScheduler;
 import refinedstorage.inventory.ItemHandlerBasic;
+import refinedstorage.inventory.ItemHandlerFluid;
 import refinedstorage.inventory.ItemHandlerUpgrade;
 import refinedstorage.item.ItemUpgrade;
 import refinedstorage.tile.config.IComparable;
+import refinedstorage.tile.config.IType;
 import refinedstorage.tile.data.TileDataParameter;
 
-public class TileExporter extends TileMultipartNode implements IComparable {
+public class TileExporter extends TileMultipartNode implements IComparable, IType {
     public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer> TYPE = IType.createParameter();
 
     private static final String NBT_COMPARE = "Compare";
+    private static final String NBT_TYPE = "Type";
+
+    private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, this);
+    private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, this);
 
-    private ItemHandlerBasic filters = new ItemHandlerBasic(9, this);
     private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK);
 
     private int compare = 0;
+    private int type = IType.ITEMS;
 
     private CraftingTaskScheduler scheduler = new CraftingTaskScheduler(this);
 
     public TileExporter() {
         dataManager.addWatchedParameter(COMPARE);
+        dataManager.addWatchedParameter(TYPE);
     }
 
     @Override
@@ -44,13 +55,15 @@ public class TileExporter extends TileMultipartNode implements IComparable {
 
     @Override
     public void updateNode() {
+        if (ticks % upgrades.getSpeed() == 0) {
+            if (type == IType.ITEMS) {
                 IItemHandler handler = getItemHandler(getFacingTile(), getDirection().getOpposite());
 
                 int size = upgrades.hasUpgrade(ItemUpgrade.TYPE_STACK) ? 64 : 1;
 
-        if (handler != null && ticks % upgrades.getSpeed() == 0) {
+                if (handler != null) {
-            for (int i = 0; i < filters.getSlots(); ++i) {
+                    for (int i = 0; i < itemFilters.getSlots(); ++i) {
-                ItemStack slot = filters.getStackInSlot(i);
+                        ItemStack slot = itemFilters.getStackInSlot(i);
 
                         if (slot != null) {
                             ItemStack took = network.extractItem(slot, size, compare);
@@ -71,6 +84,26 @@ public class TileExporter extends TileMultipartNode implements IComparable {
                         }
                     }
                 }
+            } else if (type == IType.FLUIDS) {
+                IFluidHandler handler = getFluidHandler(getFacingTile(), getDirection().getOpposite());
+
+                if (handler != null) {
+                    for (FluidStack stack : fluidFilters.getFluids()) {
+                        if (stack != null) {
+                            FluidStack took = network.extractFluid(stack, Fluid.BUCKET_VOLUME, compare);
+
+                            if (took != null) {
+                                int remainder = Fluid.BUCKET_VOLUME - handler.fill(took, true);
+
+                                if (remainder > 0) {
+                                    network.insertFluid(took, remainder, false);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
 
     @Override
@@ -93,8 +126,13 @@ public class TileExporter extends TileMultipartNode implements IComparable {
             compare = tag.getInteger(NBT_COMPARE);
         }
 
-        readItems(filters, 0, tag);
+        if (tag.hasKey(NBT_TYPE)) {
+            type = tag.getInteger(NBT_TYPE);
+        }
+
+        readItems(itemFilters, 0, tag);
         readItems(upgrades, 1, tag);
+        readItems(fluidFilters, 2, tag);
 
         scheduler.read(tag);
     }
@@ -104,19 +142,17 @@ public class TileExporter extends TileMultipartNode implements IComparable {
         super.write(tag);
 
         tag.setInteger(NBT_COMPARE, compare);
+        tag.setInteger(NBT_TYPE, type);
 
-        writeItems(filters, 0, tag);
+        writeItems(itemFilters, 0, tag);
         writeItems(upgrades, 1, tag);
+        writeItems(fluidFilters, 2, tag);
 
         scheduler.writeToNBT(tag);
 
         return tag;
     }
 
-    public IItemHandler getFilters() {
-        return filters;
-    }
-
     public IItemHandler getUpgrades() {
         return upgrades;
     }
@@ -126,6 +162,23 @@ public class TileExporter extends TileMultipartNode implements IComparable {
         return upgrades;
     }
 
+    @Override
+    public int getType() {
+        return worldObj.isRemote ? TYPE.getValue() : type;
+    }
+
+    @Override
+    public void setType(int type) {
+        this.type = type;
+
+        markDirty();
+    }
+
+    @Override
+    public IItemHandler getFilterInventory() {
+        return getType() == IType.ITEMS ? itemFilters : fluidFilters;
+    }
+
     @Override
     public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
         if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {