WayofTime
/
BloodMagic
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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)
1.12
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.settings/org.eclipse.jdt.core.prefs
View File

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

5
changelog.txt
View File

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

1
src/main/java/WayofTime/bloodmagic/api/Constants.java
View File

@ -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"),

13
src/main/java/WayofTime/bloodmagic/item/routing/IFluidFilterProvider.java Normal file
View File

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

2
src/main/java/WayofTime/bloodmagic/item/routing/IItemFilterProvider.java
View File

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

15
src/main/java/WayofTime/bloodmagic/item/routing/IRoutingFilterProvider.java Normal file
View File

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

151
src/main/java/WayofTime/bloodmagic/item/routing/ItemFluidRouterFilter.java Normal file
View File

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

9
src/main/java/WayofTime/bloodmagic/item/routing/ItemRouterFilter.java
View File

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

3
src/main/java/WayofTime/bloodmagic/registry/ModItems.java
View File

@ -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());

36
src/main/java/WayofTime/bloodmagic/routing/IFluidFilter.java Normal file
View File

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

10
src/main/java/WayofTime/bloodmagic/routing/IFluidRoutingNode.java Normal file
View File

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

10
src/main/java/WayofTime/bloodmagic/routing/IInputFluidRoutingNode.java Normal file
View File

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

2
src/main/java/WayofTime/bloodmagic/routing/IItemFilter.java
View File

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

10
src/main/java/WayofTime/bloodmagic/routing/IOutputFluidRoutingNode.java Normal file
View File

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

6
src/main/java/WayofTime/bloodmagic/routing/IRoutingFilter.java Normal file
View File

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

212
src/main/java/WayofTime/bloodmagic/routing/RoutingFluidFilter.java Normal file
View File

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

1
src/main/java/WayofTime/bloodmagic/routing/TestItemFilter.java
View File

@ -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;
/**

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

16
src/main/resources/assets/bloodmagic/blockstates/item/ItemFluidRouterFilter.json Normal file
View File

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

10
src/main/resources/assets/bloodmagic/lang/en_US.lang
View File

@ -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
@ -444,7 +445,7 @@ tooltip.bloodmagic.activationCrystal.weak=Activates low-level rituals
tooltip.bloodmagic.activationCrystal.awakened=Activates more powerful rituals
tooltip.bloodmagic.activationCrystal.creative=Creative Only - Activates any ritual
tooltip.bloodmagic.diviner.currentRitual=Current Ritual:
tooltip.bloodmagic.diviner.currentRitual=Current Ritual:
tooltip.bloodmagic.diviner.blankRune=Blank Runes: %d
tooltip.bloodmagic.diviner.waterRune=Water Runes: %d
tooltip.bloodmagic.diviner.airRune=Air Runes: %d
@ -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
@ -697,9 +699,9 @@ ritual.bloodmagic.fullStomachRitual.fillRange.info=(Feeding) The range that the
ritual.bloodmagic.fullStomachRitual.chest.info=(Chest) The location of the inventory that the ritual will grab food from to feed players in range.
ritual.bloodmagic.interdictionRitual.interdictionRange.info=(Push) The area of the ritual where mobs will be pushed. All mobs are pushed away from the master ritual stone, regardless of where this area is.
ritual.bloodmagic.containmentRitual.containmentRange.info=(Containment) The area of the ritual where mobs will be pulled. All mobs are pulled towards the master ritual stone, regardless of where this area is.
ritual.bloodmagic.speedRitual.sanicRange.info=(Speed) All entities within this area are launched in the direction of the arrow formed by the ritual.
ritual.bloodmagic.speedRitual.sanicRange.info=(Speed) All entities within this area are launched in the direction of the arrow formed by the ritual.
ritual.bloodmagic.suppressionRitual.suppressionRange.info=(Suppress) All liquids within the range are suppressed.
ritual.bloodmagic.expulsionRitual.expulsionRange.info=(Expulsion)
ritual.bloodmagic.expulsionRitual.expulsionRange.info=(Expulsion)
ritual.bloodmagic.zephyrRitual.zephyrRange.info=(Suction) Items within this range will be sucked into the linked chest.
ritual.bloodmagic.zephyrRitual.chest.info=(Chest) The location of the inventory that the ritual will place the picked up items into.
ritual.bloodmagic.animalGrowthRitual.growing.info=(Growth) Animals within this range will grow much faster.
@ -708,7 +710,7 @@ ritual.bloodmagic.forsakenSoulRitual.crystal.info=(Crystal) Demon Crystals in th
ritual.bloodmagic.forsakenSoulRitual.damage.info=(Damage) Mobs within this range will be slowly damaged, and when killed will grow the crystals.
ritual.bloodmagic.crystalHarvestRitual.crystal.info=(Crystal) All Demon Will crystal clusters have a single crystal broken off, spawning the crystal into the world. If there is only one crystal on the cluster, it will not break it.
ritual.bloodmagic.placerRitual.placerRange.info=(Placement) The range that the ritual will place its blocks in.
ritual.bloodmagic.placerRitual.placerRange.info=(Placement) The range that the ritual will place its blocks in.
ritual.bloodmagic.placerRitual.chest.info=(Chest) The location of the inventory that the ritual will grab blocks from to place in the world.
ritual.bloodmagic.fellingRitual.fellingRange.info=(Cutting) The range that the ritual will search out logs and leaves in order to cut down.
ritual.bloodmagic.fellingRitual.chest.info=(Chest) The location of the inventory that the ritual will place the results into.

BIN
src/main/resources/assets/bloodmagic/textures/items/FluidRouterFilterExact.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 681 B