lauchmelder/BloodMagic
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source 
(cherry picked from commit a5a17f6)
This commit is contained in:
WayofTime 2016-12-14 11:48:39 -08:00 • committed by Nicholas Ignoffo
parent a628adfde8
commit 65104db564
24 changed files with 725 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

18
src/main/java/WayofTime/bloodmagic/tile/container/ContainerItemRoutingNode.java
View file

@ -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

43
src/main/java/WayofTime/bloodmagic/tile/routing/TileInputRoutingNode.java
View file

@ -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;
}
}

156
src/main/java/WayofTime/bloodmagic/tile/routing/TileMasterRoutingNode.java
View file

@ -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;
for (EnumFacing facing : EnumFacing.VALUES)
if (outputTile instanceof IOutputItemRoutingNode)
{
if (!outputNode.isInventoryConnectedToSide(facing) || !outputNode.isOutput(facing))
{
continue;
}
IOutputItemRoutingNode outputNode = (IOutputItemRoutingNode) outputTile;
IItemFilter filter = outputNode.getOutputFilterForSide(facing);
if (filter != null)
for (EnumFacing facing : EnumFacing.VALUES)
{
int priority = outputNode.getPriority(facing);
if (outputMap.containsKey(priority))
if (!outputNode.isInventoryConnectedToSide(facing) || !outputNode.isOutput(facing))
{
outputMap.get(priority).add(filter);
} else
continue;
}
IItemFilter filter = outputNode.getOutputFilterForSide(facing);
if (filter != null)
{
List<IItemFilter> filterList = new LinkedList<IItemFilter>();
filterList.add(filter);
outputMap.put(priority, filterList);
int priority = outputNode.getPriority(facing);
if (outputMap.containsKey(priority))
{
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;
for (EnumFacing facing : EnumFacing.VALUES)
if (inputTile instanceof IInputItemRoutingNode)
{
if (!inputNode.isInventoryConnectedToSide(facing) || !inputNode.isInput(facing))
{
continue;
}
IInputItemRoutingNode inputNode = (IInputItemRoutingNode) inputTile;
IItemFilter filter = inputNode.getInputFilterForSide(facing);
if (filter != null)
for (EnumFacing facing : EnumFacing.VALUES)
{
int priority = inputNode.getPriority(facing);
if (inputMap.containsKey(priority))
if (!inputNode.isInventoryConnectedToSide(facing) || !inputNode.isInput(facing))
{
inputMap.get(priority).add(filter);
} else
continue;
}
IItemFilter filter = inputNode.getInputFilterForSide(facing);
if (filter != null)
{
List<IItemFilter> filterList = new LinkedList<IItemFilter>();
filterList.add(filter);
inputMap.put(priority, filterList);
int priority = inputNode.getPriority(facing);
if (inputMap.containsKey(priority))
{
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)

43
src/main/java/WayofTime/bloodmagic/tile/routing/TileOutputRoutingNode.java
View file

@ -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;
}
}