Anvilcraft/resonant-induction
2
1
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merged release valve with the tank

Browse source
This commit is contained in:
Calclavia 2014-01-19 17:25:43 +08:00
parent db4af58b2b
commit 62be2b5b1d
12 changed files with 243 additions and 270 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

142
src/main/java/resonantinduction/archaic/trough/EnumPipeMaterial.java Normal file
View file

@ -0,0 +1,142 @@
package resonantinduction.archaic.trough;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.fluids.FluidStack;
import resonantinduction.mechanical.Mechanical;
import resonantinduction.mechanical.fluid.prefab.TileFluidNetwork;
import calclavia.lib.render.ColorCode;
/**
* Enum to hold info about each pipe material. Values are by default and some can change with pipe
* upgrades.
*
* @Note unsupportedFluids should only be used by filters. All pipes should allow all fluid types.
* However, pipes that can't support the fluid should have an effect. Eg no gas support should cause
* the pipe to leak. No molten support should cause the pipe to take damage.
*
* @author DarkGuardsman
*/
public enum EnumPipeMaterial
{
/** Simple water only pipe. Should render open toped when it can */
WOOD("wood", false, true, false, -1, 200),
/** Another version of the wooden pipe */
STONE("stone", false, true, false, -1, 1000);
public String matName = "material";
List<String> unsupportedFluids = new ArrayList<String>();
public boolean canSupportGas = false;
public boolean canSupportFluids = false;
public boolean canSupportMoltenFluids = false;
public int maxPressure = 1000;
public int maxVolume = 2000;
/**
* Materials are stored as meta were there sub types are stored by NBT. Item versions of the
* pipes are still meta so there is a set spacing to allow for a large but defined range of sub
* pipes
*/
public static int spacing = 1000;
private EnumPipeMaterial()
{
this.canSupportGas = true;
this.canSupportFluids = true;
canSupportMoltenFluids = true;
}
private EnumPipeMaterial(String name, boolean gas, boolean fluid, boolean molten, String... strings)
{
this.matName = name;
this.canSupportGas = gas;
this.canSupportFluids = fluid;
this.canSupportMoltenFluids = molten;
}
private EnumPipeMaterial(String name, boolean gas, boolean fluid, boolean molten, int pressure, int volume, String... strings)
{
this(name, gas, fluid, molten, strings);
this.maxPressure = pressure;
this.maxVolume = volume;
}
public static EnumPipeMaterial get(World world, int x, int y, int z)
{
return get(world.getBlockMetadata(x, y, z));
}
public static EnumPipeMaterial get(int i)
{
if (i < EnumPipeMaterial.values().length)
{
return EnumPipeMaterial.values()[i];
}
return null;
}
public static EnumPipeMaterial get(ItemStack stack)
{
if (stack != null)
{
return getFromItemMeta(stack.getItemDamage());
}
return null;
}
public static EnumPipeMaterial getFromItemMeta(int meta)
{
meta = meta / spacing;
if (meta < EnumPipeMaterial.values().length)
{
return EnumPipeMaterial.values()[meta];
}
return EnumPipeMaterial.WOOD;
}
public int getMeta(int typeID)
{
return (this.ordinal() * spacing) + typeID;
}
public int getMeta()
{
return this.getMeta(0);
}
public static int getType(int meta)
{
return meta / spacing;
}
public static int getDropItemMeta(World world, int x, int y, int z)
{
int meta = world.getBlockMetadata(x, y, z);
TileEntity ent = world.getBlockTileEntity(x, y, z);
meta *= spacing;
if (ent instanceof TileFluidNetwork)
{
meta += ((TileFluidNetwork) ent).getSubID();
}
return meta;
}
public boolean canSupport(FluidStack fluid)
{
if (fluid != null && fluid.getFluid() != null)
{
if (fluid.getFluid().isGaseous(fluid) && this.canSupportGas)
{
return true;
}
else if (!fluid.getFluid().isGaseous(fluid) && this.canSupportFluids)
{
return true;
}
}
return false;
}
}

3
src/main/java/resonantinduction/mechanical/ClientProxy.java
View file

@ -3,8 +3,6 @@ package resonantinduction.mechanical;
import net.minecraftforge.client.MinecraftForgeClient;
import resonantinduction.core.render.RenderRIItem;
import resonantinduction.mechanical.fluid.pipe.ItemPipeRenderer;
import resonantinduction.mechanical.fluid.pipe.RenderPipe;
import resonantinduction.mechanical.fluid.pipe.TilePipe;
import resonantinduction.mechanical.fluid.tank.ItemTankRenderer;
import resonantinduction.mechanical.fluid.tank.RenderTank;
import resonantinduction.mechanical.fluid.tank.TileTank;
@ -23,7 +21,6 @@ public class ClientProxy extends CommonProxy
{
MinecraftForgeClient.registerItemRenderer(Mechanical.blockTank.blockID, new ItemTankRenderer());
MinecraftForgeClient.registerItemRenderer(Mechanical.itemPipe.itemID, new ItemPipeRenderer());
MinecraftForgeClient.registerItemRenderer(Mechanical.blockReleaseValve.blockID, new ItemPipeRenderer());
ClientRegistry.bindTileEntitySpecialRenderer(TileTank.class, RenderTank.INSTANCE);
}
}

3
src/main/java/resonantinduction/mechanical/Mechanical.java
View file

@ -16,8 +16,6 @@ import resonantinduction.mechanical.fluid.pump.TileGrate;
import resonantinduction.mechanical.fluid.pump.TilePump;
import resonantinduction.mechanical.fluid.tank.BlockTank;
import resonantinduction.mechanical.fluid.tank.TileTank;
import resonantinduction.mechanical.fluid.valve.BlockReleaseValve;
import resonantinduction.mechanical.fluid.valve.TileReleaseValve;
import resonantinduction.mechanical.gear.ItemGear;
import resonantinduction.mechanical.item.ItemPipeGauge;
import resonantinduction.mechanical.logistic.BlockDetector;
@ -96,7 +94,6 @@ public class Mechanical
blockTank = contentRegistry.createBlock(BlockTank.class, ItemBlockFluidContainer.class, TileTank.class);
blockGrate = contentRegistry.createTile(BlockGrate.class, TileGrate.class);
blockPump = contentRegistry.createTile(BlockPump.class, TilePump.class);
blockReleaseValve = contentRegistry.createTile(BlockReleaseValve.class, TileReleaseValve.class);
itemPipeGuage = contentRegistry.createItem(ItemPipeGauge.class);
itemPipe = contentRegistry.createItem(ItemPipe.class);

6
src/main/java/resonantinduction/mechanical/fluid/network/FluidNetwork.java
View file

@ -49,7 +49,11 @@ public abstract class FluidNetwork extends Network<IFluidNetwork, IFluidConnecto
this.tank = new FluidTank(0);
for (IFluidConnector part : this.getConnectors())
{
part.setNetwork(this);
if (part.getNetwork() instanceof IFluidNetwork)
{
part.setNetwork(this);
}
this.buildPart(part);
}
this.rebuildHandler();

23
src/main/java/resonantinduction/mechanical/fluid/pipe/EnumPipeMaterial.java
View file

@ -23,12 +23,8 @@ import calclavia.lib.render.ColorCode;
*/
public enum EnumPipeMaterial
{
/** Simple water only pipe. Should render open toped when it can */
WOOD("wood", false, true, false, -1, 200),
/** Gas only pipe */
GLASS("glass", true, false, false, 100, 300),
/** Another version of the wooden pipe */
STONE("stone", false, true, false, -1, 1000),
/** Cheap fluid pipe */
TIN("tin", false, true, false, 300, 1000),
/** Cheap fluid pipe */
@ -101,25 +97,6 @@ public enum EnumPipeMaterial
return null;
}
public static EnumPipeMaterial get(ItemStack stack)
{
if (stack != null)
{
return getFromItemMeta(stack.getItemDamage());
}
return null;
}
public static EnumPipeMaterial getFromItemMeta(int meta)
{
meta = meta / spacing;
if (meta < EnumPipeMaterial.values().length)
{
return EnumPipeMaterial.values()[meta];
}
return EnumPipeMaterial.WOOD;
}
public int getMeta(int typeID)
{
return (this.ordinal() * spacing) + typeID;

19
src/main/java/resonantinduction/mechanical/fluid/pipe/ItemPipe.java
View file

@ -1,5 +1,8 @@
package resonantinduction.mechanical.fluid.pipe;
import java.util.List;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.world.World;
@ -21,6 +24,22 @@ public class ItemPipe extends ItemMultipartBase
public TMultiPart newPart(ItemStack itemStack, EntityPlayer player, World world, BlockCoord pos, int side, Vector3 hit)
{
PartPipe part = (PartPipe) MultiPartRegistry.createPart("resonant_induction_pipe", false);
part.preparePlacement(itemStack.getItemDamage());
return part;
}
@Override
public int getMetadata(int damage)
{
return damage;
}
@Override
public void getSubItems(int itemID, CreativeTabs tab, List listToAddTo)
{
for (EnumPipeMaterial material : EnumPipeMaterial.values())
{
listToAddTo.add(new ItemStack(itemID, 1, material.ordinal()));
}
}
}

14
src/main/java/resonantinduction/mechanical/fluid/pipe/ItemPipeRenderer.java
View file

@ -34,13 +34,8 @@ public class ItemPipeRenderer implements IItemRenderer
{
GL11.glPushMatrix();
GL11.glRotatef(180f, 0f, 0f, 1f);
FMLClientHandler.instance().getClient().renderEngine.bindTexture(RenderPipe.getTexture(item.getItemDamage()));
int meta = item.getItemDamage();
if (Mechanical.blockReleaseValve != null && item.itemID == Mechanical.blockReleaseValve.blockID)
{
meta = EnumPipeMaterial.IRON.getMeta();
}
if (type == ItemRenderType.ENTITY)
{
GL11.glTranslatef(-.5F, -1F, -.5F);
@ -65,12 +60,7 @@ public class ItemPipeRenderer implements IItemRenderer
{
RenderPipe.render(item.getItemDamage(), (byte) 0b000011);
}
if (Mechanical.blockReleaseValve != null && item.itemID == Mechanical.blockReleaseValve.blockID)
{
FMLClientHandler.instance().getClient().renderEngine.bindTexture(RenderReleaseValve.VALVE_TEXTURE);
valve.render();
}
GL11.glPopMatrix();
}
}

46
src/main/java/resonantinduction/mechanical/fluid/pipe/PartPipe.java
View file

@ -1,7 +1,9 @@
package resonantinduction.mechanical.fluid.pipe;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.MovingObjectPosition;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
@ -11,6 +13,7 @@ import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
import resonantinduction.api.fluid.IFluidConnector;
import resonantinduction.api.fluid.IFluidNetwork;
import resonantinduction.api.fluid.IFluidPipe;
import resonantinduction.core.prefab.part.PartFramedConnection;
import resonantinduction.mechanical.Mechanical;
import resonantinduction.mechanical.fluid.network.PipeNetwork;
@ -23,20 +26,8 @@ import cpw.mods.fml.relauncher.SideOnly;
public class PartPipe extends PartFramedConnection<EnumPipeMaterial, IFluidConnector, IFluidNetwork> implements IFluidConnector, TSlottedPart, JNormalOcclusion, IHollowConnect, JIconHitEffects
{
/** Client Side Connection Check */
private ForgeDirection testingSide;
public Object[] connections = new Object[6];
/** Network used to link all parts together */
protected IFluidNetwork network;
protected FluidTank tank = new FluidTank(1 * FluidContainerRegistry.BUCKET_VOLUME);
/**
* Bitmask connections
*/
public byte currentWireConnections = 0x00;
public byte currentAcceptorConnections = 0x00;
private boolean isExtracting = false;
public PartPipe()
{
@ -55,6 +46,35 @@ public class PartPipe extends PartFramedConnection<EnumPipeMaterial, IFluidConne
return "resonant_induction_pipe";
}
@Override
public void update()
{
if (isExtracting)
{
for (int i = 0; i < this.getConnections().length; i++)
{
Object obj = this.getConnections()[i];
if (obj instanceof IFluidHandler)
{
((IFluidHandler) obj).drain(ForgeDirection.getOrientation(i).getOpposite(), FluidContainerRegistry.BUCKET_VOLUME, true);
}
}
}
}
@Override
public boolean activate(EntityPlayer player, MovingObjectPosition part, ItemStack item)
{
if (!world().isRemote)
{
isExtracting = !isExtracting;
player.addChatMessage("Pipe extraction mode: " + isExtracting);
}
return super.activate(player, part, item);
}
@Override
@SideOnly(Side.CLIENT)
public void renderDynamic(codechicken.lib.vec.Vector3 pos, float frame, int pass)

99
src/main/java/resonantinduction/mechanical/fluid/pipe/RenderPipe.java
View file

@ -23,7 +23,7 @@ public class RenderPipe
public static ModelPipe MODEL_PIPE = new ModelPipe();
public static ModelOpenTrough MODEL_TROUGH_PIPE = new ModelOpenTrough();
private static HashMap<Pair<EnumPipeMaterial, Integer>, ResourceLocation> TEXTURES = new HashMap<Pair<EnumPipeMaterial, Integer>, ResourceLocation>();
private static HashMap<EnumPipeMaterial, ResourceLocation> TEXTURES = new HashMap<EnumPipeMaterial, ResourceLocation>();
public static ResourceLocation TEXTURE = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "pipe/iron.png");
public void render(PartPipe part, double x, double y, double z, float f)
@ -32,80 +32,61 @@ public class RenderPipe
GL11.glPushMatrix();
GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
GL11.glScalef(1.0F, -1F, -1F);
FMLClientHandler.instance().getClient().renderEngine.bindTexture(getTexture(material, 0));
render(material, part.getMaterialID(), part.getAllCurrentConnections());
FMLClientHandler.instance().getClient().renderEngine.bindTexture(getTexture(material));
render(material, part.getAllCurrentConnections());
GL11.glPopMatrix();
}
public static ResourceLocation getTexture(EnumPipeMaterial mat, int pipeID)
public static ResourceLocation getTexture(EnumPipeMaterial material)
{
if (mat != null)
if (material != null)
{
Pair<EnumPipeMaterial, Integer> index = new Pair<EnumPipeMaterial, Integer>(mat, pipeID);
if (!TEXTURES.containsKey(index))
if (!TEXTURES.containsKey(material))
{
String pipeName = "";
if (EnumPipeType.get(pipeID) != null)
{
pipeName = EnumPipeType.get(pipeID).getName(pipeID);
}
TEXTURES.put(index, new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "pipe/" + mat.matName + ".png"));
TEXTURES.put(material, new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "pipe/" + material.matName + ".png"));
}
return TEXTURES.get(index);
return TEXTURES.get(material);
}
return TEXTURE;
}
public static ResourceLocation getTexture(int meta)
public static void render(EnumPipeMaterial mat, byte side)
{
return getTexture(EnumPipeMaterial.getFromItemMeta(meta), EnumPipeMaterial.getType(meta));
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.DOWN))
{
MODEL_PIPE.renderBottom();
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.UP))
{
MODEL_PIPE.renderTop();
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.NORTH))
{
MODEL_PIPE.renderBack();
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.SOUTH))
{
MODEL_PIPE.renderFront();
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.WEST))
{
MODEL_PIPE.renderLeft();
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.EAST))
{
MODEL_PIPE.renderRight();
}
public static void render(EnumPipeMaterial mat, int pipeID, byte side)
{
if (mat == EnumPipeMaterial.WOOD)
{
MODEL_TROUGH_PIPE.render(side, false);
}
else if (mat == EnumPipeMaterial.STONE)
{
MODEL_TROUGH_PIPE.render(side, true);
}
else
{
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.DOWN))
{
MODEL_PIPE.renderBottom();
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.UP))
{
MODEL_PIPE.renderTop();
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.NORTH))
{
MODEL_PIPE.renderBack();
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.SOUTH))
{
MODEL_PIPE.renderFront();
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.WEST))
{
MODEL_PIPE.renderLeft();
}
if (TileFluidNetwork.canRenderSide(side, ForgeDirection.EAST))
{
MODEL_PIPE.renderRight();
}
MODEL_PIPE.renderMiddle();
}
MODEL_PIPE.renderMiddle();
}
public static void render(int meta, byte sides)
{
render(EnumPipeMaterial.getFromItemMeta(meta), EnumPipeMaterial.getType(meta), sides);
if (meta < EnumPipeMaterial.values().length)
{
FMLClientHandler.instance().getClient().renderEngine.bindTexture(getTexture(EnumPipeMaterial.values()[meta]));
render(EnumPipeMaterial.values()[meta], sides);
}
}
}

153
src/main/java/resonantinduction/mechanical/fluid/pipe/TilePipe.java
View file

@ -1,153 +0,0 @@
package resonantinduction.mechanical.fluid.pipe;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.IFluidHandler;
import resonantinduction.api.fluid.IFluidNetwork;
import resonantinduction.api.fluid.IFluidPipe;
import resonantinduction.mechanical.fluid.network.PipeNetwork;
import resonantinduction.mechanical.fluid.prefab.TileFluidNetwork;
import universalelectricity.api.vector.Vector3;
import calclavia.lib.render.ColorCode;
import calclavia.lib.render.ColorCode.IColorCoded;
public class TilePipe extends TileFluidNetwork implements IColorCoded, IFluidPipe
{
/** gets the current color mark of the pipe */
@Override
public ColorCode getColor()
{
return EnumPipeType.getColorCode(this.colorID);
}
/** sets the current color mark of the pipe */
@Override
public boolean setColor(Object cc)
{
if (!worldObj.isRemote)
{
int p = this.colorID;
this.colorID = EnumPipeType.getUpdatedID(colorID, ColorCode.get(cc));
return p != this.colorID;
}
return false;
}
@Override
public void validateConnectionSide(TileEntity tileEntity, ForgeDirection side)
{
int meta = new Vector3(this).getBlockMetadata(this.worldObj);
if (meta < EnumPipeMaterial.values().length)
{
EnumPipeMaterial pipeMat = EnumPipeMaterial.values()[meta];
if (pipeMat == EnumPipeMaterial.WOOD || pipeMat == EnumPipeMaterial.STONE)
{
if (side == ForgeDirection.UP)
{
return;
}
}
}
if (tileEntity instanceof TilePipe)
{
int metaOther = new Vector3(tileEntity).getBlockMetadata(this.worldObj);
if (meta < EnumPipeMaterial.values().length && metaOther < EnumPipeMaterial.values().length)
{
EnumPipeMaterial pipeMat = EnumPipeMaterial.values()[meta];
EnumPipeMaterial pipeMatOther = EnumPipeMaterial.values()[metaOther];
// Same pipe types can connect
if (pipeMat == pipeMatOther)
{
this.getNetwork().merge(((IFluidPipe) tileEntity).getNetwork());
connectedBlocks[side.ordinal()] = tileEntity;
setRenderSide(side, true);
}
else if ((pipeMat == EnumPipeMaterial.WOOD || pipeMat == EnumPipeMaterial.STONE) && (pipeMatOther == EnumPipeMaterial.WOOD || pipeMatOther == EnumPipeMaterial.STONE))
{
// Wood and stone pipes can connect to each other but not other pipe types since
// they are more like a trough than a pipe
this.getNetwork().merge(((IFluidPipe) tileEntity).getNetwork());
connectedBlocks[side.ordinal()] = tileEntity;
setRenderSide(side, true);
}
else if (pipeMat != EnumPipeMaterial.WOOD && pipeMat != EnumPipeMaterial.STONE && pipeMatOther != EnumPipeMaterial.WOOD && pipeMatOther != EnumPipeMaterial.STONE && pipeMat != EnumPipeMaterial.GLASS && pipeMatOther != EnumPipeMaterial.GLASS)
{
/*
* Any other pipe can connect to each other as long as the color matches except
* for glass which only works with itself at the moment
*/
this.getNetwork().merge(((IFluidPipe) tileEntity).getNetwork());
connectedBlocks[side.ordinal()] = tileEntity;
setRenderSide(side, true);
}
}
}
else if (tileEntity instanceof IFluidHandler)
{
connectedBlocks[side.ordinal()] = tileEntity;
setRenderSide(side, true);
}
}
@Override
public IFluidNetwork getNetwork()
{
if (this.network == null)
{
this.network = new PipeNetwork();
this.network.addConnector(this);
}
return this.network;
}
@Override
public void setNetwork(IFluidNetwork network)
{
if (network instanceof PipeNetwork)
{
this.network = (PipeNetwork) network;
}
}
@Override
public void sendTankUpdate()
{
if (this.getBlockMetadata() == EnumPipeMaterial.WOOD.ordinal() || this.getBlockMetadata() == EnumPipeMaterial.STONE.ordinal())
{
super.sendTankUpdate();
}
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid)
{
return false;
}
@Override
public int getPressureIn(ForgeDirection side)
{
return this.getMaxPressure();
}
@Override
public void onWrongPressure(ForgeDirection side, int pressure)
{
// TODO Auto-generated method stub
}
@Override
public int getMaxPressure()
{
return 10000;
}
@Override
public int getMaxFlowRate()
{
return 1000;
}
}

3
src/main/java/resonantinduction/mechanical/fluid/tank/BlockTank.java
View file

@ -13,7 +13,6 @@ import net.minecraft.world.World;
import resonantinduction.core.render.RIBlockRenderingHandler;
import resonantinduction.mechanical.fluid.pipe.EnumPipeMaterial;
import resonantinduction.mechanical.fluid.pipe.ItemBlockFluidContainer;
import resonantinduction.mechanical.fluid.pipe.TilePipe;
import resonantinduction.mechanical.fluid.prefab.BlockFluidNetwork;
import universalelectricity.api.vector.Vector3;
import calclavia.lib.utility.FluidUtility;
@ -97,7 +96,7 @@ public class BlockTank extends BlockFluidNetwork
{
ArrayList<ItemStack> ret = new ArrayList<ItemStack>();
TileEntity entity = world.getBlockTileEntity(x, y, z);
if (entity instanceof TilePipe)
if (entity instanceof TileTank)
{
ret.add(new ItemStack(this, 1, EnumPipeMaterial.getDropItemMeta(world, x, y, z)));
}

2
src/main/resources/assets/resonantinduction/languages/en_US.properties
View file

@ -52,7 +52,7 @@ tile.resonantinduction\:manipulator.name=Manipulator
tile.resonantinduction\:rejector.name=Rejector
# Fluid pipes
tile.resonantinduction\:fluidPipe.2.name=Red Wood Trough
item.resonantinduction\:pipe.name=Pipe
tile.resonantinduction\:fluidPipe.3.name=Green Wood Trough
tile.resonantinduction\:fluidPipe.4.name=Brown Wood Trough
tile.resonantinduction\:fluidPipe.5.name=Blue Wood Trough