Fluid Interface Exporting

src/main/java/refinedstorage/RefinedStorage.java

@@ -58,6 +58,7 @@ public final class RefinedStorage {
     public int exporterUsage;
     public int importerUsage;
     public int interfaceUsage;
+    public int fluidInterfaceUsage;
     public int relayUsage;
     public int soldererUsage;
     public int storageUsage;
@@ -105,6 +106,7 @@ public final class RefinedStorage {
         exporterUsage = config.getInt("exporter", "energy", 1, 0, Integer.MAX_VALUE, "The energy used by Exporters");
         importerUsage = config.getInt("importer", "energy", 1, 0, Integer.MAX_VALUE, "The energy used by Importers");
         interfaceUsage = config.getInt("interface", "energy", 3, 0, Integer.MAX_VALUE, "The energy used by Interfaces");
+        fluidInterfaceUsage = config.getInt("fluidInterface", "energy", 3, 0, Integer.MAX_VALUE, "The energy used by Fluid Interfaces");
         relayUsage = config.getInt("relay", "energy", 1, 0, Integer.MAX_VALUE, "The energy used by Relays");
         soldererUsage = config.getInt("solderer", "energy", 3, 0, Integer.MAX_VALUE, "The energy used by Solderers");
         storageUsage = config.getInt("storage", "energy", 1, 0, Integer.MAX_VALUE, "The energy used by Storage Blocks");

src/main/java/refinedstorage/container/ContainerFluidInterface.java

@@ -2,6 +2,7 @@ package refinedstorage.container;
 
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraftforge.items.SlotItemHandler;
+import refinedstorage.container.slot.SlotSpecimenFluid;
 import refinedstorage.tile.TileFluidInterface;
 
 public class ContainerFluidInterface extends ContainerBase {
@@ -12,8 +13,8 @@ public class ContainerFluidInterface extends ContainerBase {
             addSlotToContainer(new SlotItemHandler(fluidInterface.getUpgrades(), i, 187, 6 + (i * 18)));
         }
 
-        addSlotToContainer(new SlotItemHandler(fluidInterface.getBuckets(), 0, 44, 32));
+        addSlotToContainer(new SlotItemHandler(fluidInterface.getIn(), 0, 44, 32));
-        addSlotToContainer(new SlotItemHandler(fluidInterface.getBuckets(), 1, 116, 32));
+        addSlotToContainer(new SlotSpecimenFluid(!fluidInterface.getWorld().isRemote, fluidInterface.getOut(), 0, 116, 32));
 
         addPlayerInventory(8, 122);
     }

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

@@ -4,7 +4,6 @@ import mezz.jei.gui.ingredients.FluidStackRenderer;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.client.renderer.GlStateManager;
-import net.minecraft.client.renderer.RenderHelper;
 import net.minecraft.client.resources.I18n;
 import net.minecraft.inventory.Container;
 import net.minecraft.inventory.Slot;
@@ -100,6 +99,18 @@ public abstract class GuiBase extends GuiContainer {
 
         drawBackground(guiLeft, guiTop, mouseX, mouseY);
 
+        for (int i = 0; i < inventorySlots.inventorySlots.size(); ++i) {
+            Slot slot = inventorySlots.inventorySlots.get(i);
+
+            if (slot instanceof SlotItemHandler && ((SlotItemHandler) slot).getItemHandler() instanceof ItemHandlerFluid) {
+                FluidStack stack = ((ItemHandlerFluid) ((SlotItemHandler) slot).getItemHandler()).getFluids()[slot.getSlotIndex()];
+
+                if (stack != null) {
+                    FLUID_RENDERER.draw(mc, guiLeft + slot.xDisplayPosition, guiTop + slot.yDisplayPosition, stack);
+                }
+            }
+        }
+
         if (scrollbar != null) {
             GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
 
@@ -126,20 +137,6 @@ public abstract class GuiBase extends GuiContainer {
 
         drawForeground(mouseX, mouseY);
 
-        RenderHelper.enableGUIStandardItemLighting();
-
-        for (int i = 0; i < inventorySlots.inventorySlots.size(); ++i) {
-            Slot slot = inventorySlots.inventorySlots.get(i);
-
-            if (slot instanceof SlotItemHandler && ((SlotItemHandler) slot).getItemHandler() instanceof ItemHandlerFluid) {
-                FluidStack stack = ((ItemHandlerFluid) ((SlotItemHandler) slot).getItemHandler()).getFluids()[slot.getSlotIndex()];
-
-                if (stack != null) {
-                    FLUID_RENDERER.draw(mc, slot.xDisplayPosition, slot.yDisplayPosition, stack);
-                }
-            }
-        }
-
         if (sideButtonTooltip != null) {
             drawTooltip(mouseX, mouseY, sideButtonTooltip);
         }

src/main/java/refinedstorage/gui/GuiFluidInterface.java

@@ -1,10 +1,15 @@
 package refinedstorage.gui;
 
+import mezz.jei.gui.ingredients.FluidStackRenderer;
+import refinedstorage.api.storage.CompareUtils;
 import refinedstorage.container.ContainerFluidInterface;
+import refinedstorage.gui.sidebutton.SideButtonCompare;
 import refinedstorage.gui.sidebutton.SideButtonRedstoneMode;
 import refinedstorage.tile.TileFluidInterface;
 
 public class GuiFluidInterface extends GuiBase {
+    private static final FluidStackRenderer TANK_IN_RENDERER = new FluidStackRenderer(TileFluidInterface.TANK_CAPACITY, true, 12, 47, null);
+
     public GuiFluidInterface(ContainerFluidInterface container) {
         super(container, 211, 204);
     }
@@ -12,6 +17,8 @@ public class GuiFluidInterface extends GuiBase {
     @Override
     public void init(int x, int y) {
         addSideButton(new SideButtonRedstoneMode(TileFluidInterface.REDSTONE_MODE));
+
+        addSideButton(new SideButtonCompare(TileFluidInterface.COMPARE, CompareUtils.COMPARE_NBT));
     }
 
     @Override
@@ -23,6 +30,14 @@ public class GuiFluidInterface extends GuiBase {
         bindTexture("gui/fluid_interface.png");
 
         drawTexture(x, y, 0, 0, width, height);
+
+        if (TileFluidInterface.TANK_IN.getValue() != null) {
+            TANK_IN_RENDERER.draw(mc, x + 46, y + 56, TileFluidInterface.TANK_IN.getValue());
+        }
+
+        if (TileFluidInterface.TANK_OUT.getValue() != null) {
+            TANK_IN_RENDERER.draw(mc, x + 118, y + 56, TileFluidInterface.TANK_OUT.getValue());
+        }
     }
 
     @Override

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

@@ -3,39 +3,81 @@ package refinedstorage.tile;
 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.FluidTank;
 import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import refinedstorage.RefinedStorage;
 import refinedstorage.inventory.ItemHandlerBasic;
+import refinedstorage.inventory.ItemHandlerFluid;
 import refinedstorage.inventory.ItemHandlerUpgrade;
 import refinedstorage.item.ItemUpgrade;
+import refinedstorage.tile.config.IComparable;
+import refinedstorage.tile.data.ITileDataProducer;
+import refinedstorage.tile.data.RefinedStorageSerializers;
+import refinedstorage.tile.data.TileDataParameter;
 
-public class TileFluidInterface extends TileNode {
+public class TileFluidInterface extends TileNode implements IComparable {
+    public static final int TANK_CAPACITY = 16000;
+
+    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
+
+    public static final TileDataParameter<FluidStack> TANK_IN = new TileDataParameter<>(RefinedStorageSerializers.FLUID_STACK_SERIALIZER, null, new ITileDataProducer<FluidStack, TileFluidInterface>() {
+        @Override
+        public FluidStack getValue(TileFluidInterface tile) {
+            return tile.tankIn.getFluid();
+        }
+    });
+
+    public static final TileDataParameter<FluidStack> TANK_OUT = new TileDataParameter<>(RefinedStorageSerializers.FLUID_STACK_SERIALIZER, null, new ITileDataProducer<FluidStack, TileFluidInterface>() {
+        @Override
+        public FluidStack getValue(TileFluidInterface tile) {
+            return tile.tankOut.getFluid();
+        }
+    });
+
+    private static final String NBT_COMPARE = "Compare";
     private static final String NBT_TANK_IN = "TankIn";
     private static final String NBT_TANK_OUT = "TankOut";
 
-    private FluidTank tankIn = new FluidTank(16000) {
+    private int compare = 0;
+
+    private FluidTank tankIn = new FluidTank(TANK_CAPACITY) {
         @Override
         protected void onContentsChanged() {
             super.onContentsChanged();
 
+            if (worldObj != null && !worldObj.isRemote) {
+                dataManager.sendParameterToWatchers(TANK_IN);
+            }
+
             markDirty();
         }
     };
 
-    private FluidTank tankOut = new FluidTank(16000) {
+    private FluidTank tankOut = new FluidTank(TANK_CAPACITY) {
         @Override
         protected void onContentsChanged() {
             super.onContentsChanged();
 
+            if (worldObj != null && !worldObj.isRemote) {
+                dataManager.sendParameterToWatchers(TANK_OUT);
+            }
+
             markDirty();
         }
     };
 
-    private ItemHandlerBasic buckets = new ItemHandlerBasic(2, this);
+    private ItemHandlerBasic in = new ItemHandlerBasic(1, this);
+    private ItemHandlerFluid out = new ItemHandlerFluid(1, this);
 
     private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED);
 
     public TileFluidInterface() {
+        dataManager.addWatchedParameter(COMPARE);
+        dataManager.addParameter(TANK_IN);
+        dataManager.addParameter(TANK_OUT);
+
         tankIn.setCanDrain(false);
         tankIn.setCanFill(true);
 
@@ -43,16 +85,49 @@ public class TileFluidInterface extends TileNode {
         tankOut.setCanFill(false);
     }
 
+    @Override
+    public void updateNode() {
+        if (ticks % upgrades.getSpeed() == 0) {
+            FluidStack stack = out.getFluids()[0];
+
+            if (tankOut.getFluid() != null && (stack == null || (tankOut.getFluid().getFluid() != stack.getFluid()))) {
+                FluidStack remainder = tankOut.drainInternal(Fluid.BUCKET_VOLUME, true);
+
+                if (remainder != null) {
+                    network.insertFluid(remainder, remainder.amount, false);
+                }
+            } else if (stack != null) {
+                FluidStack result = network.extractFluid(stack, Fluid.BUCKET_VOLUME, compare);
+
+                if (result != null) {
+                    int remainder = Fluid.BUCKET_VOLUME - tankOut.fillInternal(result, true);
+
+                    if (remainder > 0) {
+                        network.insertFluid(stack, remainder, false);
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public int getEnergyUsage() {
+        return RefinedStorage.INSTANCE.fluidInterfaceUsage;
+    }
+
     @Override
     public NBTTagCompound write(NBTTagCompound tag) {
         super.write(tag);
 
         writeItems(upgrades, 0, tag);
-        writeItems(buckets, 1, tag);
+        writeItems(in, 1, tag);
+        writeItems(out, 2, tag);
 
         tag.setTag(NBT_TANK_IN, tankIn.writeToNBT(new NBTTagCompound()));
         tag.setTag(NBT_TANK_OUT, tankOut.writeToNBT(new NBTTagCompound()));
 
+        tag.setInteger(NBT_COMPARE, compare);
+
         return tag;
     }
 
@@ -61,7 +136,8 @@ public class TileFluidInterface extends TileNode {
         super.read(tag);
 
         readItems(upgrades, 0, tag);
-        readItems(buckets, 1, tag);
+        readItems(in, 1, tag);
+        readItems(out, 2, tag);
 
         if (tag.hasKey(NBT_TANK_IN)) {
             tankIn.readFromNBT(tag.getCompoundTag(NBT_TANK_IN));
@@ -70,14 +146,22 @@ public class TileFluidInterface extends TileNode {
         if (tag.hasKey(NBT_TANK_OUT)) {
             tankOut.readFromNBT(tag.getCompoundTag(NBT_TANK_OUT));
         }
+
+        if (tag.hasKey(NBT_COMPARE)) {
+            compare = tag.getInteger(NBT_COMPARE);
+        }
     }
 
     public ItemHandlerUpgrade getUpgrades() {
         return upgrades;
     }
 
-    public ItemHandlerBasic getBuckets() {
+    public ItemHandlerBasic getIn() {
-        return buckets;
+        return in;
+    }
+
+    public ItemHandlerFluid getOut() {
+        return out;
     }
 
     @Override
@@ -95,12 +179,12 @@ public class TileFluidInterface extends TileNode {
     }
 
     @Override
-    public void updateNode() {
+    public int getCompare() {
-
+        return compare;
     }
 
     @Override
-    public int getEnergyUsage() {
+    public void setCompare(int compare) {
-        return 0; // @TODO: x
+        this.compare = compare;
     }
 }

src/main/java/refinedstorage/tile/data/RefinedStorageSerializers.java

@@ -4,6 +4,8 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.network.PacketBuffer;
 import net.minecraft.network.datasync.DataParameter;
 import net.minecraft.network.datasync.DataSerializer;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fml.common.network.ByteBufUtils;
 import refinedstorage.tile.ClientCraftingTask;
 import refinedstorage.tile.ClientNode;
@@ -87,4 +89,32 @@ public final class RefinedStorageSerializers {
             return null;
         }
     };
+
+    public static final DataSerializer<FluidStack> FLUID_STACK_SERIALIZER = new DataSerializer<FluidStack>() {
+        @Override
+        public void write(PacketBuffer buf, FluidStack value) {
+            if (value == null) {
+                buf.writeBoolean(false);
+            } else {
+                buf.writeBoolean(true);
+                ByteBufUtils.writeUTF8String(buf, FluidRegistry.getFluidName(value));
+                buf.writeInt(value.amount);
+                buf.writeNBTTagCompoundToBuffer(value.tag);
+            }
+        }
+
+        @Override
+        public FluidStack read(PacketBuffer buf) throws IOException {
+            if (buf.readBoolean()) {
+                return new FluidStack(FluidRegistry.getFluid(ByteBufUtils.readUTF8String(buf)), buf.readInt(), buf.readNBTTagCompoundFromBuffer());
+            }
+
+            return null;
+        }
+
+        @Override
+        public DataParameter<FluidStack> createKey(int id) {
+            return null;
+        }
+    };
 }