Added Fluid routing to the routing nodes - this is done by using the Fluid Filter and placing a fluid container as the filter.

(cherry picked from commit a5a17f6)

.settings/org.eclipse.jdt.core.prefs

@@ -1,5 +1,5 @@
 #
-#Sat Apr 02 15:31:00 EDT 2016
+#Tue Dec 13 20:41:11 EST 2016
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
 org.eclipse.jdt.core.formatter.brace_position_for_block=next_line
 org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
@@ -288,10 +288,10 @@ org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not
 org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=next_line
 eclipse.preferences.version=1
-org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
+org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=next_line
 org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
 org.eclipse.jdt.core.compiler.compliance=1.6
 org.eclipse.jdt.core.formatter.blank_lines_after_package=1
 org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16

changelog.txt

@@ -1,3 +1,8 @@
+------------------------------------------------------
+Version 2.1.1-70
+------------------------------------------------------
+- Added Fluid routing to the routing nodes - this is done by using the Fluid Filter and placing a fluid container as the filter.
+
 ------------------------------------------------------
 Version 2.1.0-69
 ------------------------------------------------------

src/main/java/WayofTime/bloodmagic/api/Constants.java

@@ -207,6 +207,7 @@ public class Constants
         NODE_ROUTER("ItemNodeRouter"),
         RITUAL_DIVINER("ItemRitualDiviner"),
         ROUTER_FILTER("ItemRouterFilter"),
+        FLUID_ROUTER_FILTER("ItemFluidRouterFilter"),
         SACRIFICIAL_DAGGER("ItemSacrificialDagger"),
         SACRIFICE_PACK("ItemPackSacrifice"),
         SELF_SACRIFICE_PACK("ItemPackSelfSacrifice"),

src/main/java/WayofTime/bloodmagic/item/routing/IFluidFilterProvider.java

@@ -0,0 +1,13 @@
+package WayofTime.bloodmagic.item.routing;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import WayofTime.bloodmagic.routing.IFluidFilter;
+
+public interface IFluidFilterProvider extends IRoutingFilterProvider
+{
+    IFluidFilter getInputFluidFilter(ItemStack stack, TileEntity tile, IFluidHandler handler);
+
+    IFluidFilter getOutputFluidFilter(ItemStack stack, TileEntity tile, IFluidHandler handler);
+}

src/main/java/WayofTime/bloodmagic/item/routing/IItemFilterProvider.java

@@ -5,7 +5,7 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.items.IItemHandler;
 import WayofTime.bloodmagic.routing.IItemFilter;
 
-public interface IItemFilterProvider
+public interface IItemFilterProvider extends IRoutingFilterProvider
 {
     IItemFilter getInputItemFilter(ItemStack stack, TileEntity tile, IItemHandler handler);
 

src/main/java/WayofTime/bloodmagic/item/routing/IRoutingFilterProvider.java

@@ -0,0 +1,15 @@
+package WayofTime.bloodmagic.item.routing;
+
+import net.minecraft.item.ItemStack;
+
+public interface IRoutingFilterProvider
+{
+    /**
+     * Translates the inputed keyStack into the proper filtered key
+     * 
+     * @param filterStack
+     * @param keyStack
+     * @return A new ItemStack which modifies the keyStack
+     */
+    ItemStack getContainedStackForItem(ItemStack filterStack, ItemStack keyStack);
+}

src/main/java/WayofTime/bloodmagic/item/routing/ItemFluidRouterFilter.java

@@ -0,0 +1,151 @@
+package WayofTime.bloodmagic.item.routing;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+
+import WayofTime.bloodmagic.BloodMagic;
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.client.IVariantProvider;
+import WayofTime.bloodmagic.item.inventory.ItemInventory;
+import WayofTime.bloodmagic.routing.IFluidFilter;
+import WayofTime.bloodmagic.routing.RoutingFluidFilter;
+import WayofTime.bloodmagic.util.GhostItemHelper;
+import WayofTime.bloodmagic.util.helper.TextHelper;
+
+public class ItemFluidRouterFilter extends Item implements IFluidFilterProvider, IVariantProvider
+{
+    public static String[] names = { "exact" };
+
+    public ItemFluidRouterFilter()
+    {
+        super();
+
+        setUnlocalizedName(Constants.Mod.MODID + ".fluidFilter.");
+        setHasSubtypes(true);
+        setCreativeTab(BloodMagic.tabBloodMagic);
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack stack)
+    {
+        return super.getUnlocalizedName(stack) + names[stack.getItemDamage()];
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void getSubItems(Item id, CreativeTabs creativeTab, List<ItemStack> list)
+    {
+        for (int i = 0; i < names.length; i++)
+            list.add(new ItemStack(id, 1, i));
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean advanced)
+    {
+        tooltip.add(TextHelper.localize("tooltip.BloodMagic.fluidFilter." + names[stack.getItemDamage()]));
+
+        super.addInformation(stack, player, tooltip, advanced);
+    }
+
+    @Override
+    public IFluidFilter getInputFluidFilter(ItemStack filterStack, TileEntity tile, IFluidHandler handler)
+    {
+        IFluidFilter testFilter = new RoutingFluidFilter();
+
+        switch (filterStack.getMetadata())
+        {
+        case 0:
+            testFilter = new RoutingFluidFilter();
+            break;
+
+        default:
+            testFilter = new RoutingFluidFilter();
+        }
+
+        List<ItemStack> filteredList = new ArrayList<ItemStack>();
+        ItemInventory inv = new ItemInventory(filterStack, 9, "");
+        for (int i = 0; i < inv.getSizeInventory(); i++)
+        {
+            ItemStack stack = inv.getStackInSlot(i);
+            if (stack == null)
+            {
+                continue;
+            }
+
+            ItemStack ghostStack = GhostItemHelper.getStackFromGhost(stack);
+
+            filteredList.add(ghostStack);
+        }
+
+        testFilter.initializeFilter(filteredList, tile, handler, false);
+        return testFilter;
+    }
+
+    @Override
+    public IFluidFilter getOutputFluidFilter(ItemStack filterStack, TileEntity tile, IFluidHandler handler)
+    {
+        IFluidFilter testFilter = new RoutingFluidFilter();
+
+        switch (filterStack.getMetadata())
+        {
+        case 0:
+            testFilter = new RoutingFluidFilter();
+            break;
+
+        default:
+            testFilter = new RoutingFluidFilter();
+        }
+
+        List<ItemStack> filteredList = new ArrayList<ItemStack>();
+        ItemInventory inv = new ItemInventory(filterStack, 9, ""); //TODO: Change to grab the filter from the Item later.
+        for (int i = 0; i < inv.getSizeInventory(); i++)
+        {
+            ItemStack stack = inv.getStackInSlot(i);
+            if (stack == null)
+            {
+                continue;
+            }
+
+            ItemStack ghostStack = GhostItemHelper.getStackFromGhost(stack);
+            if (ghostStack.stackSize == 0)
+            {
+                ghostStack.stackSize = Integer.MAX_VALUE;
+            }
+
+            filteredList.add(ghostStack);
+        }
+
+        testFilter.initializeFilter(filteredList, tile, handler, true);
+        return testFilter;
+    }
+
+    @Override
+    public List<Pair<Integer, String>> getVariants()
+    {
+        List<Pair<Integer, String>> ret = new ArrayList<Pair<Integer, String>>();
+        ret.add(new ImmutablePair<Integer, String>(0, "type=exact"));
+        return ret;
+    }
+
+    @Override
+    public ItemStack getContainedStackForItem(ItemStack filterStack, ItemStack keyStack)
+    {
+        ItemStack copyStack = keyStack.copy();
+        GhostItemHelper.setItemGhostAmount(copyStack, 0);
+        copyStack.stackSize = 1;
+        return copyStack;
+    }
+}

src/main/java/WayofTime/bloodmagic/item/routing/ItemRouterFilter.java

@@ -165,4 +165,13 @@ public class ItemRouterFilter extends Item implements IItemFilterProvider, IVari
         ret.add(new ImmutablePair<Integer, String>(3, "type=oredict"));
         return ret;
     }
+
+    @Override
+    public ItemStack getContainedStackForItem(ItemStack filterStack, ItemStack keyStack)
+    {
+        ItemStack copyStack = keyStack.copy();
+        GhostItemHelper.setItemGhostAmount(copyStack, 0);
+        copyStack.stackSize = 1;
+        return copyStack;
+    }
 }

src/main/java/WayofTime/bloodmagic/registry/ModItems.java

@@ -47,6 +47,7 @@ import WayofTime.bloodmagic.item.armour.ItemLivingArmour;
 import WayofTime.bloodmagic.item.armour.ItemSentientArmour;
 import WayofTime.bloodmagic.item.gear.ItemPackSacrifice;
 import WayofTime.bloodmagic.item.gear.ItemPackSelfSacrifice;
+import WayofTime.bloodmagic.item.routing.ItemFluidRouterFilter;
 import WayofTime.bloodmagic.item.routing.ItemNodeRouter;
 import WayofTime.bloodmagic.item.routing.ItemRouterFilter;
 import WayofTime.bloodmagic.item.sigil.ItemSigilAir;
@@ -159,6 +160,7 @@ public class ModItems
     public static final Item SENTIENT_SHOVEL;
     public static final Item NODE_ROUTER;
     public static final Item BASE_ITEM_FILTER;
+    public static final Item BASE_FLUID_FILTER;
     public static final Item CUTTING_FLUID;
     public static final Item SANGUINE_BOOK;
     public static final Item ITEM_POINTS_UPGRADE;
@@ -258,6 +260,7 @@ public class ModItems
 
         NODE_ROUTER = registerItem(new ItemNodeRouter(), Constants.BloodMagicItem.NODE_ROUTER.getRegName());
         BASE_ITEM_FILTER = registerItem(new ItemRouterFilter(), Constants.BloodMagicItem.ROUTER_FILTER.getRegName());
+        BASE_FLUID_FILTER = registerItem(new ItemFluidRouterFilter(), Constants.BloodMagicItem.FLUID_ROUTER_FILTER.getRegName());
 
         CUTTING_FLUID = registerItem(new ItemCuttingFluid(), Constants.BloodMagicItem.CUTTING_FLUID.getRegName());
 

src/main/java/WayofTime/bloodmagic/routing/IFluidFilter.java

@@ -0,0 +1,36 @@
+package WayofTime.bloodmagic.routing;
+
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+
+public interface IFluidFilter extends IRoutingFilter
+{
+    void initializeFilter(List<ItemStack> filteredList, TileEntity tile, IFluidHandler fluidHandler, boolean isFilterOutput);
+
+    /**
+     * This method is only called when the output tank this filter is managing
+     * receives an ItemStack. Should only really be called by the Input filter
+     * via it's transfer method.
+     * 
+     * @param fluidStack
+     *        - The stack to filter
+     * 
+     * @return - The remainder of the stack after it has been absorbed into the
+     *         tank.
+     */
+    FluidStack transferStackThroughOutputFilter(FluidStack fluidStack);
+
+    /**
+     * This method is only called on an input filter to transfer FluidStacks
+     * from the input tank to the output tank.
+     */
+    int transferThroughInputFilter(IFluidFilter outputFilter, int maxTransfer);
+
+    boolean doesStackMatchFilter(FluidStack testStack);
+
+    boolean doStacksMatch(FluidStack filterStack, FluidStack testStack);
+}

src/main/java/WayofTime/bloodmagic/routing/IFluidRoutingNode.java

@@ -0,0 +1,10 @@
+package WayofTime.bloodmagic.routing;
+
+import net.minecraft.util.EnumFacing;
+
+public interface IFluidRoutingNode extends IRoutingNode
+{
+    boolean isTankConnectedToSide(EnumFacing side);
+
+    int getPriority(EnumFacing side);
+}

src/main/java/WayofTime/bloodmagic/routing/IInputFluidRoutingNode.java

@@ -0,0 +1,10 @@
+package WayofTime.bloodmagic.routing;
+
+import net.minecraft.util.EnumFacing;
+
+public interface IInputFluidRoutingNode extends IFluidRoutingNode
+{
+    boolean isFluidInput(EnumFacing side);
+
+    IFluidFilter getInputFluidFilterForSide(EnumFacing side);
+}

src/main/java/WayofTime/bloodmagic/routing/IItemFilter.java

@@ -6,7 +6,7 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.items.IItemHandler;
 
-public interface IItemFilter
+public interface IItemFilter extends IRoutingFilter
 {
     void initializeFilter(List<ItemStack> filteredList, TileEntity tile, IItemHandler itemHandler, boolean isFilterOutput);
 

src/main/java/WayofTime/bloodmagic/routing/IOutputFluidRoutingNode.java

@@ -0,0 +1,10 @@
+package WayofTime.bloodmagic.routing;
+
+import net.minecraft.util.EnumFacing;
+
+public interface IOutputFluidRoutingNode extends IFluidRoutingNode
+{
+    boolean isFluidOutput(EnumFacing side);
+
+    IFluidFilter getOutputFluidFilterForSide(EnumFacing side);
+}

src/main/java/WayofTime/bloodmagic/routing/IRoutingFilter.java

@@ -0,0 +1,6 @@
+package WayofTime.bloodmagic.routing;
+
+public interface IRoutingFilter
+{
+
+}

src/main/java/WayofTime/bloodmagic/routing/RoutingFluidFilter.java

@@ -0,0 +1,212 @@
+package WayofTime.bloodmagic.routing;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidUtil;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidTankProperties;
+
+public class RoutingFluidFilter implements IFluidFilter
+{
+    protected List<FluidStack> requestList;
+    protected TileEntity accessedTile;
+    protected IFluidHandler fluidHandler;
+
+    @Override
+    public void initializeFilter(List<ItemStack> filteredList, TileEntity tile, IFluidHandler fluidHandler, boolean isFilterOutput)
+    {
+        this.accessedTile = tile;
+        this.fluidHandler = fluidHandler;
+        if (isFilterOutput)
+        {
+            //The requestList contains a list of how much can be extracted.
+            requestList = new ArrayList<FluidStack>();
+            for (ItemStack filterStack : filteredList)
+            {
+                FluidStack fluidFilterStack = getFluidStackFromItemStack(filterStack);
+                if (fluidFilterStack != null)
+                {
+                    requestList.add(fluidFilterStack);
+                }
+            }
+
+            IFluidTankProperties[] properties = fluidHandler.getTankProperties();
+
+            for (IFluidTankProperties property : properties)
+            {
+                FluidStack containedStack = property.getContents();
+                if (containedStack != null)
+                {
+                    for (FluidStack fluidFilterStack : requestList)
+                    {
+                        if (doStacksMatch(fluidFilterStack, containedStack))
+                        {
+                            fluidFilterStack.amount = Math.max(fluidFilterStack.amount - containedStack.amount, 0);
+                        }
+                    }
+                }
+            }
+        } else
+        {
+            requestList = new ArrayList<FluidStack>();
+            for (ItemStack filterStack : filteredList)
+            {
+                FluidStack fluidFilterStack = getFluidStackFromItemStack(filterStack);
+                if (fluidFilterStack != null)
+                {
+                    fluidFilterStack.amount *= -1;
+                    requestList.add(fluidFilterStack);
+                }
+            }
+
+            IFluidTankProperties[] properties = fluidHandler.getTankProperties();
+
+            for (IFluidTankProperties property : properties)
+            {
+                FluidStack containedStack = property.getContents();
+                if (containedStack != null)
+                {
+                    for (FluidStack fluidFilterStack : requestList)
+                    {
+                        if (doStacksMatch(fluidFilterStack, containedStack))
+                        {
+                            fluidFilterStack.amount += containedStack.amount;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public static FluidStack getFluidStackFromItemStack(ItemStack inputStack)
+    {
+        FluidStack fluidStack = FluidUtil.getFluidContained(inputStack);
+        fluidStack.amount = inputStack.stackSize;
+        return fluidStack;
+    }
+
+    /**
+     * Gives the remainder~
+     */
+    @Override
+    public FluidStack transferStackThroughOutputFilter(FluidStack fluidStack)
+    {
+        int allowedAmount = 0;
+        for (FluidStack filterStack : requestList)
+        {
+            if (doStacksMatch(filterStack, fluidStack))
+            {
+                allowedAmount = Math.min(filterStack.amount, fluidStack.amount);
+                break;
+            }
+        }
+
+        if (allowedAmount <= 0)
+        {
+            return fluidStack;
+        }
+
+        FluidStack copyStack = fluidStack.copy();
+        int filledAmount = fluidHandler.fill(fluidStack, true);
+        copyStack.amount = fluidStack.amount - filledAmount;
+
+        Iterator<FluidStack> itr = requestList.iterator();
+        while (itr.hasNext())
+        {
+            FluidStack filterStack = itr.next();
+            if (doStacksMatch(filterStack, copyStack))
+            {
+                filterStack.amount -= filledAmount;
+                if (filterStack.amount <= 0)
+                {
+                    itr.remove();
+                }
+            }
+        }
+
+        World world = accessedTile.getWorld();
+        BlockPos pos = accessedTile.getPos();
+        world.notifyBlockUpdate(pos, world.getBlockState(pos), world.getBlockState(pos), 3);
+
+        return copyStack.amount <= 0 ? null : copyStack;
+    }
+
+    @Override
+    public int transferThroughInputFilter(IFluidFilter outputFilter, int maxTransfer)
+    {
+        for (FluidStack filterFluidStack : requestList)
+        {
+            int allowedAmount = Math.min(filterFluidStack.amount, maxTransfer);
+            if (allowedAmount <= 0)
+            {
+                continue;
+            }
+
+            FluidStack copyStack = filterFluidStack.copy();
+            copyStack.amount = allowedAmount;
+            FluidStack drainStack = fluidHandler.drain(copyStack, false);
+            if (drainStack != null) //Can't pull this liquid out for some reason if it fails this check
+            {
+                FluidStack remainderStack = outputFilter.transferStackThroughOutputFilter(drainStack);
+                int drained = remainderStack == null ? copyStack.amount : (copyStack.amount - remainderStack.amount);
+
+                if (drained > 0)
+                {
+                    drainStack.amount = drained;
+
+                    fluidHandler.drain(drainStack, true);
+                    maxTransfer -= drained;
+                }
+
+                Iterator<FluidStack> itr = requestList.iterator();
+                while (itr.hasNext())
+                {
+                    FluidStack filterStack = itr.next();
+                    if (doStacksMatch(filterStack, copyStack))
+                    {
+                        filterStack.amount -= drained;
+                        if (filterStack.amount <= 0)
+                        {
+                            itr.remove();
+                        }
+                    }
+                }
+
+                World world = accessedTile.getWorld();
+                BlockPos pos = accessedTile.getPos();
+                world.notifyBlockUpdate(pos, world.getBlockState(pos), world.getBlockState(pos), 3);
+
+                return maxTransfer;
+            }
+        }
+
+        return 0;
+    }
+
+    @Override
+    public boolean doesStackMatchFilter(FluidStack testStack)
+    {
+        for (FluidStack filterStack : requestList)
+        {
+            if (doStacksMatch(filterStack, testStack))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean doStacksMatch(FluidStack filterStack, FluidStack testStack)
+    {
+        return testStack != null && filterStack.getFluid() == testStack.getFluid();
+    }
+}

src/main/java/WayofTime/bloodmagic/routing/TestItemFilter.java

@@ -8,6 +8,7 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 import net.minecraftforge.items.IItemHandler;
+import WayofTime.bloodmagic.util.GhostItemHelper;
 import WayofTime.bloodmagic.util.Utils;
 
 /**

src/main/java/WayofTime/bloodmagic/tile/container/ContainerItemRoutingNode.java

@@ -10,9 +10,8 @@ import net.minecraft.inventory.IInventory;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import WayofTime.bloodmagic.item.inventory.ItemInventory;
-import WayofTime.bloodmagic.item.routing.IItemFilterProvider;
+import WayofTime.bloodmagic.item.routing.IRoutingFilterProvider;
 import WayofTime.bloodmagic.tile.routing.TileFilteredRoutingNode;
-import WayofTime.bloodmagic.util.GhostItemHelper;
 
 public class ContainerItemRoutingNode extends Container
 {
@@ -100,6 +99,13 @@ public class ContainerItemRoutingNode extends Container
                                     GhostItemHelper.setItemGhostAmount(copyStack, 0);
                                     copyStack.setCount(1);
                                     slot.putStack(copyStack);
+
+                                    ItemStack filterStack = this.inventorySlots.get(0).getStack();
+                                    if (filterStack.getItem() instanceof IRoutingFilterProvider)
+                                    {
+                                        ItemStack copyStack = ((IRoutingFilterProvider) filterStack.getItem()).getContainedStackForItem(filterStack, heldStack);
+                                        slot.putStack(copyStack);
+                                    }
                                 }
                             }
                         } else
@@ -136,14 +142,14 @@ public class ContainerItemRoutingNode extends Container
             {
                 if (!this.mergeItemStack(itemstack1, slotsOccupied, slotsOccupied + 36, true))
                 {
-                    return ItemStack.EMPTY;
+                    return null;
                 }
 
                 slot.onSlotChange(itemstack1, itemstack);
             } else if (index > 0)
             {
 //                return null;
-                if (itemstack1.getItem() instanceof IItemFilterProvider) // Change to check item is a filter
+                if (itemstack1.getItem() instanceof IRoutingFilterProvider) // Change to check item is a filter
                 {
                     if (!this.mergeItemStack(itemstack1, 0, 1, false))
                     {
@@ -155,7 +161,7 @@ public class ContainerItemRoutingNode extends Container
                 return ItemStack.EMPTY;
             }
 
-            if (itemstack1.getCount() == 0)
+            if (itemstack1.isEmpty())
             {
                 slot.putStack(ItemStack.EMPTY);
             } else
@@ -195,7 +201,7 @@ public class ContainerItemRoutingNode extends Container
         @Override
         public boolean isItemValid(ItemStack itemStack)
         {
-            return itemStack.getItem() instanceof IItemFilterProvider; //TODO: Create a new Item that holds the filter.
+            return itemStack.getItem() instanceof IRoutingFilterProvider; //TODO: Create a new Item that holds the filter.
         }
 
         @Override

src/main/java/WayofTime/bloodmagic/tile/routing/TileInputRoutingNode.java

@@ -3,14 +3,19 @@ package WayofTime.bloodmagic.tile.routing;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.EnumFacing;
+import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandler;
 import net.minecraftforge.items.IItemHandler;
+import WayofTime.bloodmagic.item.routing.IFluidFilterProvider;
 import WayofTime.bloodmagic.item.routing.IItemFilterProvider;
 import WayofTime.bloodmagic.routing.DefaultItemFilter;
+import WayofTime.bloodmagic.routing.IFluidFilter;
+import WayofTime.bloodmagic.routing.IInputFluidRoutingNode;
 import WayofTime.bloodmagic.routing.IInputItemRoutingNode;
 import WayofTime.bloodmagic.routing.IItemFilter;
 import WayofTime.bloodmagic.util.Utils;
 
-public class TileInputRoutingNode extends TileFilteredRoutingNode implements IInputItemRoutingNode
+public class TileInputRoutingNode extends TileFilteredRoutingNode implements IInputItemRoutingNode, IInputFluidRoutingNode
 {
     public TileInputRoutingNode()
     {
@@ -34,11 +39,14 @@ public class TileInputRoutingNode extends TileFilteredRoutingNode implements IIn
             {
                 ItemStack filterStack = this.getFilterStack(side);
 
-                if (filterStack.isEmpty() || !(filterStack.getItem() instanceof IItemFilterProvider))
+                if (filterStack.isEmpty())
                 {
                     IItemFilter filter = new DefaultItemFilter();
                     filter.initializeFilter(null, tile, handler, false);
                     return filter;
+                } else if (!(filterStack.getItem() instanceof IItemFilterProvider))
+                {
+                    return null;
                 }
 
                 IItemFilterProvider filter = (IItemFilterProvider) filterStack.getItem();
@@ -48,4 +56,35 @@ public class TileInputRoutingNode extends TileFilteredRoutingNode implements IIn
 
         return null;
     }
+
+    @Override
+    public boolean isFluidInput(EnumFacing side)
+    {
+        return true;
+    }
+
+    @Override
+    public IFluidFilter getInputFluidFilterForSide(EnumFacing side)
+    {
+        TileEntity tile = worldObj.getTileEntity(pos.offset(side));
+        if (tile != null && tile.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side))
+        {
+            IFluidHandler handler = tile.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side);
+            ItemStack filterStack = this.getFilterStack(side);
+            if (filterStack == null || !(filterStack.getItem() instanceof IFluidFilterProvider))
+            {
+                return null;
+            }
+
+            return ((IFluidFilterProvider) filterStack.getItem()).getInputFluidFilter(filterStack, tile, handler);
+        }
+
+        return null;
+    }
+
+    @Override
+    public boolean isTankConnectedToSide(EnumFacing side)
+    {
+        return true;
+    }
 }

src/main/java/WayofTime/bloodmagic/tile/routing/TileMasterRoutingNode.java

@@ -17,9 +17,12 @@ import net.minecraft.world.World;
 import WayofTime.bloodmagic.api.Constants;
 import WayofTime.bloodmagic.api.soul.EnumDemonWillType;
 import WayofTime.bloodmagic.demonAura.WorldDemonWillHandler;
+import WayofTime.bloodmagic.routing.IFluidFilter;
+import WayofTime.bloodmagic.routing.IInputFluidRoutingNode;
 import WayofTime.bloodmagic.routing.IInputItemRoutingNode;
 import WayofTime.bloodmagic.routing.IItemFilter;
 import WayofTime.bloodmagic.routing.IMasterRoutingNode;
+import WayofTime.bloodmagic.routing.IOutputFluidRoutingNode;
 import WayofTime.bloodmagic.routing.IOutputItemRoutingNode;
 import WayofTime.bloodmagic.routing.IRoutingNode;
 import WayofTime.bloodmagic.routing.NodeHelper;
@@ -59,33 +62,65 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
         }
 
         Map<Integer, List<IItemFilter>> outputMap = new TreeMap<Integer, List<IItemFilter>>();
+        Map<Integer, List<IFluidFilter>> outputFluidMap = new TreeMap<Integer, List<IFluidFilter>>();
 
         for (BlockPos outputPos : outputNodeList)
         {
             TileEntity outputTile = getWorld().getTileEntity(outputPos);
-            if (outputTile instanceof IOutputItemRoutingNode && this.isConnected(new LinkedList<BlockPos>(), outputPos))
+            if (this.isConnected(new LinkedList<BlockPos>(), outputPos))
             {
-                IOutputItemRoutingNode outputNode = (IOutputItemRoutingNode) outputTile;
+                if (outputTile instanceof IOutputItemRoutingNode)
-
-                for (EnumFacing facing : EnumFacing.VALUES)
                 {
-                    if (!outputNode.isInventoryConnectedToSide(facing) || !outputNode.isOutput(facing))
+                    IOutputItemRoutingNode outputNode = (IOutputItemRoutingNode) outputTile;
-                    {
-                        continue;
-                    }
 
-                    IItemFilter filter = outputNode.getOutputFilterForSide(facing);
+                    for (EnumFacing facing : EnumFacing.VALUES)
-                    if (filter != null)
                     {
-                        int priority = outputNode.getPriority(facing);
+                        if (!outputNode.isInventoryConnectedToSide(facing) || !outputNode.isOutput(facing))
-                        if (outputMap.containsKey(priority))
                         {
-                            outputMap.get(priority).add(filter);
+                            continue;
-                        } else
+                        }
+
+                        IItemFilter filter = outputNode.getOutputFilterForSide(facing);
+                        if (filter != null)
                         {
-                            List<IItemFilter> filterList = new LinkedList<IItemFilter>();
+                            int priority = outputNode.getPriority(facing);
-                            filterList.add(filter);
+                            if (outputMap.containsKey(priority))
-                            outputMap.put(priority, filterList);
+                            {
+                                outputMap.get(priority).add(filter);
+                            } else
+                            {
+                                List<IItemFilter> filterList = new LinkedList<IItemFilter>();
+                                filterList.add(filter);
+                                outputMap.put(priority, filterList);
+                            }
+                        }
+                    }
+                }
+
+                if (outputTile instanceof IOutputFluidRoutingNode)
+                {
+                    IOutputFluidRoutingNode outputNode = (IOutputFluidRoutingNode) outputTile;
+
+                    for (EnumFacing facing : EnumFacing.VALUES)
+                    {
+                        if (!outputNode.isTankConnectedToSide(facing) || !outputNode.isFluidOutput(facing))
+                        {
+                            continue;
+                        }
+
+                        IFluidFilter filter = outputNode.getOutputFluidFilterForSide(facing);
+                        if (filter != null)
+                        {
+                            int priority = outputNode.getPriority(facing);
+                            if (outputMap.containsKey(priority))
+                            {
+                                outputFluidMap.get(priority).add(filter);
+                            } else
+                            {
+                                List<IFluidFilter> filterList = new LinkedList<IFluidFilter>();
+                                filterList.add(filter);
+                                outputFluidMap.put(priority, filterList);
+                            }
                         }
                     }
                 }
@@ -93,33 +128,65 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
         }
 
         Map<Integer, List<IItemFilter>> inputMap = new TreeMap<Integer, List<IItemFilter>>();
+        Map<Integer, List<IFluidFilter>> inputFluidMap = new TreeMap<Integer, List<IFluidFilter>>();
 
         for (BlockPos inputPos : inputNodeList)
         {
             TileEntity inputTile = getWorld().getTileEntity(inputPos);
-            if (inputTile instanceof IInputItemRoutingNode && this.isConnected(new LinkedList<BlockPos>(), inputPos))
+            if (this.isConnected(new LinkedList<BlockPos>(), inputPos))
             {
-                IInputItemRoutingNode inputNode = (IInputItemRoutingNode) inputTile;
+                if (inputTile instanceof IInputItemRoutingNode)
-
-                for (EnumFacing facing : EnumFacing.VALUES)
                 {
-                    if (!inputNode.isInventoryConnectedToSide(facing) || !inputNode.isInput(facing))
+                    IInputItemRoutingNode inputNode = (IInputItemRoutingNode) inputTile;
-                    {
-                        continue;
-                    }
 
-                    IItemFilter filter = inputNode.getInputFilterForSide(facing);
+                    for (EnumFacing facing : EnumFacing.VALUES)
-                    if (filter != null)
                     {
-                        int priority = inputNode.getPriority(facing);
+                        if (!inputNode.isInventoryConnectedToSide(facing) || !inputNode.isInput(facing))
-                        if (inputMap.containsKey(priority))
                         {
-                            inputMap.get(priority).add(filter);
+                            continue;
-                        } else
+                        }
+
+                        IItemFilter filter = inputNode.getInputFilterForSide(facing);
+                        if (filter != null)
                         {
-                            List<IItemFilter> filterList = new LinkedList<IItemFilter>();
+                            int priority = inputNode.getPriority(facing);
-                            filterList.add(filter);
+                            if (inputMap.containsKey(priority))
-                            inputMap.put(priority, filterList);
+                            {
+                                inputMap.get(priority).add(filter);
+                            } else
+                            {
+                                List<IItemFilter> filterList = new LinkedList<IItemFilter>();
+                                filterList.add(filter);
+                                inputMap.put(priority, filterList);
+                            }
+                        }
+                    }
+                }
+
+                if (inputTile instanceof IInputFluidRoutingNode)
+                {
+                    IInputFluidRoutingNode inputNode = (IInputFluidRoutingNode) inputTile;
+
+                    for (EnumFacing facing : EnumFacing.VALUES)
+                    {
+                        if (!inputNode.isTankConnectedToSide(facing) || !inputNode.isFluidInput(facing))
+                        {
+                            continue;
+                        }
+
+                        IFluidFilter filter = inputNode.getInputFluidFilterForSide(facing);
+                        if (filter != null)
+                        {
+                            int priority = inputNode.getPriority(facing);
+                            if (inputMap.containsKey(priority))
+                            {
+                                inputFluidMap.get(priority).add(filter);
+                            } else
+                            {
+                                List<IFluidFilter> filterList = new LinkedList<IFluidFilter>();
+                                filterList.add(filter);
+                                inputFluidMap.put(priority, filterList);
+                            }
                         }
                     }
                 }
@@ -127,6 +194,7 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
         }
 
         int maxTransfer = this.getMaxTransferForDemonWill(WorldDemonWillHandler.getCurrentWill(getWorld(), pos, EnumDemonWillType.DEFAULT));
+        int maxFluidTransfer = 1000;
 
         for (Entry<Integer, List<IItemFilter>> outputEntry : outputMap.entrySet())
         {
@@ -147,6 +215,26 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
                 }
             }
         }
+
+        for (Entry<Integer, List<IFluidFilter>> outputEntry : outputFluidMap.entrySet())
+        {
+            List<IFluidFilter> outputList = outputEntry.getValue();
+            for (IFluidFilter outputFilter : outputList)
+            {
+                for (Entry<Integer, List<IFluidFilter>> inputEntry : inputFluidMap.entrySet())
+                {
+                    List<IFluidFilter> inputList = inputEntry.getValue();
+                    for (IFluidFilter inputFilter : inputList)
+                    {
+                        maxFluidTransfer -= inputFilter.transferThroughInputFilter(outputFilter, maxFluidTransfer);
+                        if (maxFluidTransfer <= 0)
+                        {
+                            return;
+                        }
+                    }
+                }
+            }
+        }
     }
 
     public int getMaxTransferForDemonWill(double will)

src/main/java/WayofTime/bloodmagic/tile/routing/TileOutputRoutingNode.java

@@ -3,14 +3,19 @@ package WayofTime.bloodmagic.tile.routing;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.EnumFacing;
+import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandler;
 import net.minecraftforge.items.IItemHandler;
+import WayofTime.bloodmagic.item.routing.IFluidFilterProvider;
 import WayofTime.bloodmagic.item.routing.IItemFilterProvider;
 import WayofTime.bloodmagic.routing.DefaultItemFilter;
+import WayofTime.bloodmagic.routing.IFluidFilter;
 import WayofTime.bloodmagic.routing.IItemFilter;
+import WayofTime.bloodmagic.routing.IOutputFluidRoutingNode;
 import WayofTime.bloodmagic.routing.IOutputItemRoutingNode;
 import WayofTime.bloodmagic.util.Utils;
 
-public class TileOutputRoutingNode extends TileFilteredRoutingNode implements IOutputItemRoutingNode
+public class TileOutputRoutingNode extends TileFilteredRoutingNode implements IOutputItemRoutingNode, IOutputFluidRoutingNode
 {
     public TileOutputRoutingNode()
     {
@@ -34,11 +39,14 @@ public class TileOutputRoutingNode extends TileFilteredRoutingNode implements IO
             {
                 ItemStack filterStack = this.getFilterStack(side);
 
-                if (filterStack.isEmpty() || !(filterStack.getItem() instanceof IItemFilterProvider))
+                if (filterStack.isEmpty())
                 {
                     IItemFilter filter = new DefaultItemFilter();
                     filter.initializeFilter(null, tile, handler, true);
                     return filter;
+                } else if (!(filterStack.getItem() instanceof IItemFilterProvider))
+                {
+                    return null;
                 }
 
                 IItemFilterProvider filter = (IItemFilterProvider) filterStack.getItem();
@@ -48,4 +56,35 @@ public class TileOutputRoutingNode extends TileFilteredRoutingNode implements IO
 
         return null;
     }
+
+    @Override
+    public boolean isFluidOutput(EnumFacing side)
+    {
+        return true;
+    }
+
+    @Override
+    public IFluidFilter getOutputFluidFilterForSide(EnumFacing side)
+    {
+        TileEntity tile = worldObj.getTileEntity(pos.offset(side));
+        if (tile != null && tile.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side))
+        {
+            IFluidHandler handler = tile.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side);
+            ItemStack filterStack = this.getFilterStack(side);
+            if (filterStack == null || !(filterStack.getItem() instanceof IFluidFilterProvider))
+            {
+                return null;
+            }
+
+            return ((IFluidFilterProvider) filterStack.getItem()).getOutputFluidFilter(filterStack, tile, handler);
+        }
+
+        return null;
+    }
+
+    @Override
+    public boolean isTankConnectedToSide(EnumFacing side)
+    {
+        return true;
+    }
 }

src/main/resources/assets/bloodmagic/blockstates/item/ItemFluidRouterFilter.json

@@ -0,0 +1,16 @@
+{
+  "forge_marker": 1,
+  "defaults": {
+    "model": "builtin/generated",
+    "transform": "forge:default-item"
+  },
+  "variants": {
+    "type": {
+      "exact": {
+        "textures": {
+          "layer0": "bloodmagic:items/FluidRouterFilterExact"
+        }
+      }
+    }
+  }
+}

src/main/resources/assets/bloodmagic/lang/en_US.lang

@@ -182,6 +182,7 @@ item.bloodmagic.itemFilter.exact.name=Precise Item Filter
 item.bloodmagic.itemFilter.ignoreNBT.name=NBT Item Filter
 item.bloodmagic.itemFilter.modItems.name=Mod Item Filter
 item.bloodmagic.itemFilter.oreDict.name=Ore Dictionary Item Filter
+item.bloodmagic.fluidFilter.exact.name=Fluid Filter
 
 item.bloodmagic.experienceTome.name=Tome of Peritia
 item.bloodmagic.sanguineBook.name=Inspectoris Scandalum
@@ -535,6 +536,7 @@ tooltip.bloodmagic.itemFilter.oreDict=Used to filter through the Ore Dictionary
 tooltip.bloodmagic.fluid.type=Fluid Contained
 tooltip.bloodmagic.fluid.amount=Amount
 tooltip.bloodmagic.fluid.capacity=Capacity
+tooltip.bloodmagic.itemFilter.exact=Filters the fluid input/output
 
 tooltip.bloodmagic.ghost.everything=Everything
 tooltip.bloodmagic.ghost.amount=Ghost item amount: %d