Pushing more things to Git which weren't there.

ToroiseGit doesn't auto add new files to be pushed/committed unless you manually add them to a commit. :(

20 files changed, 1305 insertions, 79 deletions

diff --git a/src/Java/miscutil/core/block/antigrief/TowerDevice.java b/src/Java/miscutil/core/block/antigrief/TowerDevice.java
new file mode 100644
index 0000000000..aea1d40921
--- /dev/null
+++ b/src/Java/miscutil/core/block/antigrief/TowerDevice.java
@@ -0,0 +1,265 @@
+package miscutil.core.block.antigrief;
+
+import static miscutil.core.block.ModBlocks.blockGriefSaver;
+
+import java.util.List;
+import java.util.Random;
+
+import miscutil.core.creativetabs.AddToCreativeTab;
+import miscutil.core.lib.Strings;
+import miscutil.core.tileentities.TileEntityReverter;
+import miscutil.core.util.Utils;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class TowerDevice extends Block {
+  private static IIcon TEX_ANTIBUILDER;
+  public static final int META_ANTIBUILDER = 9;
+  public TowerDevice()
+  {
+    super(Material.wood);
+    setHardness(10.0F);
+    setResistance(35.0F);
+    setStepSound(Block.soundTypeWood);
+    setCreativeTab(AddToCreativeTab.tabMachines);
+  }
+  
+  public int tickRate()
+  {
+    return 15;
+  }
+  
+  public IIcon getIcon(int side, int meta)
+  {
+      return TEX_ANTIBUILDER;
+  }
+  
+  @SideOnly(Side.CLIENT)
+  public void registerBlockIcons(IIconRegister par1IconRegister)
+  {
+    TEX_ANTIBUILDER = par1IconRegister.registerIcon(Strings.MODID + ":" + "blockAntiGrief");
+  }
+  
+  public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List)
+  {
+    par3List.add(new ItemStack(par1, 1, 9));
+  }
+  
+  public boolean onBlockActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9)
+  {
+    int meta = par1World.getBlockMetadata(x, y, z);
+    return false;
+  }
+  
+  public float getExplosionResistance(Entity par1Entity, World world, int x, int y, int z, double explosionX, double explosionY, double explosionZ)
+  {
+    int meta = world.getBlockMetadata(x, y, z);
+    return super.getExplosionResistance(par1Entity, world, x, y, z, explosionX, explosionY, explosionZ);
+  }
+  
+  public float getBlockHardness(World world, int x, int y, int z)
+  {
+    int meta = world.getBlockMetadata(x, y, z);    
+    return super.getBlockHardness(world, x, y, z);
+  }
+  
+  public static boolean areNearbyLockBlocks(World world, int x, int y, int z)
+  {
+    boolean locked = false;
+    for (int dx = x - 2; dx <= x + 2; dx++) {
+      for (int dy = y - 2; dy <= y + 2; dy++) {
+        for (int dz = z - 2; dz <= z + 2; dz++) {
+          if ((world.getBlock(dx, dy, dz) == blockGriefSaver) && (world.getBlockMetadata(dx, dy, dz) == 4)) {
+            locked = true;
+          }
+        }
+      }
+    }
+    return locked;
+  }
+  
+  public static void unlockBlock(World par1World, int x, int y, int z)
+  {
+    Block thereBlockID = par1World.getBlock(x, y, z);
+    int thereBlockMeta = par1World.getBlockMetadata(x, y, z);
+    if ((thereBlockID == blockGriefSaver) || (thereBlockMeta == 4))
+    {
+      changeToBlockMeta(par1World, x, y, z, 5);
+      par1World.playSoundEffect(x + 0.5D, y + 0.5D, z + 0.5D, "random.click", 0.3F, 0.6F);
+    }
+  }
+  
+  private static void changeToBlockMeta(World par1World, int x, int y, int z, int meta)
+  {
+    Block thereBlockID = par1World.getBlock(x, y, z);
+    if ((thereBlockID == blockGriefSaver))
+    {
+      par1World.setBlock(x, y, z, thereBlockID, meta, 3);
+      par1World.markBlockRangeForRenderUpdate(x, y, z, x, y, z);
+      par1World.notifyBlocksOfNeighborChange(x, y, z, thereBlockID);
+    }
+  }
+  
+  public void onBlockAdded(World par1World, int x, int y, int z)
+  {
+    int meta = par1World.getBlockMetadata(x, y, z);
+    if (!par1World.isRemote) {
+    	
+    }
+  }
+  
+  public void onNeighborBlockChange(World par1World, int x, int y, int z, Block myBlockID)
+  {
+    int meta = par1World.getBlockMetadata(x, y, z);
+    if (!par1World.isRemote)
+    {
+      
+    }
+  }
+  
+  public void updateTick(World par1World, int x, int y, int z, Random par5Random)
+  {
+    if (!par1World.isRemote)
+    {
+      int meta = par1World.getBlockMetadata(x, y, z);
+    }
+  }
+  
+  private void letsBuild(World par1World, int x, int y, int z)
+  {
+	  
+  }
+  
+  private boolean isInactiveTrapCharged(World par1World, int x, int y, int z)
+  {
+    return false;
+  }
+  
+  private boolean isReactorReady(World world, int x, int y, int z)
+  {
+    if ((world.getBlock(x, y + 1, z) != Blocks.redstone_block) || 
+      (world.getBlock(x, y - 1, z) != Blocks.redstone_block) || 
+      (world.getBlock(x + 1, y, z) != Blocks.redstone_block) || 
+      (world.getBlock(x - 1, y, z) != Blocks.redstone_block) || 
+      (world.getBlock(x, y, z + 1) != Blocks.redstone_block) || 
+      (world.getBlock(x, y, z - 1) != Blocks.redstone_block)) {
+      return false;
+    }
+    return true;
+  }
+  
+  @SideOnly(Side.CLIENT)
+  public void randomDisplayTick(World par1World, int x, int y, int z, Random par5Random)
+  {
+    int meta = par1World.getBlockMetadata(x, y, z);
+    if ((meta == 3) || (meta == 1) || (meta == 9)) {
+      for (int i = 0; i < 1; i++) {
+        sparkle(par1World, x, y, z, par5Random);
+      }
+    }
+  }
+  
+  public void sparkle(World world, int x, int y, int z, Random rand)
+  {
+    double offset = 0.0625D;
+    for (int side = 0; side < 6; side++)
+    {
+      double rx = x + rand.nextFloat();
+      double ry = y + rand.nextFloat();
+      double rz = z + rand.nextFloat();
+      if ((side == 0) && (!world.getBlock(x, y + 1, z).isOpaqueCube())) {
+        ry = y + 1 + offset;
+      }
+      if ((side == 1) && (!world.getBlock(x, y - 1, z).isOpaqueCube())) {
+        ry = y + 0 - offset;
+      }
+      if ((side == 2) && (!world.getBlock(x, y, z + 1).isOpaqueCube())) {
+        rz = z + 1 + offset;
+      }
+      if ((side == 3) && (!world.getBlock(x, y, z - 1).isOpaqueCube())) {
+        rz = z + 0 - offset;
+      }
+      if ((side == 4) && (!world.getBlock(x + 1, y, z).isOpaqueCube())) {
+        rx = x + 1 + offset;
+      }
+      if ((side == 5) && (!world.getBlock(x - 1, y, z).isOpaqueCube())) {
+        rx = x + 0 - offset;
+      }
+      if ((rx < x) || (rx > x + 1) || (ry < 0.0D) || (ry > y + 1) || (rz < z) || (rz > z + 1)) {
+        world.spawnParticle("reddust", rx, ry, rz, 0.0D, 0.0D, 0.0D);
+      }
+    }
+  }
+  
+  public static void checkAndActivateVanishBlock(World world, int x, int y, int z)
+  {
+    Block thereID = world.getBlock(x, y, z);
+    int thereMeta = world.getBlockMetadata(x, y, z);
+  }
+  
+  public static void changeToActiveVanishBlock(World par1World, int x, int y, int z, int meta)
+  {
+    changeToBlockMeta(par1World, x, y, z, meta);
+    par1World.playSoundEffect(x + 0.5D, y + 0.5D, z + 0.5D, "random.pop", 0.3F, 0.6F);
+    
+    Block thereBlockID = par1World.getBlock(x, y, z);
+    par1World.scheduleBlockUpdate(x, y, z, thereBlockID, getTickRateFor(thereBlockID, meta, par1World.rand));
+  }
+  
+  private static int getTickRateFor(Block thereBlockID, int meta, Random rand)
+  {
+    return 15;
+  }
+  
+  public int getLightValue(IBlockAccess world, int x, int y, int z)
+  {
+    Block blockID = world.getBlock(x, y, z);
+    int meta = world.getBlockMetadata(x, y, z);
+    if (blockID != this) {
+      return 0;
+    }
+      return 10;
+  }
+  
+  public boolean hasTileEntity(int metadata)
+  {
+    return (metadata == 0);
+  }
+  
+  public TileEntity createTileEntity(World world, int metadata)
+  {
+    if (metadata == 0) {
+    	Utils.LOG_INFO("I have been created. [Antigriefer]"+this.getLocalizedName());
+      return new TileEntityReverter();
+    }
+    return null;
+  }
+  
+  public Item getItemDropped(int meta, Random par2Random, int par3)
+  {
+    switch (meta)
+    {
+    case 0: 
+      return null;
+    }
+    return Item.getItemFromBlock(this);
+  }
+  
+  public int damageDropped(int meta)
+  {
+    return meta;
+  }
+}
diff --git a/src/Java/miscutil/core/tileentities/TileEntityReverter.java b/src/Java/miscutil/core/tileentities/TileEntityReverter.java
new file mode 100644
index 0000000000..4ee8eeed4b
--- /dev/null
+++ b/src/Java/miscutil/core/tileentities/TileEntityReverter.java
@@ -0,0 +1,309 @@
+package miscutil.core.tileentities;
+
+import java.util.Random;
+
+import miscutil.core.block.ModBlocks;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.tileentity.TileEntity;
+
+
+
+public class TileEntityReverter extends TileEntity
+{
+	private static final int REVERT_CHANCE = 10;
+	public int radius = 16;
+	public int diameter = 8 * this.radius + 4;
+	public double requiredPlayerRange = 64.0D;
+	public Random rand = new Random();
+	private int tickCount;
+	private boolean slowScan;
+	private int ticksSinceChange;
+	private Block[] blockData;
+	private byte[] metaData;
+
+	public boolean canUpdate(){
+		return true;
+	}
+
+	public void updateEntity()
+	{
+		if (anyPlayerInRange())
+		{
+			this.tickCount += 1;
+			if (this.worldObj.isRemote)
+			{
+				double var1 = this.xCoord + this.worldObj.rand.nextFloat();
+				double var3 = this.yCoord + this.worldObj.rand.nextFloat();
+				double var5 = this.zCoord + this.worldObj.rand.nextFloat();
+
+				this.worldObj.spawnParticle("enchantmenttable", var1, var3, var5, 0.0D, 0.0D, 0.0D);
+				if (this.rand.nextInt(5) == 0)
+				{
+					makeRandomOutline();
+					makeRandomOutline();
+					makeRandomOutline();
+				}
+			}
+			else
+			{
+				if ((this.blockData == null) || (this.metaData == null))
+				{
+					captureBlockData();
+					this.slowScan = true;
+				}
+				if ((!this.slowScan) || (this.tickCount % 20 == 0)) {
+					if (scanAndRevertChanges())
+					{
+						this.slowScan = false;
+						this.ticksSinceChange = 0;
+					}
+					else
+					{
+						this.ticksSinceChange += 1;
+						if (this.ticksSinceChange > 20) {
+							this.slowScan = true;
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			this.blockData = null;
+			this.metaData = null;
+
+			this.tickCount = 0;
+		}
+	}
+
+	private void makeRandomOutline()
+	{
+		makeOutline(this.rand.nextInt(12));
+	}
+
+	private void makeOutline(int outline)
+	{
+		double sx = this.xCoord;
+		double sy = this.yCoord;
+		double sz = this.zCoord;
+
+		double dx = this.xCoord;
+		double dy = this.yCoord;
+		double dz = this.zCoord;
+		switch (outline)
+		{
+		case 0: 
+			sx -= this.radius;
+			dx -= this.radius;
+			sz -= this.radius;
+			dz += this.radius + 1;
+		case 8: 
+			sx -= this.radius;
+			dx += this.radius + 1;
+			sz -= this.radius;
+			dz -= this.radius;
+			break;
+		case 1: 
+		case 9: 
+			sx -= this.radius;
+			dx -= this.radius;
+			sz -= this.radius;
+			dz += this.radius + 1;
+			break;
+		case 2: 
+		case 10: 
+			sx -= this.radius;
+			dx += this.radius + 1;
+			sz += this.radius + 1;
+			dz += this.radius + 1;
+			break;
+		case 3: 
+		case 11: 
+			sx += this.radius + 1;
+			dx += this.radius + 1;
+			sz -= this.radius;
+			dz += this.radius + 1;
+			break;
+		case 4: 
+			sx -= this.radius;
+			dx -= this.radius;
+			sz -= this.radius;
+			dz -= this.radius;
+			break;
+		case 5: 
+			sx += this.radius + 1;
+			dx += this.radius + 1;
+			sz -= this.radius;
+			dz -= this.radius;
+			break;
+		case 6: 
+			sx += this.radius + 1;
+			dx += this.radius + 1;
+			sz += this.radius + 1;
+			dz += this.radius + 1;
+			break;
+		case 7: 
+			sx -= this.radius;
+			dx -= this.radius;
+			sz += this.radius + 1;
+			dz += this.radius + 1;
+		}
+		switch (outline)
+		{
+		case 0: 
+		case 1: 
+		case 2: 
+		case 3: 
+			sy += this.radius + 1;
+			dy += this.radius + 1;
+			break;
+		case 4: 
+		case 5: 
+		case 6: 
+		case 7: 
+			sy -= this.radius;
+			dy += this.radius + 1;
+			break;
+		case 8: 
+		case 9: 
+		case 10: 
+		case 11: 
+			sy -= this.radius;
+			dy -= this.radius;
+		}
+		if (this.rand.nextBoolean()) {
+			drawParticleLine(this.xCoord + 0.5D, this.yCoord + 0.5D, this.zCoord + 0.5D, dx, dy, dz);
+		} else {
+			drawParticleLine(sx, sy, sz, this.xCoord + 0.5D, this.yCoord + 0.5D, this.zCoord + 0.5D);
+		}
+		drawParticleLine(sx, sy, sz, dx, dy, dz);
+	}
+
+	protected void drawParticleLine(double srcX, double srcY, double srcZ, double destX, double destY, double destZ)
+	{
+		int particles = 16;
+		for (int i = 0; i < particles; i++)
+		{
+			double trailFactor = i / (particles - 1.0D);
+
+			double tx = srcX + (destX - srcX) * trailFactor + this.rand.nextFloat() * 0.005D;
+			double ty = srcY + (destY - srcY) * trailFactor + this.rand.nextFloat() * 0.005D;
+			double tz = srcZ + (destZ - srcZ) * trailFactor + this.rand.nextFloat() * 0.005D;
+			this.worldObj.spawnParticle("portal", tx, ty, tz, 0.0D, 0.0D, 0.0D);
+		}
+	}
+
+	private boolean scanAndRevertChanges()
+	{
+		int index = 0;
+		boolean reverted = false;
+		for (int x = -this.radius; x <= this.radius; x++) {
+			for (int y = -this.radius; y <= this.radius; y++) {
+				for (int z = -this.radius; z <= this.radius; z++)
+				{
+					Block blockID = this.worldObj.getBlock(this.xCoord + x, this.yCoord + y, this.zCoord + z);
+					byte meta = (byte)this.worldObj.getBlockMetadata(this.xCoord + x, this.yCoord + y, this.zCoord + z);
+					if (this.blockData[index] != blockID) {
+						if (revertBlock(this.xCoord + x, this.yCoord + y, this.zCoord + z, blockID, meta, this.blockData[index], this.metaData[index]))
+						{
+							reverted = true;
+						}
+						else
+						{
+							this.blockData[index] = blockID;
+							this.metaData[index] = meta;
+						}
+					}
+					index++;
+				}
+			}
+		}
+		return reverted;
+	}
+
+	private boolean revertBlock(int x, int y, int z, Block thereBlockID, byte thereMeta, Block replaceBlockID, byte replaceMeta)
+	{
+		/*if ((thereBlockID == Blocks.air) && (!replaceBlockID.getMaterial().blocksMovement()))
+		{
+			System.out.println("Not replacing block " + replaceBlockID + " because it doesn't block movement");
+
+			return false;
+		}*/
+		if (isUnrevertable(thereBlockID, thereMeta, replaceBlockID, replaceMeta)) {
+			return false;
+		}
+		if (this.rand.nextInt(5) == 0)
+		{
+			if (replaceBlockID != Blocks.air)
+			{
+				//replaceBlockID = null;
+				replaceMeta = 4;
+			}
+			this.worldObj.setBlock(x, y, z, replaceBlockID, replaceMeta, 2);
+			if (thereBlockID == Blocks.air)
+			{
+				this.worldObj.playAuxSFX(2001, x, y, z, Block.getIdFromBlock(replaceBlockID) + (replaceMeta << 12));
+			}
+			else if (replaceBlockID == Blocks.air)
+			{
+				this.worldObj.playAuxSFX(2001, x, y, z, Block.getIdFromBlock(thereBlockID) + (thereMeta << 12));
+				thereBlockID.dropBlockAsItem(this.worldObj, x, y, z, thereMeta, 0);
+			}
+		}
+		return true;
+	}
+
+	private boolean isUnrevertable(Block thereBlockID, byte thereMeta, Block replaceBlockID, byte replaceMeta)
+	{
+		if ((thereBlockID == ModBlocks.blockGriefSaver) || (replaceBlockID == ModBlocks.blockGriefSaver)) {
+			return true;
+		}
+		/*if (((thereBlockID == towerTranslucent) && (thereMeta != 4)) || ((replaceBlockID == towerTranslucent) && (replaceMeta != 4))) {
+			return true;
+		}*/
+		if ((thereBlockID == Blocks.redstone_lamp) && (replaceBlockID == Blocks.lit_redstone_lamp)) {
+			return true;
+		}
+		if ((thereBlockID == Blocks.lit_redstone_lamp) && (replaceBlockID == Blocks.redstone_lamp)) {
+			return true;
+		}
+		/*if ((thereBlockID == Blocks.water) || (replaceBlockID == Blocks.flowing_water)) {
+			return true;
+		}
+		if ((thereBlockID == Blocks.flowing_water) || (replaceBlockID == Blocks.water)) {
+			return true;
+		}*/
+		if (replaceBlockID == Blocks.tnt) {
+			return true;
+		}
+		return false;
+	}
+
+	private void captureBlockData()
+	{
+		this.blockData = new Block[this.diameter * this.diameter * this.diameter];
+		this.metaData = new byte[this.diameter * this.diameter * this.diameter];
+
+		int index = 0;
+		for (int x = -this.radius; x <= this.radius; x++) {
+			for (int y = -this.radius; y <= this.radius; y++) {
+				for (int z = -this.radius; z <= this.radius; z++)
+				{
+					Block blockID = this.worldObj.getBlock(this.xCoord + x, this.yCoord + y, this.zCoord + z);
+					int meta = this.worldObj.getBlockMetadata(this.xCoord + x, this.yCoord + y, this.zCoord + z);
+
+					this.blockData[index] = blockID;
+					this.metaData[index] = ((byte)meta);
+
+					index++;
+				}
+			}
+		}
+	}
+
+	public boolean anyPlayerInRange()
+	{
+		return this.worldObj.getClosestPlayer(this.xCoord + 0.5D, this.yCoord + 0.5D, this.zCoord + 0.5D, this.requiredPlayerRange) != null;
+	}
+}
diff --git a/src/Java/miscutil/core/util/Log.java b/src/Java/miscutil/core/util/Log.java
new file mode 100644
index 0000000000..ea69618ec7
--- /dev/null
+++ b/src/Java/miscutil/core/util/Log.java
@@ -0,0 +1,29 @@
+package crazypants.enderio;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public final class Log
+{
+  public static final Logger LOGGER = LogManager.getLogger("EnderIO");
+  
+  public static void warn(String msg)
+  {
+    LOGGER.warn(msg);
+  }
+  
+  public static void error(String msg)
+  {
+    LOGGER.error(msg);
+  }
+  
+  public static void info(String msg)
+  {
+    LOGGER.info(msg);
+  }
+  
+  public static void debug(String msg)
+  {
+    LOGGER.debug(msg);
+  }
+}
diff --git a/src/Java/miscutil/core/waila/IWailaInfoProvider.java b/src/Java/miscutil/core/waila/IWailaInfoProvider.java
new file mode 100644
index 0000000000..90b96d4bc0
--- /dev/null
+++ b/src/Java/miscutil/core/waila/IWailaInfoProvider.java
@@ -0,0 +1,19 @@
+package crazypants.enderio.waila;
+
+import java.text.NumberFormat;
+import java.util.List;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
+
+public abstract interface IWailaInfoProvider
+{
+  public static final int BIT_BASIC = 1;
+  public static final int BIT_COMMON = 2;
+  public static final int BIT_DETAILED = 4;
+  public static final int ALL_BITS = 7;
+  public static final NumberFormat fmt = ;
+  
+  public abstract void getWailaInfo(List<String> paramList, EntityPlayer paramEntityPlayer, World paramWorld, int paramInt1, int paramInt2, int paramInt3);
+  
+  public abstract int getDefaultDisplayMask(World paramWorld, int paramInt1, int paramInt2, int paramInt3);
+}
diff --git a/src/Java/miscutil/core/waila/IWailaNBTProvider.java b/src/Java/miscutil/core/waila/IWailaNBTProvider.java
new file mode 100644
index 0000000000..5b4f7dbe2b
--- /dev/null
+++ b/src/Java/miscutil/core/waila/IWailaNBTProvider.java
@@ -0,0 +1,8 @@
+package crazypants.enderio.waila;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public abstract interface IWailaNBTProvider
+{
+  public abstract void getData(NBTTagCompound paramNBTTagCompound);
+}
diff --git a/src/Java/miscutil/core/waila/WailaCompat.java b/src/Java/miscutil/core/waila/WailaCompat.java
new file mode 100644
index 0000000000..1f494f89bd
--- /dev/null
+++ b/src/Java/miscutil/core/waila/WailaCompat.java
@@ -0,0 +1,323 @@
+package crazypants.enderio.waila;
+
+import crazypants.enderio.EnderIO;
+import crazypants.enderio.TileEntityEio;
+import crazypants.enderio.block.BlockDarkSteelAnvil;
+import crazypants.enderio.conduit.ConduitUtil;
+import crazypants.enderio.conduit.IConduit;
+import crazypants.enderio.conduit.IConduitBundle;
+import crazypants.enderio.conduit.liquid.AbstractTankConduit;
+import crazypants.enderio.conduit.liquid.ConduitTank;
+import crazypants.enderio.conduit.power.IPowerConduit;
+import crazypants.enderio.fluid.Fluids;
+import crazypants.enderio.gui.IAdvancedTooltipProvider;
+import crazypants.enderio.gui.IResourceTooltipProvider;
+import crazypants.enderio.gui.TooltipAddera;
+import crazypants.enderio.machine.IIoConfigurable;
+import crazypants.enderio.machine.IoMode;
+import crazypants.enderio.machine.capbank.TileCapBank;
+import crazypants.enderio.machine.power.TileCapacitorBank;
+import crazypants.enderio.power.IInternalPoweredTile;
+import crazypants.util.IFacade;
+import crazypants.util.Lang;
+import java.text.NumberFormat;
+import java.util.List;
+import mcp.mobius.waila.api.ITaggedList;
+import mcp.mobius.waila.api.IWailaConfigHandler;
+import mcp.mobius.waila.api.IWailaDataAccessor;
+import mcp.mobius.waila.api.IWailaDataProvider;
+import mcp.mobius.waila.api.IWailaRegistrar;
+import mcp.mobius.waila.api.impl.ConfigHandler;
+import net.minecraft.block.Block;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldSettings;
+import net.minecraft.world.chunk.IChunkProvider;
+import net.minecraft.world.storage.WorldInfo;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+public class WailaCompat
+  implements IWailaDataProvider
+{
+  private class WailaWorldWrapper
+    extends World
+  {
+    private World wrapped;
+    
+    private WailaWorldWrapper(World wrapped)
+    {
+      super(wrapped.getWorldInfo().getWorldName(), wrapped.provider, new WorldSettings(wrapped.getWorldInfo()), wrapped.theProfiler);
+      this.wrapped = wrapped;
+      this.isRemote = wrapped.isRemote;
+    }
+    
+    public Block getBlock(int x, int y, int z)
+    {
+      Block block = this.wrapped.getBlock(x, y, z);
+      if ((block instanceof IFacade)) {
+        return ((IFacade)block).getFacade(this.wrapped, x, y, z, -1);
+      }
+      return block;
+    }
+    
+    public int getBlockMetadata(int x, int y, int z)
+    {
+      Block block = this.wrapped.getBlock(x, y, z);
+      if ((block instanceof IFacade)) {
+        return ((IFacade)block).getFacadeMetadata(this.wrapped, x, y, z, -1);
+      }
+      return this.wrapped.getBlockMetadata(x, y, z);
+    }
+    
+    public TileEntity getTileEntity(int x, int y, int z)
+    {
+      int meta = getBlockMetadata(x, y, z);
+      Block block = getBlock(x, y, z);
+      if ((block == null) || (!block.hasTileEntity(meta))) {
+        return null;
+      }
+      TileEntity te = block.createTileEntity(this, meta);
+      if (te == null) {
+        return null;
+      }
+      te.setWorldObj(this);
+      te.xCoord = x;
+      te.yCoord = y;
+      te.zCoord = z;
+      
+      return te;
+    }
+    
+    protected IChunkProvider createChunkProvider()
+    {
+      return null;
+    }
+    
+    protected int func_152379_p()
+    {
+      return 0;
+    }
+    
+    public Entity getEntityByID(int p_73045_1_)
+    {
+      return null;
+    }
+  }
+  
+  public static final WailaCompat INSTANCE = new WailaCompat();
+  private static IWailaDataAccessor _accessor = null;
+  
+  public static void load(IWailaRegistrar registrar)
+  {
+    registrar.registerStackProvider(INSTANCE, IFacade.class);
+    registrar.registerStackProvider(INSTANCE, BlockDarkSteelAnvil.class);
+    
+    registrar.registerHeadProvider(INSTANCE, Block.class);
+    registrar.registerBodyProvider(INSTANCE, Block.class);
+    registrar.registerTailProvider(INSTANCE, Block.class);
+    
+    registrar.registerNBTProvider(INSTANCE, TileEntityEio.class);
+    
+    registrar.registerSyncedNBTKey("controllerStoredEnergyRF", TileCapacitorBank.class);
+    
+
+
+
+    ConfigHandler.instance().addConfig("Ender IO", "facades.hidden", Lang.localize("waila.config.hiddenfacades"));
+    IWailaInfoProvider.fmt.setMaximumFractionDigits(1);
+  }
+  
+  public ItemStack getWailaStack(IWailaDataAccessor accessor, IWailaConfigHandler config)
+  {
+    MovingObjectPosition pos = accessor.getPosition();
+    if (config.getConfig("facades.hidden"))
+    {
+      if ((accessor.getBlock() instanceof IFacade))
+      {
+        if (((accessor.getTileEntity() instanceof IConduitBundle)) && (ConduitUtil.isFacadeHidden((IConduitBundle)accessor.getTileEntity(), accessor.getPlayer()))) {
+          return null;
+        }
+        IFacade bundle = (IFacade)accessor.getBlock();
+        Block facade = bundle.getFacade(accessor.getWorld(), pos.blockX, pos.blockY, pos.blockZ, accessor.getSide().ordinal());
+        if (facade != null)
+        {
+          ItemStack ret = facade.getPickBlock(pos, new WailaWorldWrapper(accessor.getWorld(), null), pos.blockX, pos.blockY, pos.blockZ);
+          return ret;
+        }
+      }
+    }
+    else if ((accessor.getBlock() instanceof BlockDarkSteelAnvil)) {
+      return accessor.getBlock().getPickBlock(accessor.getPosition(), accessor.getWorld(), accessor.getPosition().blockX, accessor.getPosition().blockY, accessor.getPosition().blockZ);
+    }
+    return null;
+  }
+  
+  public List<String> getWailaHead(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor, IWailaConfigHandler config)
+  {
+    return currenttip;
+  }
+  
+  public List<String> getWailaBody(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor, IWailaConfigHandler config)
+  {
+    _accessor = accessor;
+    
+    EntityPlayer player = accessor.getPlayer();
+    MovingObjectPosition pos = accessor.getPosition();
+    int x = pos.blockX;int y = pos.blockY;int z = pos.blockZ;
+    World world = accessor.getWorld();
+    Block block = world.getBlock(x, y, z);
+    TileEntity te = world.getTileEntity(x, y, z);
+    Item item = Item.getItemFromBlock(block);
+    if (((te instanceof IIoConfigurable)) && (block == accessor.getBlock()))
+    {
+      IIoConfigurable machine = (IIoConfigurable)te;
+      ForgeDirection side = accessor.getSide();
+      IoMode mode = machine.getIoMode(side);
+      currenttip.add(EnumChatFormatting.YELLOW + String.format(Lang.localize("gui.machine.side"), new Object[] { EnumChatFormatting.WHITE + Lang.localize(new StringBuilder().append("gui.machine.side.").append(side.name().toLowerCase()).toString()) }));
+      
+      currenttip.add(EnumChatFormatting.YELLOW + String.format(Lang.localize("gui.machine.ioMode"), new Object[] { mode.colorLocalisedName() }));
+    }
+    if ((block instanceof IWailaInfoProvider))
+    {
+      IWailaInfoProvider info = (IWailaInfoProvider)block;
+      if ((block instanceof IAdvancedTooltipProvider))
+      {
+        int mask = info.getDefaultDisplayMask(world, pos.blockX, pos.blockY, pos.blockZ);
+        boolean basic = (mask & 0x1) == 1;
+        boolean common = (mask & 0x2) == 2;
+        boolean detailed = (mask & 0x4) == 4;
+        
+        IAdvancedTooltipProvider adv = (IAdvancedTooltipProvider)block;
+        if (common) {
+          adv.addCommonEntries(itemStack, player, currenttip, false);
+        }
+        if ((TooltipAddera.showAdvancedTooltips()) && (detailed)) {
+          adv.addDetailedEntries(itemStack, player, currenttip, false);
+        } else if (detailed) {
+          TooltipAddera.addShowDetailsTooltip(currenttip);
+        }
+        if ((!TooltipAddera.showAdvancedTooltips()) && (basic)) {
+          adv.addBasicEntries(itemStack, player, currenttip, false);
+        }
+      }
+      else if ((block instanceof IResourceTooltipProvider))
+      {
+        TooltipAddera.addInformation((IResourceTooltipProvider)block, itemStack, player, currenttip);
+      }
+      if (currenttip.size() > 0) {
+        currenttip.add("");
+      }
+      info.getWailaInfo(currenttip, player, world, pos.blockX, pos.blockY, pos.blockZ);
+    }
+    else if ((block instanceof IAdvancedTooltipProvider))
+    {
+      TooltipAddera.addInformation((IAdvancedTooltipProvider)block, itemStack, player, currenttip, false);
+    }
+    else if ((item instanceof IAdvancedTooltipProvider))
+    {
+      TooltipAddera.addInformation((IAdvancedTooltipProvider)item, itemStack, player, currenttip, false);
+    }
+    else if ((block instanceof IResourceTooltipProvider))
+    {
+      TooltipAddera.addInformation((IResourceTooltipProvider)block, itemStack, player, currenttip);
+    }
+    boolean removeRF = false;
+    if (((te instanceof IInternalPoweredTile)) && (block == accessor.getBlock()) && (accessor.getNBTData().hasKey("storedEnergyRF")) && (!(te instanceof TileCapBank)))
+    {
+      removeRF = true;
+      IInternalPoweredTile power = (IInternalPoweredTile)te;
+      if (power.displayPower())
+      {
+        if (currenttip.size() > 4) {
+          currenttip.add("");
+        }
+        int stored = (accessor.getTileEntity() instanceof TileCapacitorBank) ? power.getEnergyStored() : accessor.getNBTData().getInteger("storedEnergyRF");
+        int max = power.getMaxEnergyStored();
+        
+        currenttip.add(String.format("%s%s%s / %s%s%s RF", new Object[] { EnumChatFormatting.WHITE, IWailaInfoProvider.fmt.format(stored), EnumChatFormatting.RESET, EnumChatFormatting.WHITE, IWailaInfoProvider.fmt.format(max), EnumChatFormatting.RESET }));
+      }
+    }
+    else if (((te instanceof IConduitBundle)) && (itemStack != null) && (itemStack.getItem() == EnderIO.itemPowerConduit))
+    {
+      removeRF = true;
+      NBTTagCompound nbtRoot = accessor.getNBTData();
+      short nbtVersion = nbtRoot.getShort("nbtVersion");
+      NBTTagList conduitTags = (NBTTagList)nbtRoot.getTag("conduits");
+      if (conduitTags != null) {
+        for (int i = 0; i < conduitTags.tagCount(); i++)
+        {
+          NBTTagCompound conduitTag = conduitTags.getCompoundTagAt(i);
+          IConduit conduit = ConduitUtil.readConduitFromNBT(conduitTag, nbtVersion);
+          if ((conduit instanceof IPowerConduit)) {
+            currenttip.add(String.format("%s%s%s / %s%s%s RF", new Object[] { EnumChatFormatting.WHITE, IWailaInfoProvider.fmt.format(((IPowerConduit)conduit).getEnergyStored()), EnumChatFormatting.RESET, EnumChatFormatting.WHITE, IWailaInfoProvider.fmt.format(((IConduitBundle)te).getMaxEnergyStored()), EnumChatFormatting.RESET }));
+          }
+        }
+      }
+    }
+    else if (((te instanceof IConduitBundle)) && (itemStack != null) && (itemStack.getItem() == EnderIO.itemLiquidConduit))
+    {
+      NBTTagCompound nbtRoot = accessor.getNBTData();
+      short nbtVersion = nbtRoot.getShort("nbtVersion");
+      NBTTagList conduitTags = (NBTTagList)nbtRoot.getTag("conduits");
+      if (conduitTags != null) {
+        for (int i = 0; i < conduitTags.tagCount(); i++)
+        {
+          NBTTagCompound conduitTag = conduitTags.getCompoundTagAt(i);
+          IConduit conduit = ConduitUtil.readConduitFromNBT(conduitTag, nbtVersion);
+          if ((conduit instanceof AbstractTankConduit))
+          {
+            AbstractTankConduit tankConduit = (AbstractTankConduit)conduit;
+            ConduitTank tank = tankConduit.getTank();
+            if (tank.getFluid() == null) {
+              break;
+            }
+            String lockedStr = tankConduit.isFluidTypeLocked() ? Lang.localize("itemLiquidConduit.lockedWaila") : "";
+            String fluidName = tank.getFluid().getLocalizedName();
+            int fluidAmount = tank.getFluidAmount();
+            if (fluidAmount > 0) {
+              currenttip.add(String.format("%s%s%s%s %s%s%s %s", new Object[] { lockedStr, EnumChatFormatting.WHITE, fluidName, EnumChatFormatting.RESET, EnumChatFormatting.WHITE, IWailaInfoProvider.fmt.format(fluidAmount), EnumChatFormatting.RESET, Fluids.MB() }));
+            } else if (tankConduit.isFluidTypeLocked()) {
+              currenttip.add(String.format("%s%s%s%s", new Object[] { lockedStr, EnumChatFormatting.WHITE, fluidName, EnumChatFormatting.RESET }));
+            }
+            break;
+          }
+        }
+      }
+    }
+    if (removeRF) {
+      ((ITaggedList)currenttip).removeEntries("RFEnergyStorage");
+    }
+    return currenttip;
+  }
+  
+  public List<String> getWailaTail(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor, IWailaConfigHandler config)
+  {
+    return currenttip;
+  }
+  
+  public NBTTagCompound getNBTData(EntityPlayerMP player, TileEntity te, NBTTagCompound tag, World world, int x, int y, int z)
+  {
+    if ((te instanceof IWailaNBTProvider)) {
+      ((IWailaNBTProvider)te).getData(tag);
+    }
+    tag.setInteger("x", x);
+    tag.setInteger("y", y);
+    tag.setInteger("z", z);
+    return tag;
+  }
+  
+  public static NBTTagCompound getNBTData()
+  {
+    return _accessor.getNBTData();
+  }
+}
diff --git a/src/Java/miscutil/enderio/conduit/gas/AbstractGasConduit.java b/src/Java/miscutil/enderio/conduit/gas/AbstractGasConduit.java
index ee7ba3d954..2bc3be3d67 100644
--- a/src/Java/miscutil/enderio/conduit/gas/AbstractGasConduit.java
+++ b/src/Java/miscutil/enderio/conduit/gas/AbstractGasConduit.java
@@ -1,8 +1,5 @@
 package crazypants.enderio.conduit.gas;
 
-import com.enderio.core.common.util.BlockCoord;
-import com.enderio.core.common.util.DyeColor;
-import cpw.mods.fml.common.Optional.Method;
 import crazypants.enderio.conduit.AbstractConduit;
 import crazypants.enderio.conduit.ConduitUtil;
 import crazypants.enderio.conduit.ConnectionMode;
@@ -10,6 +7,8 @@ import crazypants.enderio.conduit.IConduit;
 import crazypants.enderio.conduit.IConduitBundle;
 import crazypants.enderio.machine.RedstoneControlMode;
 import crazypants.enderio.machine.reservoir.TileReservoir;
+import crazypants.util.BlockCoord;
+import crazypants.util.DyeColor;
 import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.Map;
@@ -31,14 +30,12 @@ public abstract class AbstractGasConduit
   protected final Map<ForgeDirection, Integer> externalRedstoneSignals = new HashMap();
   protected boolean redstoneStateDirty = true;
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public IGasHandler getExternalHandler(ForgeDirection direction)
   {
     IGasHandler con = GasUtil.getExternalGasHandler(getBundle().getWorld(), getLocation().getLocation(direction));
     return (con != null) && (!(con instanceof IConduitBundle)) ? con : null;
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public IGasHandler getTankContainer(BlockCoord bc)
   {
     return GasUtil.getGasHandler(getBundle().getWorld(), bc);
diff --git a/src/Java/miscutil/enderio/conduit/gas/AbstractGasTankConduit.java b/src/Java/miscutil/enderio/conduit/gas/AbstractGasTankConduit.java
index 7226ad8328..5a0b50c370 100644
--- a/src/Java/miscutil/enderio/conduit/gas/AbstractGasTankConduit.java
+++ b/src/Java/miscutil/enderio/conduit/gas/AbstractGasTankConduit.java
@@ -1,7 +1,5 @@
 package crazypants.enderio.conduit.gas;
 
-import com.enderio.core.common.util.BlockCoord;
-import cpw.mods.fml.common.Optional.Method;
 import crazypants.enderio.conduit.AbstractConduitNetwork;
 import crazypants.enderio.conduit.ConduitUtil;
 import crazypants.enderio.conduit.ConnectionMode;
@@ -9,6 +7,7 @@ import crazypants.enderio.conduit.IConduitBundle;
 import crazypants.enderio.conduit.RaytraceResult;
 import crazypants.enderio.conduit.geom.CollidableComponent;
 import crazypants.enderio.tool.ToolUtil;
+import crazypants.util.BlockCoord;
 import java.util.List;
 import mekanism.api.gas.GasStack;
 import mekanism.api.gas.IGasHandler;
@@ -101,7 +100,6 @@ public abstract class AbstractGasTankConduit
   
   public abstract AbstractGasTankConduitNetwork<? extends AbstractGasTankConduit> getTankNetwork();
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public void setGasType(GasStack gasType)
   {
     if ((this.tank.getGas() != null) && (this.tank.getGas().isGasEqual(gasType))) {
@@ -121,7 +119,6 @@ public abstract class AbstractGasTankConduit
     return this.tank;
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public GasStack getGasType()
   {
     GasStack result = null;
diff --git a/src/Java/miscutil/enderio/conduit/gas/AbstractGasTankConduitNetwork.java b/src/Java/miscutil/enderio/conduit/gas/AbstractGasTankConduitNetwork.java
index 75a4a3c1ad..62d8daa205 100644
--- a/src/Java/miscutil/enderio/conduit/gas/AbstractGasTankConduitNetwork.java
+++ b/src/Java/miscutil/enderio/conduit/gas/AbstractGasTankConduitNetwork.java
@@ -10,7 +10,7 @@ public class AbstractGasTankConduitNetwork<T extends AbstractGasTankConduit>
   
   protected AbstractGasTankConduitNetwork(Class<T> cl)
   {
-    super(cl, IGasConduit.class);
+    super(cl);
   }
   
   public GasStack getGasType()
@@ -18,6 +18,11 @@ public class AbstractGasTankConduitNetwork<T extends AbstractGasTankConduit>
     return this.gasType;
   }
   
+  public Class<IGasConduit> getBaseConduitType()
+  {
+    return IGasConduit.class;
+  }
+  
   public void addConduit(T con)
   {
     super.addConduit(con);
diff --git a/src/Java/miscutil/enderio/conduit/gas/ConduitGasTank.java b/src/Java/miscutil/enderio/conduit/gas/ConduitGasTank.java
index 08aef66656..521e08a589 100644
--- a/src/Java/miscutil/enderio/conduit/gas/ConduitGasTank.java
+++ b/src/Java/miscutil/enderio/conduit/gas/ConduitGasTank.java
@@ -1,6 +1,5 @@
 package crazypants.enderio.conduit.gas;
 
-import cpw.mods.fml.common.Optional.Method;
 import mekanism.api.gas.Gas;
 import mekanism.api.gas.GasStack;
 import mekanism.api.gas.GasTank;
@@ -64,7 +63,6 @@ public class ConduitGasTank
     }
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public int receive(GasStack resource, boolean doReceive)
   {
     if ((resource == null) || (resource.getGas().getID() < 0)) {
@@ -103,7 +101,6 @@ public class ConduitGasTank
     return space;
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public GasStack draw(int maxDrain, boolean doDraw)
   {
     if ((this.stored == null) || (this.stored.getGas().getID() < 0)) {
diff --git a/src/Java/miscutil/enderio/conduit/gas/GasConduit.java b/src/Java/miscutil/enderio/conduit/gas/GasConduit.java
index 7f34570853..59300c4aa8 100644
--- a/src/Java/miscutil/enderio/conduit/gas/GasConduit.java
+++ b/src/Java/miscutil/enderio/conduit/gas/GasConduit.java
@@ -1,9 +1,5 @@
 package crazypants.enderio.conduit.gas;
 
-import com.enderio.core.client.render.IconUtil;
-import com.enderio.core.client.render.IconUtil.IIconProvider;
-import com.enderio.core.common.util.BlockCoord;
-import cpw.mods.fml.common.Optional.Method;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 import crazypants.enderio.EnderIO;
@@ -13,6 +9,9 @@ import crazypants.enderio.conduit.IConduit;
 import crazypants.enderio.conduit.IConduitBundle;
 import crazypants.enderio.conduit.geom.CollidableComponent;
 import crazypants.enderio.config.Config;
+import crazypants.render.IconUtil;
+import crazypants.render.IconUtil.IIconProvider;
+import crazypants.util.BlockCoord;
 import java.util.HashMap;
 import java.util.Map;
 import mekanism.api.gas.Gas;
@@ -216,39 +215,22 @@ public class GasConduit
     return null;
   }
   
-  @Deprecated
-  @Optional.Method(modid="MekanismAPI|gas")
-  public int receiveGas(ForgeDirection side, GasStack stack)
+  public int receiveGas(ForgeDirection from, GasStack resource)
   {
-    return receiveGas(side, stack, true);
-  }
-  
-  @Optional.Method(modid="MekanismAPI|gas")
-  public int receiveGas(ForgeDirection side, GasStack stack, boolean doTransfer)
-  {
-    if ((this.network == null) || (!getConnectionMode(side).acceptsInput())) {
+    if ((this.network == null) || (!getConnectionMode(from).acceptsInput())) {
       return 0;
     }
-    return this.network.fill(side, stack, doTransfer);
-  }
-  
-  @Deprecated
-  @Optional.Method(modid="MekanismAPI|gas")
-  public GasStack drawGas(ForgeDirection side, int amount)
-  {
-    return drawGas(side, amount, true);
+    return this.network.fill(from, resource, true);
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
-  public GasStack drawGas(ForgeDirection side, int amount, boolean doTransfer)
+  public GasStack drawGas(ForgeDirection from, int maxDrain)
   {
-    if ((this.network == null) || (!getConnectionMode(side).acceptsOutput())) {
+    if ((this.network == null) || (!getConnectionMode(from).acceptsOutput())) {
       return null;
     }
-    return this.network.drain(side, amount, doTransfer);
+    return this.network.drain(from, maxDrain, true);
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public boolean canReceiveGas(ForgeDirection from, Gas gas)
   {
     if (this.network == null) {
@@ -257,7 +239,6 @@ public class GasConduit
     return (getConnectionMode(from).acceptsInput()) && (GasConduitNetwork.areGassCompatable(getGasType(), new GasStack(gas, 0)));
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public boolean canDrawGas(ForgeDirection from, Gas gas)
   {
     if (this.network == null) {
diff --git a/src/Java/miscutil/enderio/conduit/gas/GasConduitNetwork.java b/src/Java/miscutil/enderio/conduit/gas/GasConduitNetwork.java
index 79990c6959..43db642248 100644
--- a/src/Java/miscutil/enderio/conduit/gas/GasConduitNetwork.java
+++ b/src/Java/miscutil/enderio/conduit/gas/GasConduitNetwork.java
@@ -1,9 +1,12 @@
 package crazypants.enderio.conduit.gas;
 
-import com.enderio.core.common.util.BlockCoord;
+import cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent;
+import crazypants.enderio.conduit.ConduitNetworkTickHandler;
+import crazypants.enderio.conduit.ConduitNetworkTickHandler.TickListener;
 import crazypants.enderio.conduit.ConnectionMode;
 import crazypants.enderio.conduit.IConduit;
 import crazypants.enderio.conduit.IConduitBundle;
+import crazypants.util.BlockCoord;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
@@ -23,12 +26,19 @@ public class GasConduitNetwork
   private int ticksActiveUnsynced;
   private boolean lastSyncedActive = false;
   private int lastSyncedVolume = -1;
+  private long timeAtLastApply;
+  private final InnerTickHandler tickHandler = new InnerTickHandler(null);
   
   public GasConduitNetwork()
   {
     super(GasConduit.class);
   }
   
+  public Class<IGasConduit> getBaseConduitType()
+  {
+    return IGasConduit.class;
+  }
+  
   public void addConduit(GasConduit con)
   {
     this.tank.setCapacity(this.tank.getMaxGas() + 1000);
@@ -87,7 +97,24 @@ public class GasConduitNetwork
     }
   }
   
-  public void doNetworkTick()
+  public void onUpdateEntity(IConduit conduit)
+  {
+    World world = conduit.getBundle().getEntity().getWorldObj();
+    if (world == null) {
+      return;
+    }
+    if (world.isRemote) {
+      return;
+    }
+    long curTime = world.getTotalWorldTime();
+    if ((curTime > 0L) && (curTime != this.timeAtLastApply))
+    {
+      this.timeAtLastApply = curTime;
+      ConduitNetworkTickHandler.instance.addListener(this.tickHandler);
+    }
+  }
+  
+  private void doTick()
   {
     if ((this.gasType == null) || (this.outputs.isEmpty()) || (!this.tank.containsValidGas()) || (this.tank.isEmpty()))
     {
@@ -277,4 +304,17 @@ public class GasConduitNetwork
     setConduitVolumes();
     this.lastSyncedVolume = this.tank.getStored();
   }
+  
+  private class InnerTickHandler
+    implements ConduitNetworkTickHandler.TickListener
+  {
+    private InnerTickHandler() {}
+    
+    public void tickStart(TickEvent.ServerTickEvent evt) {}
+    
+    public void tickEnd(TickEvent.ServerTickEvent evt)
+    {
+      GasConduitNetwork.this.doTick();
+    }
+  }
 }
diff --git a/src/Java/miscutil/enderio/conduit/gas/GasConduitRenderer.java b/src/Java/miscutil/enderio/conduit/gas/GasConduitRenderer.java
index 4bb0a2eb1c..9b53361b44 100644
--- a/src/Java/miscutil/enderio/conduit/gas/GasConduitRenderer.java
+++ b/src/Java/miscutil/enderio/conduit/gas/GasConduitRenderer.java
@@ -1,11 +1,5 @@
 package crazypants.enderio.conduit.gas;
 
-import com.enderio.core.client.render.BoundingBox;
-import com.enderio.core.client.render.CubeRenderer;
-import com.enderio.core.client.render.RenderUtil;
-import com.enderio.core.common.vecmath.Vector2f;
-import com.enderio.core.common.vecmath.Vector3d;
-import com.enderio.core.common.vecmath.Vertex;
 import crazypants.enderio.EnderIO;
 import crazypants.enderio.conduit.BlockConduitBundle;
 import crazypants.enderio.conduit.ConnectionMode;
@@ -16,6 +10,12 @@ import crazypants.enderio.conduit.geom.ConnectionModeGeometry;
 import crazypants.enderio.conduit.geom.Offset;
 import crazypants.enderio.conduit.render.ConduitBundleRenderer;
 import crazypants.enderio.conduit.render.DefaultConduitRenderer;
+import crazypants.render.BoundingBox;
+import crazypants.render.CubeRenderer;
+import crazypants.render.RenderUtil;
+import crazypants.vecmath.Vector2f;
+import crazypants.vecmath.Vector3d;
+import crazypants.vecmath.Vertex;
 import java.util.List;
 import mekanism.api.gas.Gas;
 import mekanism.api.gas.GasStack;
@@ -112,14 +112,14 @@ public class GasConduitRenderer
       if (conduit.getConnectionMode(component.dir) == ConnectionMode.DISABLED)
       {
         tex = EnderIO.blockConduitBundle.getConnectorIcon(component.data);
-        Object corners = component.bound.getCornersWithUvForFace(component.dir, tex.getMinU(), tex.getMaxU(), tex.getMinV(), tex.getMaxV());
+        List<Vertex> corners = component.bound.getCornersWithUvForFace(component.dir, tex.getMinU(), tex.getMaxU(), tex.getMinV(), tex.getMaxV());
         Tessellator tessellator = Tessellator.instance;
-        for (Vertex c : (List)corners) {
+        for (Vertex c : corners) {
           CubeRenderer.addVecWithUV(c.xyz, c.uv.x, c.uv.y);
         }
-        for (int i = ((List)corners).size() - 1; i >= 0; i--)
+        for (int i = corners.size() - 1; i >= 0; i--)
         {
-          Vertex c = (Vertex)((List)corners).get(i);
+          Vertex c = (Vertex)corners.get(i);
           CubeRenderer.addVecWithUV(c.xyz, c.uv.x, c.uv.y);
         }
       }
diff --git a/src/Java/miscutil/enderio/conduit/gas/GasOutput.java b/src/Java/miscutil/enderio/conduit/gas/GasOutput.java
index 02bb4e71dd..f8757b204d 100644
--- a/src/Java/miscutil/enderio/conduit/gas/GasOutput.java
+++ b/src/Java/miscutil/enderio/conduit/gas/GasOutput.java
@@ -1,6 +1,6 @@
 package crazypants.enderio.conduit.gas;
 
-import com.enderio.core.common.util.BlockCoord;
+import crazypants.util.BlockCoord;
 import net.minecraftforge.common.util.ForgeDirection;
 
 public class GasOutput
diff --git a/src/Java/miscutil/enderio/conduit/gas/GasUtil.java b/src/Java/miscutil/enderio/conduit/gas/GasUtil.java
index 1ccadc9485..fcc02ca942 100644
--- a/src/Java/miscutil/enderio/conduit/gas/GasUtil.java
+++ b/src/Java/miscutil/enderio/conduit/gas/GasUtil.java
@@ -1,10 +1,11 @@
 package crazypants.enderio.conduit.gas;
 
-import com.enderio.core.common.util.BlockCoord;
-import cpw.mods.fml.common.ModAPIManager;
-import cpw.mods.fml.common.Optional.Method;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.ModContainer;
 import crazypants.enderio.conduit.IConduitBundle;
 import crazypants.enderio.config.Config;
+import crazypants.util.BlockCoord;
+import java.util.Map;
 import mekanism.api.gas.Gas;
 import mekanism.api.gas.GasStack;
 import mekanism.api.gas.IGasHandler;
@@ -15,15 +16,25 @@ public final class GasUtil
 {
   private static boolean useCheckPerformed = false;
   private static boolean isGasConduitEnabled = false;
-  public static final String API_NAME = "MekanismAPI|gas";
   
   public static boolean isGasConduitEnabled()
   {
     if (!useCheckPerformed)
     {
-      if (Config.isGasConduitEnabled) {
-        isGasConduitEnabled = ModAPIManager.INSTANCE.hasAPI("MekanismAPI|gas");
-      } else {
+      String configOption = Config.isGasConduitEnabled;
+      if (configOption.equalsIgnoreCase("auto"))
+      {
+        isGasConduitEnabled = Loader.isModLoaded("Mekanism");
+        if (isGasConduitEnabled) {
+          isGasConduitEnabled = ((ModContainer)Loader.instance().getIndexedModList().get("Mekanism")).getVersion().startsWith("7");
+        }
+      }
+      else if (configOption.equalsIgnoreCase("true"))
+      {
+        isGasConduitEnabled = true;
+      }
+      else
+      {
         isGasConduitEnabled = false;
       }
       useCheckPerformed = true;
@@ -31,27 +42,23 @@ public final class GasUtil
     return isGasConduitEnabled;
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public static IGasHandler getExternalGasHandler(IBlockAccess world, BlockCoord bc)
   {
     IGasHandler con = getGasHandler(world, bc);
     return (con != null) && (!(con instanceof IConduitBundle)) ? con : null;
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public static IGasHandler getGasHandler(IBlockAccess world, BlockCoord bc)
   {
     return getGasHandler(world, bc.x, bc.y, bc.z);
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public static IGasHandler getGasHandler(IBlockAccess world, int x, int y, int z)
   {
     TileEntity te = world.getTileEntity(x, y, z);
     return getGasHandler(te);
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public static IGasHandler getGasHandler(TileEntity te)
   {
     if ((te instanceof IGasHandler)) {
@@ -60,7 +67,6 @@ public final class GasUtil
     return null;
   }
   
-  @Optional.Method(modid="MekanismAPI|gas")
   public static boolean isGasValid(GasStack gas)
   {
     if (gas != null)
diff --git a/src/Java/miscutil/enderio/conduit/gas/IGasConduit.java b/src/Java/miscutil/enderio/conduit/gas/IGasConduit.java
index f41f6ba9fc..6b09293e63 100644
--- a/src/Java/miscutil/enderio/conduit/gas/IGasConduit.java
+++ b/src/Java/miscutil/enderio/conduit/gas/IGasConduit.java
@@ -1,12 +1,10 @@
 package crazypants.enderio.conduit.gas;
 
-import cpw.mods.fml.common.Optional.Interface;
 import crazypants.enderio.conduit.IConduit;
 import crazypants.enderio.conduit.IExtractor;
 import mekanism.api.gas.IGasHandler;
 import net.minecraftforge.common.util.ForgeDirection;
 
-@Optional.Interface(iface="mekanism.api.gas.IGasHandler", modid="MekanismAPI|gas")
 public abstract interface IGasConduit
   extends IConduit, IGasHandler, IExtractor
 {
diff --git a/src/Java/miscutil/enderio/conduit/gas/ItemGasConduit.java b/src/Java/miscutil/enderio/conduit/gas/ItemGasConduit.java
index df9fe0844b..d09e657023 100644
--- a/src/Java/miscutil/enderio/conduit/gas/ItemGasConduit.java
+++ b/src/Java/miscutil/enderio/conduit/gas/ItemGasConduit.java
@@ -1,16 +1,15 @@
 package crazypants.enderio.conduit.gas;
 
-import com.enderio.core.api.client.gui.IAdvancedTooltipProvider;
-import com.enderio.core.client.handlers.SpecialTooltipHandler;
-import com.enderio.core.common.Lang;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-import crazypants.enderio.EnderIO;
 import crazypants.enderio.ModObject;
 import crazypants.enderio.conduit.AbstractItemConduit;
 import crazypants.enderio.conduit.IConduit;
 import crazypants.enderio.conduit.ItemConduitSubtype;
 import crazypants.enderio.config.Config;
+import crazypants.enderio.gui.IAdvancedTooltipProvider;
+import crazypants.enderio.gui.TooltipAddera;
+import crazypants.util.Lang;
 import java.util.List;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
@@ -19,8 +18,7 @@ public class ItemGasConduit
   extends AbstractItemConduit
   implements IAdvancedTooltipProvider
 {
-  private static ItemConduitSubtype[] subtypes = { new ItemConduitSubtype(ModObject.itemGasConduit
-    .name(), "enderio:itemGasConduit") };
+  private static ItemConduitSubtype[] subtypes = { new ItemConduitSubtype(ModObject.itemGasConduit.name(), "enderio:itemGasConduit") };
   
   public static ItemGasConduit create()
   {
@@ -58,12 +56,12 @@ public class ItemGasConduit
   @SideOnly(Side.CLIENT)
   public void addDetailedEntries(ItemStack itemstack, EntityPlayer entityplayer, List list, boolean flag)
   {
-    String gpt = " " + EnderIO.lang.localize("gas.gasTick");
+    String gpt = " " + Lang.localize("gas.gasTick");
     int extractRate = Config.gasConduitExtractRate;
     int maxIo = Config.gasConduitMaxIoRate;
-    list.add(EnderIO.lang.localize("itemGasConduit.tooltip.maxExtract") + " " + extractRate + gpt);
-    list.add(EnderIO.lang.localize("itemGasConduit.tooltip.maxIo") + " " + maxIo + gpt);
-    SpecialTooltipHandler.addDetailedTooltipFromResources(list, "enderio.itemGasConduit");
+    list.add(Lang.localize("itemGasConduit.tooltip.maxExtract") + " " + extractRate + gpt);
+    list.add(Lang.localize("itemGasConduit.tooltip.maxIo") + " " + maxIo + gpt);
+    TooltipAddera.addDetailedTooltipFromResources(list, "enderio.itemGasConduit");
   }
   
   public boolean shouldHideFacades(ItemStack stack, EntityPlayer player)
diff --git a/src/Java/miscutil/enderio/conduit/gas/PacketGasLevel.java b/src/Java/miscutil/enderio/conduit/gas/PacketGasLevel.java
index 0e1b96313c..15ea65840a 100644
--- a/src/Java/miscutil/enderio/conduit/gas/PacketGasLevel.java
+++ b/src/Java/miscutil/enderio/conduit/gas/PacketGasLevel.java
@@ -1,11 +1,11 @@
 package crazypants.enderio.conduit.gas;
 
-import com.enderio.core.common.network.MessageTileEntity;
 import cpw.mods.fml.common.network.ByteBufUtils;
 import cpw.mods.fml.common.network.simpleimpl.IMessage;
 import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
 import cpw.mods.fml.common.network.simpleimpl.MessageContext;
 import crazypants.enderio.conduit.IConduitBundle;
+import crazypants.enderio.network.MessageTileEntity;
 import crazypants.util.ClientUtil;
 import io.netty.buffer.ByteBuf;
 import net.minecraft.nbt.NBTTagCompound;
diff --git a/src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java b/src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java
new file mode 100644
index 0000000000..a4ebe2e9c2
--- /dev/null
+++ b/src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java
@@ -0,0 +1,235 @@
+package miscutil.gregtech.metatileentity.implementations;
+
+import static gregtech.api.enums.GT_Values.VN;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.TextureSet;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntityCable;
+import gregtech.api.interfaces.tileentity.IColoredTileEntity;
+import gregtech.api.interfaces.tileentity.IEnergyConnected;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Cable;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Utility;
+import ic2.api.energy.tile.IEnergySink;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import cofh.api.energy.IEnergyReceiver;
+
+public class GregtechMetaPipeEntity_Cable extends GT_MetaPipeEntity_Cable implements IMetaTileEntityCable {
+	public long mTransferredAmperage = 0, mTransferredAmperageLast20 = 0, mTransferredVoltageLast20 = 0;
+
+	public final float mThickNess;
+	public final Materials mMaterial;
+	public final long mCableLossPerMeter, mAmperage, mVoltage;
+	public final boolean mInsulated, mCanShock;
+	public long mRestRF;
+
+	public GregtechMetaPipeEntity_Cable(int aID, String aName, String aNameRegional, float aThickNess, Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) {
+		super(aID, aName, aNameRegional, 0, aMaterial, aCableLossPerMeter, aAmperage, aVoltage, aInsulated, aCanShock);
+		mThickNess = aThickNess;
+		mMaterial = aMaterial;
+		mAmperage = aAmperage;
+		mVoltage = aVoltage;
+		mInsulated = aInsulated;
+		mCanShock = aCanShock;
+		mCableLossPerMeter = aCableLossPerMeter;
+	}
+
+	public GregtechMetaPipeEntity_Cable(String aName, float aThickNess, Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) {
+		super(aName, 0, aMaterial, aCableLossPerMeter, aAmperage, aVoltage, aInsulated, aCanShock);
+		mThickNess = aThickNess;
+		mMaterial = aMaterial;
+		mAmperage = aAmperage;
+		mVoltage = aVoltage;
+		mInsulated = aInsulated;
+		mCanShock = aCanShock;
+		mCableLossPerMeter = aCableLossPerMeter;
+	}
+
+	@Override
+	public byte getTileEntityBaseType() {
+		return (byte)(mInsulated?9:8);
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaPipeEntity_Cable(mName, mThickNess, mMaterial, mCableLossPerMeter, mAmperage, mVoltage, mInsulated, mCanShock);
+	}
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aConnections, byte aColorIndex, boolean aConnected, boolean aRedstone) {
+		if (!mInsulated) return new ITexture[]					{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa)};
+		if (aConnected) {
+			float tThickNess = getThickNess();
+			if (tThickNess < 0.37F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_TINY	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			if (tThickNess < 0.49F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_SMALL	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			if (tThickNess < 0.74F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_MEDIUM	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			if (tThickNess < 0.99F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_LARGE	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			return new ITexture[]								{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_HUGE	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+		}
+		return new ITexture[]									{new GT_RenderedTexture(Textures.BlockIcons.INSULATION_FULL, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+	}
+
+	@Override
+	public void onEntityCollidedWithBlock(World aWorld, int aX, int aY, int aZ, Entity aEntity) {
+		if (mCanShock && (((BaseMetaPipeEntity)getBaseMetaTileEntity()).mConnections & -128) == 0 && aEntity instanceof EntityLivingBase) GT_Utility.applyElectricityDamage((EntityLivingBase)aEntity, mTransferredVoltageLast20, mTransferredAmperageLast20);
+	}
+
+	@Override
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+		if (!mCanShock) return super.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ);
+		return AxisAlignedBB.getBoundingBox(aX+0.125D, aY+0.125D, aZ+0.125D, aX+0.875D, aY+0.875D, aZ+0.875D);
+	}
+	
+	@Override public boolean isSimpleMachine()						{return true;}
+	@Override public boolean isFacingValid(byte aFacing)			{return false;}
+	@Override public boolean isValidSlot(int aIndex)				{return true;}
+   // @Override public final boolean renderInside(byte aSide)			{return false;}
+    @Override public int getProgresstime()							{return (int)mTransferredAmperage*64;}
+    @Override public int maxProgresstime()							{return (int)mAmperage*64;}
+
+	@Override
+	public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) {
+		if (!getBaseMetaTileEntity().getCoverBehaviorAtSide(aSide).letsEnergyIn(aSide, getBaseMetaTileEntity().getCoverIDAtSide(aSide), getBaseMetaTileEntity().getCoverDataAtSide(aSide), getBaseMetaTileEntity())) return 0;
+		return transferElectricity(aSide, aVoltage, aAmperage, new ArrayList<TileEntity>(Arrays.asList((TileEntity)getBaseMetaTileEntity())));
+	}
+
+	@Override
+	public long transferElectricity(byte aSide, long aVoltage, long aAmperage, ArrayList<TileEntity> aAlreadyPassedTileEntityList) {
+		long rUsedAmperes = 0;
+		aVoltage -= mCableLossPerMeter;
+		if (aVoltage > 0) for (byte i = 0; i < 6 && aAmperage > rUsedAmperes; i++) if (i != aSide && (mConnections & (1<<i)) != 0 && getBaseMetaTileEntity().getCoverBehaviorAtSide(i).letsEnergyOut(i, getBaseMetaTileEntity().getCoverIDAtSide(i), getBaseMetaTileEntity().getCoverDataAtSide(i), getBaseMetaTileEntity())) {
+			TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(i);
+			if (!aAlreadyPassedTileEntityList.contains(tTileEntity)) {
+				aAlreadyPassedTileEntityList.add(tTileEntity);
+				if (tTileEntity instanceof IEnergyConnected) {
+					if (getBaseMetaTileEntity().getColorization() >= 0) {
+						byte tColor = ((IEnergyConnected)tTileEntity).getColorization();
+						if (tColor >= 0 && tColor != getBaseMetaTileEntity().getColorization()) continue;
+					}
+					if (tTileEntity instanceof IGregTechTileEntity && ((IGregTechTileEntity)tTileEntity).getMetaTileEntity() instanceof IMetaTileEntityCable && ((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(GT_Utility.getOppositeSide(i)).letsEnergyIn(GT_Utility.getOppositeSide(i), ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(GT_Utility.getOppositeSide(i)), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(GT_Utility.getOppositeSide(i)), ((IGregTechTileEntity)tTileEntity))) {
+						if (((IGregTechTileEntity)tTileEntity).getTimer() > 50) rUsedAmperes += ((IMetaTileEntityCable)((IGregTechTileEntity)tTileEntity).getMetaTileEntity()).transferElectricity(GT_Utility.getOppositeSide(i), aVoltage, aAmperage-rUsedAmperes, aAlreadyPassedTileEntityList);
+					} else {
+						rUsedAmperes += ((IEnergyConnected)tTileEntity).injectEnergyUnits(GT_Utility.getOppositeSide(i), aVoltage, aAmperage-rUsedAmperes);
+					}
+					//        		} else if (tTileEntity instanceof IEnergySink) {
+					//            		ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+					//            		if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)getBaseMetaTileEntity(), tDirection)) {
+					//            			if (((IEnergySink)tTileEntity).demandedEnergyUnits() > 0 && ((IEnergySink)tTileEntity).injectEnergyUnits(tDirection, aVoltage) < aVoltage) rUsedAmperes++;
+					//            		}
+				} else if (tTileEntity instanceof IEnergySink) {
+					ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+					if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)getBaseMetaTileEntity(), tDirection)) {
+						if (((IEnergySink)tTileEntity).getDemandedEnergy() > 0 && ((IEnergySink)tTileEntity).injectEnergy(tDirection, aVoltage, aVoltage) < aVoltage) rUsedAmperes++;
+					}
+				} else if(GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver){
+					ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+					int rfOut = (int) (aVoltage * GregTech_API.mEUtoRF / 100);
+					if(((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, true)==rfOut){
+						((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, false); rUsedAmperes++;
+					}else if(((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, true)>0){
+						if(mRestRF==0){
+							int RFtrans = ((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, (int) rfOut, false);rUsedAmperes++;
+							mRestRF = rfOut - RFtrans; 
+						}else{
+							int RFtrans = ((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, (int) mRestRF, false); 
+							mRestRF = mRestRF - RFtrans;
+						}
+					}
+					if(GregTech_API.mRFExplosions && ((IEnergyReceiver)tTileEntity).getMaxEnergyStored(tDirection) < rfOut * 600){
+						if(rfOut > 32 * GregTech_API.mEUtoRF / 100) this.doExplosion(rfOut);
+					}
+				}
+			}
+		}
+		mTransferredAmperage += rUsedAmperes;
+		mTransferredVoltageLast20 = Math.max(mTransferredVoltageLast20, aVoltage);
+		mTransferredAmperageLast20 = Math.max(mTransferredAmperageLast20, mTransferredAmperage);
+		if (aVoltage > mVoltage || mTransferredAmperage > mAmperage) {
+			getBaseMetaTileEntity().setToFire();
+			return aAmperage;
+		}
+		return rUsedAmperes;
+	}
+
+	@Override
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+		if (aBaseMetaTileEntity.isServerSide()) {
+			mTransferredAmperage = 0;
+
+			if (aTick % 20 == 0) {
+				mTransferredVoltageLast20 = 0;
+				mTransferredAmperageLast20 = 0;
+				mConnections = 0;
+				for (byte i = 0, j = 0; i < 6; i++) {
+					j = GT_Utility.getOppositeSide(i);
+					if (aBaseMetaTileEntity.getCoverBehaviorAtSide(i).alwaysLookConnected(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity) || aBaseMetaTileEntity.getCoverBehaviorAtSide(i).letsEnergyIn(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity) || aBaseMetaTileEntity.getCoverBehaviorAtSide(i).letsEnergyOut(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity)) {
+						TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(i);
+						if (tTileEntity instanceof IColoredTileEntity) {
+							if (aBaseMetaTileEntity.getColorization() >= 0) {
+								byte tColor = ((IColoredTileEntity)tTileEntity).getColorization();
+								if (tColor >= 0 && tColor != aBaseMetaTileEntity.getColorization()) continue;
+							}
+						}
+						if (tTileEntity instanceof IEnergyConnected && (((IEnergyConnected)tTileEntity).inputEnergyFrom(j) || ((IEnergyConnected)tTileEntity).outputsEnergyTo(j))) {
+							mConnections |= (1<<i);
+							continue;
+						}
+						if (tTileEntity instanceof IGregTechTileEntity && ((IGregTechTileEntity)tTileEntity).getMetaTileEntity() instanceof IMetaTileEntityCable) {
+							if (((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(j).alwaysLookConnected(j, ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity)tTileEntity)) || ((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(j).letsEnergyIn(j, ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity)tTileEntity)) || ((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(j).letsEnergyOut(j, ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity)tTileEntity))) {
+								mConnections |= (1<<i);
+								continue;
+							}
+						}
+						if (tTileEntity instanceof IEnergySink && ((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)aBaseMetaTileEntity, ForgeDirection.getOrientation(j))) {
+							mConnections |= (1<<i);
+							continue;
+						}
+						if(GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver && ((IEnergyReceiver)tTileEntity).canConnectEnergy(ForgeDirection.getOrientation(j))){
+							mConnections |= (1<<i);
+							continue;					    	
+						}					    
+						/*
+					    if (tTileEntity instanceof IEnergyEmitter && ((IEnergyEmitter)tTileEntity).emitsEnergyTo((TileEntity)aBaseMetaTileEntity, ForgeDirection.getOrientation(j))) {
+				    		mConnections |= (1<<i);
+				    		continue;
+					    }*/
+					}
+				}
+			}
+		}
+	}
+
+
+	@Override
+	public String[] getDescription() {
+		return new String[] {
+				"Max Voltage: "			+ EnumChatFormatting.GREEN	+ mVoltage + " (" + VN[GT_Utility.getTier(mVoltage)]	+ ")" + EnumChatFormatting.GRAY,
+				"Max Amperage: "		+ EnumChatFormatting.YELLOW	+ mAmperage + EnumChatFormatting.GRAY,
+				"Loss/Meter/Ampere: "	+ EnumChatFormatting.RED	+ mCableLossPerMeter + EnumChatFormatting.GRAY + " EU-Volt",
+				"Added by: "	+ EnumChatFormatting.RED+" Alkalus"
+		};
+	}
+
+
+	@Override
+	public float getThickNess() {
+		return mThickNess;
+	}
+
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/mcmod.info b/src/Java/miscutil/mcmod.info
new file mode 100644
index 0000000000..0c2b859007
--- /dev/null
+++ b/src/Java/miscutil/mcmod.info
@@ -0,0 +1,19 @@
+/**
+ * @version 0.1
+ * @author Alkalus
+ * In-game info for project: Hello World.
+ */
+[ { "modid"        : "miscutils"
+  , "name"         : "miscutils"
+  , "description"  : "Adds a few various things. Supported mods include GregTech, EnderIO, Big Reactors, Thaumcraft, ExtraUtils, Pnuematicraft & Simply Jetpacks."
+  , "version"      : "0.7.8gtu"
+  , "mcversion"    : "1.7.10"
+  , "url"          : ""
+  , "updateUrl"    : ""
+  , "authorList"   : ["Alkalus"]
+  , "credits"      : ""
+  , "logoFile"     : ""
+  , "screenshots"  : []
+  , "dependencies" : ["Forge10.13.0.1180"]
+  }
+]