The Portable Grid now supports fluid disks. Fixes #1916

CHANGELOG.md

@@ -3,8 +3,8 @@
 ### 1.6.1
 - Added fluid autocrafting (raoulvdberge)
 - Added Crafting Upgrade support for fluids on the Exporter, Constructor and Fluid Interface (raoulvdberge)
-- Added support for JEI ghost slot dragging (raoulvdberge)
 - Added config option to hide covers in the creative mode tabs and JEI (raoulvdberge)
+- The Portable Grid now supports fluid disks (raoulvdberge)
 - Removed "emit signal when item is being autocrafted" option in the Detector (raoulvdberge)
 - The Crafting Card no longer schedules requests when there are items or fluids missing (raoulvdberge)
 - You can now keep fluids in stock by attaching a External Storage in fluid mode to a Fluid Interface with a Crafting Upgrade (raoulvdberge)

src/main/java/com/raoulvdberge/refinedstorage/api/network/grid/handler/IFluidGridHandler.java

@@ -46,7 +46,6 @@ public interface IFluidGridHandler {
      */
     ItemStack onShiftClick(EntityPlayerMP player, ItemStack container);
 
-
     /**
      * Called when a player requests the crafting preview window to be opened.
      *

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/grid/handler/FluidGridHandlerPortable.java

@@ -0,0 +1,112 @@
+package com.raoulvdberge.refinedstorage.apiimpl.network.grid.handler;
+
+import com.raoulvdberge.refinedstorage.RS;
+import com.raoulvdberge.refinedstorage.api.network.grid.handler.IFluidGridHandler;
+import com.raoulvdberge.refinedstorage.api.util.Action;
+import com.raoulvdberge.refinedstorage.api.util.IComparer;
+import com.raoulvdberge.refinedstorage.apiimpl.API;
+import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
+import com.raoulvdberge.refinedstorage.util.StackUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.inventory.InventoryHelper;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandlerItem;
+import org.apache.commons.lang3.tuple.Pair;
+
+import javax.annotation.Nullable;
+
+public class FluidGridHandlerPortable implements IFluidGridHandler {
+    private IPortableGrid portableGrid;
+
+    public FluidGridHandlerPortable(IPortableGrid portableGrid) {
+        this.portableGrid = portableGrid;
+    }
+
+    @Override
+    public void onExtract(EntityPlayerMP player, int hash, boolean shift) {
+        FluidStack stack = portableGrid.getFluidCache().getList().get(hash);
+
+        if (stack == null || stack.amount < Fluid.BUCKET_VOLUME) {
+            return;
+        }
+
+        if (StackUtils.hasFluidBucket(stack)) {
+            ItemStack bucket = null;
+
+            for (int i = 0; i < player.inventory.getSizeInventory(); ++i) {
+                ItemStack slot = player.inventory.getStackInSlot(i);
+
+                if (API.instance().getComparer().isEqualNoQuantity(StackUtils.EMPTY_BUCKET, slot)) {
+                    bucket = StackUtils.EMPTY_BUCKET.copy();
+
+                    player.inventory.decrStackSize(i, 1);
+
+                    break;
+                }
+            }
+
+            if (bucket != null) {
+                IFluidHandlerItem fluidHandler = bucket.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
+
+                portableGrid.getFluidStorageTracker().changed(player, stack.copy());
+
+                fluidHandler.fill(portableGrid.getFluidStorage().extract(stack, Fluid.BUCKET_VOLUME, IComparer.COMPARE_NBT, Action.PERFORM), true);
+
+                if (shift) {
+                    if (!player.inventory.addItemStackToInventory(fluidHandler.getContainer().copy())) {
+                        InventoryHelper.spawnItemStack(player.getEntityWorld(), player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ(), fluidHandler.getContainer());
+                    }
+                } else {
+                    player.inventory.setItemStack(fluidHandler.getContainer());
+                    player.updateHeldItem();
+                }
+
+                portableGrid.drainEnergy(RS.INSTANCE.config.portableGridExtractUsage);
+            }
+        }
+    }
+
+    @Nullable
+    @Override
+    public ItemStack onInsert(EntityPlayerMP player, ItemStack container) {
+        Pair<ItemStack, FluidStack> result = StackUtils.getFluid(container, true);
+
+        if (result.getValue() != null && portableGrid.getFluidStorage().insert(result.getValue(), result.getValue().amount, Action.SIMULATE) == null) {
+            portableGrid.getFluidStorageTracker().changed(player, result.getValue().copy());
+
+            result = StackUtils.getFluid(container, false);
+
+            portableGrid.getFluidStorage().insert(result.getValue(), result.getValue().amount, Action.PERFORM);
+
+            portableGrid.drainEnergy(RS.INSTANCE.config.portableGridInsertUsage);
+
+            return result.getLeft();
+        }
+
+        return container;
+    }
+
+    @Override
+    public void onInsertHeldContainer(EntityPlayerMP player) {
+        player.inventory.setItemStack(StackUtils.nullToEmpty(onInsert(player, player.inventory.getItemStack())));
+        player.updateHeldItem();
+    }
+
+    @Override
+    public ItemStack onShiftClick(EntityPlayerMP player, ItemStack container) {
+        return StackUtils.nullToEmpty(onInsert(player, container));
+    }
+
+    @Override
+    public void onCraftingPreviewRequested(EntityPlayerMP player, int hash, int quantity, boolean noPreview) {
+        // NO OP
+    }
+
+    @Override
+    public void onCraftingRequested(EntityPlayerMP player, int hash, int quantity) {
+        // NO OP
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/grid/handler/ItemGridHandlerPortable.java

@@ -33,7 +33,7 @@ public class ItemGridHandlerPortable implements IItemGridHandler {
             return;
         }
 
-        ItemStack item = portableGrid.getCache().getList().get(hash);
+        ItemStack item = portableGrid.getItemCache().getList().get(hash);
 
         if (item == null) {
             return;
@@ -76,21 +76,21 @@ public class ItemGridHandlerPortable implements IItemGridHandler {
         size = Math.min(size, maxItemSize);
 
         // Do this before actually extracting, since portable grid sends updates as soon as a change happens (so before the storage tracker used to track)
-        portableGrid.getStorageTracker().changed(player, item.copy());
+        portableGrid.getItemStorageTracker().changed(player, item.copy());
 
-        ItemStack took = portableGrid.getStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.SIMULATE);
+        ItemStack took = portableGrid.getItemStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.SIMULATE);
 
         if (took != null) {
             if ((flags & EXTRACT_SHIFT) == EXTRACT_SHIFT) {
                 IItemHandler playerInventory = player.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.UP);
 
                 if (ItemHandlerHelper.insertItem(playerInventory, took, true).isEmpty()) {
-                    took = portableGrid.getStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.PERFORM);
+                    took = portableGrid.getItemStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.PERFORM);
 
                     ItemHandlerHelper.insertItem(playerInventory, took, false);
                 }
             } else {
-                took = portableGrid.getStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.PERFORM);
+                took = portableGrid.getItemStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.PERFORM);
 
                 if (single && !held.isEmpty()) {
                     held.grow(1);
@@ -112,9 +112,9 @@ public class ItemGridHandlerPortable implements IItemGridHandler {
             return stack;
         }
 
-        portableGrid.getStorageTracker().changed(player, stack.copy());
+        portableGrid.getItemStorageTracker().changed(player, stack.copy());
 
-        ItemStack remainder = portableGrid.getStorage().insert(stack, stack.getCount(), Action.PERFORM);
+        ItemStack remainder = portableGrid.getItemStorage().insert(stack, stack.getCount(), Action.PERFORM);
 
         portableGrid.drainEnergy(RS.INSTANCE.config.portableGridInsertUsage);
 
@@ -130,11 +130,11 @@ public class ItemGridHandlerPortable implements IItemGridHandler {
         ItemStack stack = player.inventory.getItemStack();
         int size = single ? 1 : stack.getCount();
 
-        portableGrid.getStorageTracker().changed(player, stack.copy());
+        portableGrid.getItemStorageTracker().changed(player, stack.copy());
 
         if (single) {
-            if (portableGrid.getStorage().insert(stack, size, Action.SIMULATE) == null) {
+            if (portableGrid.getItemStorage().insert(stack, size, Action.SIMULATE) == null) {
-                portableGrid.getStorage().insert(stack, size, Action.PERFORM);
+                portableGrid.getItemStorage().insert(stack, size, Action.PERFORM);
 
                 stack.shrink(size);
 
@@ -143,7 +143,7 @@ public class ItemGridHandlerPortable implements IItemGridHandler {
                 }
             }
         } else {
-            player.inventory.setItemStack(StackUtils.nullToEmpty(portableGrid.getStorage().insert(stack, size, Action.PERFORM)));
+            player.inventory.setItemStack(StackUtils.nullToEmpty(portableGrid.getItemStorage().insert(stack, size, Action.PERFORM)));
         }
 
         player.updateHeldItem();

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidInterface.java

@@ -6,7 +6,7 @@ import com.raoulvdberge.refinedstorage.api.util.Action;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.externalstorage.StorageExternalFluid;
-import com.raoulvdberge.refinedstorage.inventory.fluid.FluidHandlerFluidInterface;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidHandlerProxy;
 import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
 import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
 import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
@@ -50,7 +50,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
     };
     private FluidTank tankOut = new FluidTank(TANK_CAPACITY);
 
-    private FluidHandlerFluidInterface tank = new FluidHandlerFluidInterface(tankIn, tankOut);
+    private FluidHandlerProxy tank = new FluidHandlerProxy(tankIn, tankOut);
 
     private ItemHandlerBase in = new ItemHandlerBase(1, new ListenerNetworkNode(this), stack -> StackUtils.getFluid(stack, true).getRight() != null);
     private FluidInventory out = new FluidInventory(1, TANK_CAPACITY, new ListenerNetworkNode(this));
@@ -245,7 +245,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
         return out;
     }
 
-    public FluidHandlerFluidInterface getTank() {
+    public FluidHandlerProxy getTank() {
         return tank;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageCacheFluidPortable.java

@@ -0,0 +1,83 @@
+package com.raoulvdberge.refinedstorage.apiimpl.storage;
+
+import com.raoulvdberge.refinedstorage.api.storage.IStorage;
+import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
+import com.raoulvdberge.refinedstorage.api.storage.IStorageCacheListener;
+import com.raoulvdberge.refinedstorage.api.util.IStackList;
+import com.raoulvdberge.refinedstorage.apiimpl.API;
+import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
+import net.minecraftforge.fluids.FluidStack;
+
+import javax.annotation.Nonnull;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+public class StorageCacheFluidPortable implements IStorageCache<FluidStack> {
+    private IPortableGrid portableGrid;
+    private IStackList<FluidStack> list = API.instance().createFluidStackList();
+    private List<IStorageCacheListener<FluidStack>> listeners = new LinkedList<>();
+
+    public StorageCacheFluidPortable(IPortableGrid portableGrid) {
+        this.portableGrid = portableGrid;
+    }
+
+    @Override
+    public void invalidate() {
+        list.clear();
+
+        if (portableGrid.getFluidStorage() != null) {
+            portableGrid.getFluidStorage().getStacks().forEach(list::add);
+        }
+
+        listeners.forEach(IStorageCacheListener::onInvalidated);
+    }
+
+    @Override
+    public void add(@Nonnull FluidStack stack, int size, boolean rebuilding, boolean batched) {
+        list.add(stack, size);
+
+        if (!rebuilding) {
+            listeners.forEach(l -> l.onChanged(stack, size));
+        }
+    }
+
+    @Override
+    public void remove(@Nonnull FluidStack stack, int size, boolean batched) {
+        if (list.remove(stack, size)) {
+            listeners.forEach(l -> l.onChanged(stack, -size));
+        }
+    }
+
+    @Override
+    public void flush() {
+        throw new UnsupportedOperationException("Cannot flush portable grid storage cache");
+    }
+
+    @Override
+    public void addListener(IStorageCacheListener<FluidStack> listener) {
+        listeners.add(listener);
+
+        listener.onAttached();
+    }
+
+    @Override
+    public void removeListener(IStorageCacheListener<FluidStack> listener) {
+        listeners.remove(listener);
+    }
+
+    @Override
+    public void sort() {
+        // NO OP
+    }
+
+    @Override
+    public IStackList<FluidStack> getList() {
+        return list;
+    }
+
+    @Override
+    public List<IStorage<FluidStack>> getStorages() {
+        return Collections.emptyList();
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageCacheItemPortable.java

@@ -26,8 +26,8 @@ public class StorageCacheItemPortable implements IStorageCache<ItemStack> {
     public void invalidate() {
         list.clear();
 
-        if (portableGrid.getStorage() != null) {
+        if (portableGrid.getItemStorage() != null) {
-            portableGrid.getStorage().getStacks().forEach(list::add);
+            portableGrid.getItemStorage().getStacks().forEach(list::add);
         }
 
         listeners.forEach(IStorageCacheListener::onInvalidated);

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageCacheListenerGridFluid.java

@@ -32,6 +32,6 @@ public class StorageCacheListenerGridFluid implements IStorageCacheListener<Flui
 
     @Override
     public void onChanged(@Nonnull FluidStack stack, int size) {
-        RS.INSTANCE.network.sendTo(new MessageGridFluidDelta(network, stack, size), player);
+        RS.INSTANCE.network.sendTo(new MessageGridFluidDelta(network, network.getFluidStorageTracker(), stack, size), player);
     }
 }

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageCacheListenerGridPortable.java

@@ -25,12 +25,12 @@ public class StorageCacheListenerGridPortable implements IStorageCacheListener<I
     @Override
     public void onAttached() {
         RS.INSTANCE.network.sendTo(new MessageGridItemUpdate(buf -> {
-            buf.writeInt(portableGrid.getCache().getList().getStacks().size());
+            buf.writeInt(portableGrid.getItemCache().getList().getStacks().size());
 
-            for (ItemStack stack : portableGrid.getCache().getList().getStacks()) {
+            for (ItemStack stack : portableGrid.getItemCache().getList().getStacks()) {
                 StackUtils.writeItemStack(buf, stack, null, false);
 
-                IStorageTracker.IStorageTrackerEntry entry = portableGrid.getStorageTracker().get(stack);
+                IStorageTracker.IStorageTrackerEntry entry = portableGrid.getItemStorageTracker().get(stack);
                 buf.writeBoolean(entry != null);
                 if (entry != null) {
                     buf.writeLong(entry.getTime());
@@ -47,6 +47,6 @@ public class StorageCacheListenerGridPortable implements IStorageCacheListener<I
 
     @Override
     public void onChanged(@Nonnull ItemStack stack, int size) {
-        RS.INSTANCE.network.sendTo(new MessageGridItemDelta(null, portableGrid.getStorageTracker(), stack, size), player);
+        RS.INSTANCE.network.sendTo(new MessageGridItemDelta(null, portableGrid.getItemStorageTracker(), stack, size), player);
     }
 }

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageCacheListenerGridPortableFluid.java

@@ -0,0 +1,57 @@
+package com.raoulvdberge.refinedstorage.apiimpl.storage;
+
+import com.raoulvdberge.refinedstorage.RS;
+import com.raoulvdberge.refinedstorage.api.storage.IStorageCacheListener;
+import com.raoulvdberge.refinedstorage.api.storage.IStorageTracker;
+import com.raoulvdberge.refinedstorage.network.MessageGridFluidDelta;
+import com.raoulvdberge.refinedstorage.network.MessageGridFluidUpdate;
+import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
+import com.raoulvdberge.refinedstorage.util.StackUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fml.common.network.ByteBufUtils;
+
+import javax.annotation.Nonnull;
+
+public class StorageCacheListenerGridPortableFluid implements IStorageCacheListener<FluidStack> {
+    private IPortableGrid portableGrid;
+    private EntityPlayerMP player;
+
+    public StorageCacheListenerGridPortableFluid(IPortableGrid portableGrid, EntityPlayerMP player) {
+        this.portableGrid = portableGrid;
+        this.player = player;
+    }
+
+    @Override
+    public void onAttached() {
+        RS.INSTANCE.network.sendTo(new MessageGridFluidUpdate(buf -> {
+            int size = portableGrid.getFluidCache().getList().getStacks().size();
+
+            buf.writeInt(size);
+
+            for (FluidStack stack : portableGrid.getFluidCache().getList().getStacks()) {
+                StackUtils.writeFluidStackAndHash(buf, stack);
+
+                IStorageTracker.IStorageTrackerEntry entry = portableGrid.getFluidStorageTracker().get(stack);
+                buf.writeBoolean(entry != null);
+                if (entry != null) {
+                    buf.writeLong(entry.getTime());
+                    ByteBufUtils.writeUTF8String(buf, entry.getName());
+                }
+
+                buf.writeBoolean(false);
+                buf.writeBoolean(false);
+            }
+        }, false), player);
+    }
+
+    @Override
+    public void onInvalidated() {
+        // NO OP
+    }
+
+    @Override
+    public void onChanged(@Nonnull FluidStack stack, int size) {
+        RS.INSTANCE.network.sendTo(new MessageGridFluidDelta(null, portableGrid.getFluidStorageTracker(), stack, size), player);
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/disk/StorageDiskFluidPortable.java

@@ -0,0 +1,99 @@
+package com.raoulvdberge.refinedstorage.apiimpl.storage.disk;
+
+import com.raoulvdberge.refinedstorage.api.storage.AccessType;
+import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDisk;
+import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskContainerContext;
+import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskListener;
+import com.raoulvdberge.refinedstorage.api.util.Action;
+import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.fluids.FluidStack;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Collection;
+
+public class StorageDiskFluidPortable implements IStorageDisk<FluidStack> {
+    private IStorageDisk<FluidStack> parent;
+    private IPortableGrid portableGrid;
+
+    public StorageDiskFluidPortable(IStorageDisk<FluidStack> parent, IPortableGrid portableGrid) {
+        this.parent = parent;
+        this.portableGrid = portableGrid;
+    }
+
+    @Override
+    public int getCapacity() {
+        return parent.getCapacity();
+    }
+
+    @Override
+    public void setSettings(@Nullable IStorageDiskListener listener, IStorageDiskContainerContext context) {
+        parent.setSettings(listener, context);
+    }
+
+    @Override
+    public NBTTagCompound writeToNbt() {
+        return parent.writeToNbt();
+    }
+
+    @Override
+    public Collection<FluidStack> getStacks() {
+        return parent.getStacks();
+    }
+
+    @Nullable
+    @Override
+    public FluidStack insert(@Nonnull FluidStack stack, int size, Action action) {
+        int storedPre = parent.getStored();
+
+        FluidStack remainder = parent.insert(stack, size, action);
+
+        if (action == Action.PERFORM) {
+            int inserted = parent.getCacheDelta(storedPre, size, remainder);
+
+            if (inserted > 0) {
+                portableGrid.getFluidCache().add(stack, inserted, false, false);
+            }
+        }
+
+        return remainder;
+    }
+
+    @Nullable
+    @Override
+    public FluidStack extract(@Nonnull FluidStack stack, int size, int flags, Action action) {
+        FluidStack extracted = parent.extract(stack, size, flags, action);
+
+        if (action == Action.PERFORM && extracted != null) {
+            portableGrid.getFluidCache().remove(extracted, extracted.amount, false);
+        }
+
+        return extracted;
+    }
+
+    @Override
+    public int getStored() {
+        return parent.getStored();
+    }
+
+    @Override
+    public int getPriority() {
+        return parent.getPriority();
+    }
+
+    @Override
+    public AccessType getAccessType() {
+        return parent.getAccessType();
+    }
+
+    @Override
+    public int getCacheDelta(int storedPreInsertion, int size, @Nullable FluidStack remainder) {
+        return parent.getCacheDelta(storedPreInsertion, size, remainder);
+    }
+
+    @Override
+    public String getId() {
+        return parent.getId();
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/disk/StorageDiskItemPortable.java

@@ -53,7 +53,7 @@ public class StorageDiskItemPortable implements IStorageDisk<ItemStack> {
             int inserted = parent.getCacheDelta(storedPre, size, remainder);
 
             if (inserted > 0) {
-                portableGrid.getCache().add(stack, inserted, false, false);
+                portableGrid.getItemCache().add(stack, inserted, false, false);
             }
         }
 
@@ -66,7 +66,7 @@ public class StorageDiskItemPortable implements IStorageDisk<ItemStack> {
         ItemStack extracted = parent.extract(stack, size, flags, action);
 
         if (action == Action.PERFORM && extracted != null) {
-            portableGrid.getCache().remove(extracted, extracted.getCount(), false);
+            portableGrid.getItemCache().remove(extracted, extracted.getCount(), false);
         }
 
         return extracted;

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerGrid.java

@@ -54,7 +54,7 @@ public class ContainerGrid extends ContainerBase {
 
         this.transferManager.clearTransfers();
 
-        if (grid.getGridType() != GridType.FLUID) {
+        if (grid.getGridType() != GridType.FLUID || grid instanceof IPortableGrid) {
             addFilterSlots();
         }
 

src/main/java/com/raoulvdberge/refinedstorage/gui/grid/GuiGrid.java

@@ -57,19 +57,10 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
     private int slotNumber;
 
     public GuiGrid(ContainerGrid container, IGrid grid) {
-        super(container, grid.getGridType() == GridType.FLUID ? 193 : 227, 0);
+        super(container, (grid.getGridType() == GridType.FLUID && !(grid instanceof IPortableGrid)) ? 193 : 227, 0);
-
-        IGridSorter defaultSorter;
-
-        List<IGridSorter> sorters = new LinkedList<>();
-        sorters.add(defaultSorter = new GridSorterName());
-        sorters.add(new GridSorterQuantity());
-        sorters.add(new GridSorterID());
-        sorters.add(new GridSorterInventoryTweaks());
-        sorters.add(new GridSorterLastModified());
 
         this.grid = grid;
-        this.view = grid.getGridType() == GridType.FLUID ? new GridViewFluid(this, defaultSorter, sorters) : new GridViewItem(this, defaultSorter, sorters);
+        this.view = grid.getGridType() == GridType.FLUID ? new GridViewFluid(this, getDefaultSorter(), getSorters()) : new GridViewItem(this, getDefaultSorter(), getSorters());
         this.wasConnected = this.grid.isActive();
         this.tabs = new TabList(this, new ElementDrawers(), grid::getTabs, grid::getTotalTabPages, grid::getTabPage, grid::getTabSelected, IGrid.TABS_PER_PAGE);
         this.tabs.addListener(new TabList.ITabListListener() {
@@ -151,6 +142,10 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
         return grid;
     }
 
+    public void setView(IGridView view) {
+        this.view = view;
+    }
+
     public IGridView getView() {
         return view;
     }
@@ -271,12 +266,12 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
     public void drawBackground(int x, int y, int mouseX, int mouseY) {
         tabs.drawBackground(x, y);
 
-        if (grid.getGridType() == GridType.CRAFTING) {
+        if (grid instanceof IPortableGrid) {
+            bindTexture("gui/portable_grid.png");
+        } else if (grid.getGridType() == GridType.CRAFTING) {
             bindTexture("gui/crafting_grid.png");
         } else if (grid.getGridType() == GridType.PATTERN) {
             bindTexture("gui/pattern_grid" + (((NetworkNodeGrid) grid).isProcessingPattern() ? "_processing" : "") + ".png");
-        } else if (grid instanceof IPortableGrid) {
-            bindTexture("gui/portable_grid.png");
         } else {
             bindTexture("gui/grid.png");
         }
@@ -285,7 +280,8 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
 
         drawTexture(x, yy, 0, 0, screenWidth - (grid.getGridType() != GridType.FLUID ? 34 : 0), getTopHeight());
 
-        if (grid.getGridType() != GridType.FLUID) {
+        // Filters and portable grid disk
+        if (grid.getGridType() != GridType.FLUID || grid instanceof IPortableGrid) {
             drawTexture(x + screenWidth - 34 + 4, y + tabs.getHeight(), 197, 0, 30, grid instanceof IPortableGrid ? 114 : 82);
         }
 
@@ -294,12 +290,12 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
         for (int i = 0; i < rows; ++i) {
             yy += 18;
 
-            drawTexture(x, yy, 0, getTopHeight() + (i > 0 ? (i == rows - 1 ? 18 * 2 : 18) : 0), screenWidth - (grid.getGridType() != GridType.FLUID ? 34 : 0), 18);
+            drawTexture(x, yy, 0, getTopHeight() + (i > 0 ? (i == rows - 1 ? 18 * 2 : 18) : 0), screenWidth - ((grid.getGridType() != GridType.FLUID || grid instanceof IPortableGrid) ? 34 : 0), 18);
         }
 
         yy += 18;
 
-        drawTexture(x, yy, 0, getTopHeight() + (18 * 3), screenWidth - (grid.getGridType() != GridType.FLUID ? 34 : 0), getBottomHeight());
+        drawTexture(x, yy, 0, getTopHeight() + (18 * 3), screenWidth - ((grid.getGridType() != GridType.FLUID || grid instanceof IPortableGrid) ? 34 : 0), getBottomHeight());
 
         if (grid.getGridType() == GridType.PATTERN) {
             int ty = 0;
@@ -526,4 +522,19 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
             scrollbar.setMaxOffset(getRows() - getVisibleRows());
         }
     }
+
+    public static List<IGridSorter> getSorters() {
+        List<IGridSorter> sorters = new LinkedList<>();
+        sorters.add(getDefaultSorter());
+        sorters.add(new GridSorterQuantity());
+        sorters.add(new GridSorterID());
+        sorters.add(new GridSorterInventoryTweaks());
+        sorters.add(new GridSorterLastModified());
+
+        return sorters;
+    }
+
+    public static IGridSorter getDefaultSorter() {
+        return new GridSorterName();
+    }
 }

src/main/java/com/raoulvdberge/refinedstorage/integration/jei/RSJEIPlugin.java

@@ -22,7 +22,7 @@ public class RSJEIPlugin implements IModPlugin {
         registry.addRecipeRegistryPlugin(new RecipeRegistryPluginCover());
         registry.addRecipeRegistryPlugin(new RecipeRegistryPluginHollowCover());
 
-        // TODO: #1905
+        // TODO: https://github.com/mezz/JustEnoughItems/issues/1307
         // registry.addGhostIngredientHandler(GuiBase.class, new GhostIngredientHandler());
     }
 

src/main/java/com/raoulvdberge/refinedstorage/inventory/fluid/FluidHandlerProxy.java

@@ -8,17 +8,17 @@ import net.minecraftforge.fluids.capability.IFluidTankProperties;
 
 import javax.annotation.Nullable;
 
-public class FluidHandlerFluidInterface implements IFluidHandler {
+public class FluidHandlerProxy implements IFluidHandler {
-    private FluidTank input;
+    private FluidTank insertHandler;
-    private FluidTank output;
+    private FluidTank extractHandler;
     private IFluidTankProperties[] properties;
 
-    public FluidHandlerFluidInterface(FluidTank input, FluidTank output) {
+    public FluidHandlerProxy(FluidTank insertHandler, FluidTank extractHandler) {
-        this.input = input;
+        this.insertHandler = insertHandler;
-        this.output = output;
+        this.extractHandler = extractHandler;
         this.properties = new IFluidTankProperties[]{
-            new FluidTankPropertiesWrapper(input),
+            new FluidTankPropertiesWrapper(insertHandler),
-            new FluidTankPropertiesWrapper(output)
+            new FluidTankPropertiesWrapper(extractHandler)
         };
     }
 
@@ -29,18 +29,18 @@ public class FluidHandlerFluidInterface implements IFluidHandler {
 
     @Override
     public int fill(FluidStack resource, boolean doFill) {
-        return input.fill(resource, doFill);
+        return insertHandler.fill(resource, doFill);
     }
 
     @Nullable
     @Override
     public FluidStack drain(FluidStack resource, boolean doDrain) {
-        return output.drain(resource, doDrain);
+        return extractHandler.drain(resource, doDrain);
     }
 
     @Nullable
     @Override
     public FluidStack drain(int maxDrain, boolean doDrain) {
-        return output.drain(maxDrain, doDrain);
+        return extractHandler.drain(maxDrain, doDrain);
     }
 }

src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridFluidDelta.java

@@ -15,8 +15,12 @@ import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 import org.apache.commons.lang3.tuple.Pair;
 
+import javax.annotation.Nullable;
+
 public class MessageGridFluidDelta implements IMessage, IMessageHandler<MessageGridFluidDelta, IMessage> {
+    @Nullable
     private INetwork network;
+    private IStorageTracker<FluidStack> storageTracker;
     private FluidStack stack;
     private int delta;
 
@@ -25,8 +29,9 @@ public class MessageGridFluidDelta implements IMessage, IMessageHandler<MessageG
     public MessageGridFluidDelta() {
     }
 
-    public MessageGridFluidDelta(INetwork network, FluidStack stack, int delta) {
+    public MessageGridFluidDelta(@Nullable INetwork network, IStorageTracker<FluidStack> storageTracker, FluidStack stack, int delta) {
         this.network = network;
+        this.storageTracker = storageTracker;
         this.stack = stack;
         this.delta = delta;
     }
@@ -43,14 +48,18 @@ public class MessageGridFluidDelta implements IMessage, IMessageHandler<MessageG
     public void toBytes(ByteBuf buf) {
         StackUtils.writeFluidStackAndHash(buf, stack);
 
-        IStorageTracker.IStorageTrackerEntry entry = network.getFluidStorageTracker().get(stack);
+        IStorageTracker.IStorageTrackerEntry entry = storageTracker.get(stack);
         buf.writeBoolean(entry != null);
         if (entry != null) {
             buf.writeLong(entry.getTime());
             ByteBufUtils.writeUTF8String(buf, entry.getName());
         }
 
+        if (network != null) {
             buf.writeBoolean(network.getCraftingManager().getPattern(stack) != null);
+        } else {
+            buf.writeBoolean(false);
+        }
 
         buf.writeInt(delta);
     }

src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridFluidUpdate.java

@@ -8,6 +8,7 @@ import com.raoulvdberge.refinedstorage.gui.GuiBase;
 import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
 import com.raoulvdberge.refinedstorage.gui.grid.stack.GridStackFluid;
 import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack;
+import com.raoulvdberge.refinedstorage.gui.grid.view.GridViewFluid;
 import com.raoulvdberge.refinedstorage.util.StackUtils;
 import io.netty.buffer.ByteBuf;
 import net.minecraftforge.fluids.FluidStack;
@@ -19,37 +20,19 @@ import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
 
 public class MessageGridFluidUpdate implements IMessage, IMessageHandler<MessageGridFluidUpdate, IMessage> {
     private INetwork network;
     private boolean canCraft;
     private List<IGridStack> stacks = new ArrayList<>();
+    private Consumer<ByteBuf> sendHandler;
 
     public MessageGridFluidUpdate() {
     }
 
     public MessageGridFluidUpdate(INetwork network, boolean canCraft) {
-        this.network = network;
+        this(buf -> {
-        this.canCraft = canCraft;
-    }
-
-    @Override
-    public void fromBytes(ByteBuf buf) {
-        canCraft = buf.readBoolean();
-
-        int items = buf.readInt();
-
-        for (int i = 0; i < items; ++i) {
-            Pair<Integer, FluidStack> hashAndFluidStack = StackUtils.readFluidStackAndHash(buf);
-
-            this.stacks.add(new GridStackFluid(hashAndFluidStack.getLeft(), hashAndFluidStack.getRight(), buf.readBoolean() ? new StorageTrackerEntry(buf) : null, buf.readBoolean(), buf.readBoolean()));
-        }
-    }
-
-    @Override
-    public void toBytes(ByteBuf buf) {
-        buf.writeBoolean(canCraft);
-
             int size = network.getFluidStorageCache().getList().getStacks().size();
 
             for (ICraftingPattern pattern : network.getCraftingManager().getPatterns()) {
@@ -87,11 +70,38 @@ public class MessageGridFluidUpdate implements IMessage, IMessageHandler<Message
                     buf.writeBoolean(true);
                 }
             }
+        }, canCraft);
+    }
+
+    public MessageGridFluidUpdate(Consumer<ByteBuf> sendHandler, boolean canCraft) {
+        this.sendHandler = sendHandler;
+        this.canCraft = canCraft;
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        canCraft = buf.readBoolean();
+
+        int items = buf.readInt();
+
+        for (int i = 0; i < items; ++i) {
+            Pair<Integer, FluidStack> hashAndFluidStack = StackUtils.readFluidStackAndHash(buf);
+
+            this.stacks.add(new GridStackFluid(hashAndFluidStack.getLeft(), hashAndFluidStack.getRight(), buf.readBoolean() ? new StorageTrackerEntry(buf) : null, buf.readBoolean(), buf.readBoolean()));
+        }
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeBoolean(canCraft);
+
+        sendHandler.accept(buf);
     }
 
     @Override
     public IMessage onMessage(MessageGridFluidUpdate message, MessageContext ctx) {
         GuiBase.executeLater(GuiGrid.class, grid -> {
+            grid.setView(new GridViewFluid(grid, GuiGrid.getDefaultSorter(), GuiGrid.getSorters()));
             grid.getView().setCanCraft(message.canCraft);
             grid.getView().setStacks(message.stacks);
             grid.getView().sort();

src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridItemUpdate.java

@@ -7,6 +7,7 @@ import com.raoulvdberge.refinedstorage.gui.GuiBase;
 import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
 import com.raoulvdberge.refinedstorage.gui.grid.stack.GridStackItem;
 import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack;
+import com.raoulvdberge.refinedstorage.gui.grid.view.GridViewItem;
 import com.raoulvdberge.refinedstorage.util.StackUtils;
 import io.netty.buffer.ByteBuf;
 import net.minecraft.item.ItemStack;
@@ -91,6 +92,7 @@ public class MessageGridItemUpdate implements IMessage, IMessageHandler<MessageG
     @Override
     public IMessage onMessage(MessageGridItemUpdate message, MessageContext ctx) {
         GuiBase.executeLater(GuiGrid.class, grid -> {
+            grid.setView(new GridViewItem(grid, GuiGrid.getDefaultSorter(), GuiGrid.getSorters()));
             grid.getView().setCanCraft(message.canCraft);
             grid.getView().setStacks(message.stacks);
             grid.getView().sort();

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/IPortableGrid.java

@@ -1,10 +1,11 @@
 package com.raoulvdberge.refinedstorage.tile.grid.portable;
 
 import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
+import com.raoulvdberge.refinedstorage.api.storage.IStorageTracker;
 import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDisk;
-import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageTrackerItem;
 import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
 import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
 import javax.annotation.Nullable;
@@ -20,10 +21,27 @@ public interface IPortableGrid {
         boolean isActive();
     }
 
-    IStorageCache<ItemStack> getCache();
+    @Nullable
+    IStorageCache getCache();
+
+    default IStorageCache<ItemStack> getItemCache() {
+        return (IStorageCache<ItemStack>) getCache();
+    }
+
+    default IStorageCache<FluidStack> getFluidCache() {
+        return (IStorageCache<FluidStack>) getCache();
+    }
 
     @Nullable
-    IStorageDisk<ItemStack> getStorage();
+    IStorageDisk getStorage();
+
+    default IStorageDisk<ItemStack> getItemStorage() {
+        return (IStorageDisk<ItemStack>) getStorage();
+    }
+
+    default IStorageDisk<FluidStack> getFluidStorage() {
+        return (IStorageDisk<FluidStack>) getStorage();
+    }
 
     void drainEnergy(int energy);
 
@@ -33,5 +51,7 @@ public interface IPortableGrid {
 
     IItemHandlerModifiable getFilter();
 
-    StorageTrackerItem getStorageTracker();
+    IStorageTracker<ItemStack> getItemStorageTracker();
+
+    IStorageTracker<FluidStack> getFluidStorageTracker();
 }

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/PortableGrid.java

@@ -9,15 +9,17 @@ import com.raoulvdberge.refinedstorage.api.network.grid.handler.IItemGridHandler
 import com.raoulvdberge.refinedstorage.api.storage.AccessType;
 import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
 import com.raoulvdberge.refinedstorage.api.storage.IStorageCacheListener;
+import com.raoulvdberge.refinedstorage.api.storage.StorageType;
 import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDisk;
 import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskContainerContext;
+import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskProvider;
 import com.raoulvdberge.refinedstorage.api.util.IFilter;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
+import com.raoulvdberge.refinedstorage.apiimpl.network.grid.handler.FluidGridHandlerPortable;
 import com.raoulvdberge.refinedstorage.apiimpl.network.grid.handler.ItemGridHandlerPortable;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskdrive.NetworkNodeDiskDrive;
-import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItemPortable;
+import com.raoulvdberge.refinedstorage.apiimpl.storage.*;
-import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheListenerGridPortable;
+import com.raoulvdberge.refinedstorage.apiimpl.storage.disk.StorageDiskFluidPortable;
-import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageTrackerItem;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.disk.StorageDiskItemPortable;
 import com.raoulvdberge.refinedstorage.gui.GuiBase;
 import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
@@ -47,12 +49,16 @@ import java.util.List;
 public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainerContext {
     public static int ID;
 
-    public static final String NBT_STORAGE_TRACKER = "StorageTracker";
+    static final String NBT_STORAGE_TRACKER = "StorageTracker";
+    static final String NBT_FLUID_STORAGE_TRACKER = "FluidStorageTracker";
 
     @Nullable
-    private IStorageDisk<ItemStack> storage;
+    private IStorageDisk storage;
-    private StorageCacheItemPortable cache = new StorageCacheItemPortable(this);
+    @Nullable
-    private ItemGridHandlerPortable handler = new ItemGridHandlerPortable(this, this);
+    private IStorageCache cache;
+
+    private ItemGridHandlerPortable itemHandler = new ItemGridHandlerPortable(this, this);
+    private FluidGridHandlerPortable fluidHandler = new FluidGridHandlerPortable(this);
 
     private EntityPlayer player;
     private ItemStack stack;
@@ -64,7 +70,8 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
     private int tabPage;
     private int size;
 
-    private StorageTrackerItem storageTracker = new StorageTrackerItem(() -> stack.getTagCompound().setTag(NBT_STORAGE_TRACKER, getStorageTracker().serializeNbt()));
+    private StorageTrackerItem storageTracker = new StorageTrackerItem(() -> stack.getTagCompound().setTag(NBT_STORAGE_TRACKER, getItemStorageTracker().serializeNbt()));
+    private StorageTrackerFluid fluidStorageTracker = new StorageTrackerFluid(() -> stack.getTagCompound().setTag(NBT_FLUID_STORAGE_TRACKER, getFluidStorageTracker().serializeNbt()));
 
     private List<IFilter> filters = new ArrayList<>();
     private List<IGridTab> tabs = new ArrayList<>();
@@ -80,7 +87,7 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
             StackUtils.writeItems(this, 0, stack.getTagCompound());
         }
     };
-    private ItemHandlerBase disk = new ItemHandlerBase(1, s -> NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK.test(s) && true) {
+    private ItemHandlerBase disk = new ItemHandlerBase(1, NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);
@@ -90,18 +97,34 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
 
                 if (diskStack.isEmpty()) {
                     storage = null;
+                    cache = null;
                 } else {
-                    IStorageDisk disk = API.instance().getStorageDiskManager(player.getEntityWorld()).getByStack(diskStack);
+                    IStorageDisk disk = API.instance().getStorageDiskManager(player.getEntityWorld()).getByStack(getDisk().getStackInSlot(0));
 
                     if (disk != null) {
+                        StorageType type = ((IStorageDiskProvider) getDisk().getStackInSlot(0).getItem()).getType();
+
+                        switch (type) {
+                            case ITEM:
                                 storage = new StorageDiskItemPortable(disk, PortableGrid.this);
+                                cache = new StorageCacheItemPortable(PortableGrid.this);
+                                break;
+                            case FLUID:
+                                storage = new StorageDiskFluidPortable(disk, PortableGrid.this);
+                                cache = new StorageCacheFluidPortable(PortableGrid.this);
+                                break;
+                        }
+
                         storage.setSettings(null, PortableGrid.this);
                     } else {
                         storage = null;
+                        cache = null;
                     }
                 }
 
+                if (cache != null) {
                     cache.invalidate();
+                }
 
                 StackUtils.writeItems(this, 4, stack.getTagCompound());
             }
@@ -129,6 +152,10 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
             storageTracker.readFromNbt(stack.getTagCompound().getTagList(NBT_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
         }
 
+        if (stack.getTagCompound().hasKey(NBT_FLUID_STORAGE_TRACKER)) {
+            fluidStorageTracker.readFromNbt(stack.getTagCompound().getTagList(NBT_FLUID_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
+        }
+
         StackUtils.readItems(disk, 4, stack.getTagCompound());
 
         if (!player.getEntityWorld().isRemote) {
@@ -138,11 +165,6 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
         StackUtils.readItems(filter, 0, stack.getTagCompound());
 
         drainEnergy(RS.INSTANCE.config.portableGridOpenUsage);
-
-        // If there is no disk onContentsChanged isn't called and the update isn't sent, thus items from the previous grid view would remain clientside
-        if (!player.getEntityWorld().isRemote && disk.getStackInSlot(0).isEmpty()) {
-            cache.invalidate();
-        }
     }
 
     public ItemStack getStack() {
@@ -150,13 +172,14 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
     }
 
     @Override
-    public StorageCacheItemPortable getCache() {
+    @Nullable
+    public IStorageCache getCache() {
         return cache;
     }
 
     @Override
     @Nullable
-    public IStorageDisk<ItemStack> getStorage() {
+    public IStorageDisk getStorage() {
         return storage;
     }
 
@@ -187,7 +210,7 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
 
     @Override
     public GridType getGridType() {
-        return GridType.NORMAL;
+        return (getDisk().getStackInSlot(0).isEmpty() || ((IStorageDiskProvider) getDisk().getStackInSlot(0).getItem()).getType() == StorageType.ITEM) ? GridType.NORMAL : GridType.FLUID;
     }
 
     @Nullable
@@ -198,19 +221,19 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
 
     @Override
     public IStorageCacheListener createListener(EntityPlayerMP player) {
-        return new StorageCacheListenerGridPortable(this, player);
+        return getGridType() == GridType.FLUID ? new StorageCacheListenerGridPortableFluid(this, player) : new StorageCacheListenerGridPortable(this, player);
     }
 
     @Nullable
     @Override
     public IItemGridHandler getItemHandler() {
-        return handler;
+        return itemHandler;
     }
 
     @Nullable
     @Override
     public IFluidGridHandler getFluidHandler() {
-        return null;
+        return fluidHandler;
     }
 
     @Override
@@ -333,10 +356,15 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
     }
 
     @Override
-    public StorageTrackerItem getStorageTracker() {
+    public StorageTrackerItem getItemStorageTracker() {
         return storageTracker;
     }
 
+    @Override
+    public StorageTrackerFluid getFluidStorageTracker() {
+        return fluidStorageTracker;
+    }
+
     @Override
     public InventoryCrafting getCraftingMatrix() {
         return null;

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/TilePortableGrid.java

@@ -7,21 +7,18 @@ import com.raoulvdberge.refinedstorage.api.network.grid.IGrid;
 import com.raoulvdberge.refinedstorage.api.network.grid.IGridTab;
 import com.raoulvdberge.refinedstorage.api.network.grid.handler.IFluidGridHandler;
 import com.raoulvdberge.refinedstorage.api.network.grid.handler.IItemGridHandler;
-import com.raoulvdberge.refinedstorage.api.storage.AccessType;
+import com.raoulvdberge.refinedstorage.api.storage.*;
-import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
-import com.raoulvdberge.refinedstorage.api.storage.IStorageCacheListener;
-import com.raoulvdberge.refinedstorage.api.storage.StorageType;
 import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDisk;
 import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskContainerContext;
 import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskProvider;
 import com.raoulvdberge.refinedstorage.api.util.IFilter;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
+import com.raoulvdberge.refinedstorage.apiimpl.network.grid.handler.FluidGridHandlerPortable;
 import com.raoulvdberge.refinedstorage.apiimpl.network.grid.handler.ItemGridHandlerPortable;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskdrive.NetworkNodeDiskDrive;
-import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItemPortable;
+import com.raoulvdberge.refinedstorage.apiimpl.storage.*;
-import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheListenerGridPortable;
+import com.raoulvdberge.refinedstorage.apiimpl.storage.disk.StorageDiskFluidPortable;
-import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageTrackerItem;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.disk.StorageDiskItemPortable;
 import com.raoulvdberge.refinedstorage.block.BlockPortableGrid;
 import com.raoulvdberge.refinedstorage.block.enums.PortableGridDiskState;
@@ -55,6 +52,7 @@ import net.minecraftforge.common.capabilities.Capability;
 import net.minecraftforge.common.util.Constants;
 import net.minecraftforge.energy.CapabilityEnergy;
 import net.minecraftforge.energy.EnergyStorage;
+import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
 import javax.annotation.Nonnull;
@@ -64,32 +62,32 @@ import java.util.List;
 
 public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid, IRedstoneConfigurable, IStorageDiskContainerContext, IPortableGrid.IPortableGridRenderInfo {
     public static final TileDataParameter<Integer, TilePortableGrid> REDSTONE_MODE = RedstoneMode.createParameter();
-    public static final TileDataParameter<Integer, TilePortableGrid> ENERGY_STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.energyStorage.getEnergyStored());
+    private static final TileDataParameter<Integer, TilePortableGrid> ENERGY_STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.energyStorage.getEnergyStored());
-    public static final TileDataParameter<Integer, TilePortableGrid> SORTING_DIRECTION = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSortingDirection, (t, v) -> {
+    private static final TileDataParameter<Integer, TilePortableGrid> SORTING_DIRECTION = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSortingDirection, (t, v) -> {
         if (IGrid.isValidSortingDirection(v)) {
             t.setSortingDirection(v);
             t.markDirty();
         }
     }, (initial, p) -> TileGrid.trySortGrid(initial));
-    public static final TileDataParameter<Integer, TilePortableGrid> SORTING_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSortingType, (t, v) -> {
+    private static final TileDataParameter<Integer, TilePortableGrid> SORTING_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSortingType, (t, v) -> {
         if (IGrid.isValidSortingType(v)) {
             t.setSortingType(v);
             t.markDirty();
         }
     }, (initial, p) -> TileGrid.trySortGrid(initial));
-    public static final TileDataParameter<Integer, TilePortableGrid> SEARCH_BOX_MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSearchBoxMode, (t, v) -> {
+    private static final TileDataParameter<Integer, TilePortableGrid> SEARCH_BOX_MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSearchBoxMode, (t, v) -> {
         if (IGrid.isValidSearchBoxMode(v)) {
             t.setSearchBoxMode(v);
             t.markDirty();
         }
     }, (initial, p) -> GuiBase.executeLater(GuiGrid.class, grid -> grid.getSearchField().setMode(p)));
-    public static final TileDataParameter<Integer, TilePortableGrid> SIZE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSize, (t, v) -> {
+    private static final TileDataParameter<Integer, TilePortableGrid> SIZE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSize, (t, v) -> {
         if (IGrid.isValidSize(v)) {
             t.setSize(v);
             t.markDirty();
         }
     }, (initial, p) -> GuiBase.executeLater(GuiGrid.class, GuiBase::initGui));
-    public static final TileDataParameter<Integer, TilePortableGrid> TAB_SELECTED = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getTabSelected, (t, v) -> {
+    private static final TileDataParameter<Integer, TilePortableGrid> TAB_SELECTED = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getTabSelected, (t, v) -> {
         t.setTabSelected(v == t.getTabSelected() ? -1 : v);
         t.markDirty();
     }, (initial, p) -> {
@@ -97,7 +95,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
             GuiBase.executeLater(GuiGrid.class, grid -> grid.getView().sort());
         }
     });
-    public static final TileDataParameter<Integer, TilePortableGrid> TAB_PAGE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getTabPage, (t, v) -> {
+    private static final TileDataParameter<Integer, TilePortableGrid> TAB_PAGE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getTabPage, (t, v) -> {
         if (v >= 0 && v <= t.getTotalTabPages()) {
             t.setTabPage(v);
             t.markDirty();
@@ -108,6 +106,8 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
     private static final String NBT_DISK_STATE = "DiskState";
     private static final String NBT_CONNECTED = "Connected";
     private static final String NBT_STORAGE_TRACKER = "StorageTracker";
+    private static final String NBT_FLUID_STORAGE_TRACKER = "FluidStorageTracker";
+    private static final String NBT_TYPE = "Type";
 
     private EnergyStorage energyStorage = recreateEnergyStorage(0);
     private PortableGridType type;
@@ -121,10 +121,12 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
     private int tabPage;
     private int size;
 
+    private GridType clientGridType;
+
     private List<IFilter> filters = new ArrayList<>();
     private List<IGridTab> tabs = new ArrayList<>();
     private ItemHandlerFilter filter = new ItemHandlerFilter(filters, tabs, new ListenerTile(this));
-    private ItemHandlerBase disk = new ItemHandlerBase(1, new ListenerTile(this), s -> NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK.test(s) && ((IStorageDiskProvider) s.getItem()).getType() == StorageType.ITEM) {
+    private ItemHandlerBase disk = new ItemHandlerBase(1, new ListenerTile(this), NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);
@@ -136,14 +138,17 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
     };
 
     @Nullable
-    private IStorageDisk<ItemStack> storage;
+    private IStorageDisk storage;
+    @Nullable
+    private IStorageCache cache;
 
-    private StorageCacheItemPortable cache = new StorageCacheItemPortable(this);
+    private ItemGridHandlerPortable itemHandler = new ItemGridHandlerPortable(this, this);
-    private ItemGridHandlerPortable handler = new ItemGridHandlerPortable(this, this);
+    private FluidGridHandlerPortable fluidHandler = new FluidGridHandlerPortable(this);
     private PortableGridDiskState diskState = PortableGridDiskState.NONE;
     private boolean connected;
 
     private StorageTrackerItem storageTracker = new StorageTrackerItem(this::markDirty);
+    private StorageTrackerFluid fluidStorageTracker = new StorageTrackerFluid(this::markDirty);
 
     public TilePortableGrid() {
         dataManager.addWatchedParameter(REDSTONE_MODE);
@@ -161,20 +166,38 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
 
         if (diskStack.isEmpty()) {
             this.storage = null;
+            this.cache = null;
         } else {
             IStorageDisk disk = API.instance().getStorageDiskManager(world).getByStack(getDisk().getStackInSlot(0));
 
             if (disk != null) {
+                StorageType type = ((IStorageDiskProvider) getDisk().getStackInSlot(0).getItem()).getType();
+
+                switch (type) {
+                    case ITEM:
                         this.storage = new StorageDiskItemPortable(disk, this);
+                        this.cache = new StorageCacheItemPortable(this);
+                        break;
+                    case FLUID:
+                        this.storage = new StorageDiskFluidPortable(disk, this);
+                        this.cache = new StorageCacheFluidPortable(this);
+                        break;
+                }
+
                 this.storage.setSettings(TilePortableGrid.this::checkIfDiskStateChanged, TilePortableGrid.this);
             } else {
                 this.storage = null;
+                this.cache = null;
             }
         }
 
-        this.cache.invalidate();
+        if (cache != null) {
+            cache.invalidate();
+        }
 
-        this.checkIfDiskStateChanged();
+        checkIfDiskStateChanged();
+
+        WorldUtils.updateBlock(world, pos);
     }
 
     public PortableGridDiskState getDiskState() {
@@ -188,6 +211,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
     public PortableGridType getPortableType() {
         if (type == null) {
             IBlockState state = world.getBlockState(pos);
+
             if (state.getBlock() == RSBlocks.PORTABLE_GRID) {
                 this.type = (PortableGridType) state.getValue(BlockPortableGrid.TYPE);
             }
@@ -218,6 +242,10 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
             if (stack.getTagCompound().hasKey(PortableGrid.NBT_STORAGE_TRACKER)) {
                 storageTracker.readFromNbt(stack.getTagCompound().getTagList(PortableGrid.NBT_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
             }
+
+            if (stack.getTagCompound().hasKey(PortableGrid.NBT_FLUID_STORAGE_TRACKER)) {
+                fluidStorageTracker.readFromNbt(stack.getTagCompound().getTagList(PortableGrid.NBT_FLUID_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
+            }
         }
 
         this.diskState = getDiskState(this);
@@ -242,6 +270,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
         stack.getTagCompound().setInteger(NetworkNodeGrid.NBT_TAB_PAGE, tabPage);
 
         stack.getTagCompound().setTag(PortableGrid.NBT_STORAGE_TRACKER, storageTracker.serializeNbt());
+        stack.getTagCompound().setTag(PortableGrid.NBT_FLUID_STORAGE_TRACKER, fluidStorageTracker.serializeNbt());
 
         stack.getCapability(CapabilityEnergy.ENERGY, null).receiveEnergy(energyStorage.getEnergyStored(), false);
 
@@ -258,7 +287,11 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
 
     @Override
     public GridType getGridType() {
-        return GridType.NORMAL;
+        return clientGridType != null ? clientGridType : getServerGridType();
+    }
+
+    private GridType getServerGridType() {
+        return (getDisk().getStackInSlot(0).isEmpty() || ((IStorageDiskProvider) getDisk().getStackInSlot(0).getItem()).getType() == StorageType.ITEM) ? GridType.NORMAL : GridType.FLUID;
     }
 
     @Nullable
@@ -269,19 +302,19 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
 
     @Override
     public IStorageCacheListener createListener(EntityPlayerMP player) {
-        return new StorageCacheListenerGridPortable(this, player);
+        return getServerGridType() == GridType.FLUID ? new StorageCacheListenerGridPortableFluid(this, player) : new StorageCacheListenerGridPortable(this, player);
     }
 
     @Nullable
     @Override
     public IItemGridHandler getItemHandler() {
-        return handler;
+        return itemHandler;
     }
 
     @Nullable
     @Override
     public IFluidGridHandler getFluidHandler() {
-        return null;
+        return fluidHandler;
     }
 
     @Override
@@ -406,10 +439,15 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
     }
 
     @Override
-    public StorageTrackerItem getStorageTracker() {
+    public IStorageTracker<ItemStack> getItemStorageTracker() {
         return storageTracker;
     }
 
+    @Override
+    public IStorageTracker<FluidStack> getFluidStorageTracker() {
+        return fluidStorageTracker;
+    }
+
     @Override
     public InventoryCrafting getCraftingMatrix() {
         return null;
@@ -463,13 +501,14 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
     }
 
     @Override
-    public IStorageCache<ItemStack> getCache() {
+    @Nullable
+    public IStorageCache getCache() {
         return cache;
     }
 
     @Override
     @Nullable
-    public IStorageDisk<ItemStack> getStorage() {
+    public IStorageDisk getStorage() {
         return storage;
     }
 
@@ -552,6 +591,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
         redstoneMode.write(tag);
 
         tag.setTag(NBT_STORAGE_TRACKER, storageTracker.serializeNbt());
+        tag.setTag(NBT_FLUID_STORAGE_TRACKER, fluidStorageTracker.serializeNbt());
 
         return tag;
     }
@@ -596,6 +636,10 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
         if (tag.hasKey(NBT_STORAGE_TRACKER)) {
             storageTracker.readFromNbt(tag.getTagList(NBT_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
         }
+
+        if (tag.hasKey(NBT_FLUID_STORAGE_TRACKER)) {
+            fluidStorageTracker.readFromNbt(tag.getTagList(NBT_FLUID_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
+        }
     }
 
     @Override
@@ -612,6 +656,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
     public NBTTagCompound writeUpdate(NBTTagCompound tag) {
         tag.setInteger(NBT_DISK_STATE, diskState.getId());
         tag.setBoolean(NBT_CONNECTED, getEnergy() != 0);
+        tag.setInteger(NBT_TYPE, getServerGridType().ordinal());
 
         return super.writeUpdate(tag);
     }
@@ -622,6 +667,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
 
         diskState = PortableGridDiskState.getById(tag.getInteger(NBT_DISK_STATE));
         connected = tag.getBoolean(NBT_CONNECTED);
+        clientGridType = GridType.values()[tag.getInteger(NBT_TYPE)];
     }
 
     @Override