Initial conduit work started based off of Mekinisms Gas Conduits. (Thanks tterag)

14 files changed, 1946 insertions, 0 deletions

diff --git a/src/Java/miscutil/enderio/conduit/ConduitGTHandler.java b/src/Java/miscutil/enderio/conduit/ConduitGTHandler.java
new file mode 100644
index 0000000000..f8786fd578
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/ConduitGTHandler.java
@@ -0,0 +1,76 @@
+package miscutil.enderio.conduit;
+
+import gregtech.api.interfaces.tileentity.IEnergyConnected;
+import gregtech.api.metatileentity.BaseTileEntity;
+import mekanism.api.gas.GasStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class ConduitGTHandler extends BaseTileEntity implements IEnergyConnected{
+
+	@Override
+	public byte getColorization() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public byte setColorization(byte arg0) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public long getTimer() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public boolean isInvalidTileEntity() {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound arg0) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void setLightValue(byte arg0) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound arg0) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public long injectEnergyUnits(byte arg0, long arg1, long arg2) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public boolean inputEnergyFrom(byte arg0) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public boolean outputsEnergyTo(byte arg0) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	public int receiveGas(ForgeDirection dir, GasStack offer) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/Conduit_Base.java b/src/Java/miscutil/enderio/conduit/Conduit_Base.java
new file mode 100644
index 0000000000..7a4b6ac1cf
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/Conduit_Base.java
@@ -0,0 +1,415 @@
+package miscutil.enderio.conduit;
+
+import gregtech.api.interfaces.tileentity.IEnergyConnected;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraftforge.fluids.IFluidHandler;
+
+public class Conduit_Base implements IEnergyConnected{
+
+	@Override
+	public byte getColorization() {
+		 
+		return 0;
+	}
+
+	@Override
+	public byte setColorization(byte aColor) {
+		 
+		return 0;
+	}
+
+	@Override
+	public World getWorld() {
+		 
+		return null;
+	}
+
+	@Override
+	public int getXCoord() {
+		 
+		return 0;
+	}
+
+	@Override
+	public short getYCoord() {
+		 
+		return 0;
+	}
+
+	@Override
+	public int getZCoord() {
+		 
+		return 0;
+	}
+
+	@Override
+	public boolean isServerSide() {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean isClientSide() {
+		 
+		return false;
+	}
+
+	@Override
+	public int getRandomNumber(int aRange) {
+		 
+		return 0;
+	}
+
+	@Override
+	public TileEntity getTileEntity(int aX, int aY, int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public TileEntity getTileEntityOffset(int aX, int aY, int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public TileEntity getTileEntityAtSide(byte aSide) {
+		 
+		return null;
+	}
+
+	@Override
+	public TileEntity getTileEntityAtSideAndDistance(byte aSide, int aDistance) {
+		 
+		return null;
+	}
+
+	@Override
+	public IInventory getIInventory(int aX, int aY, int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public IInventory getIInventoryOffset(int aX, int aY, int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public IInventory getIInventoryAtSide(byte aSide) {
+		 
+		return null;
+	}
+
+	@Override
+	public IInventory getIInventoryAtSideAndDistance(byte aSide, int aDistance) {
+		 
+		return null;
+	}
+
+	@Override
+	public IFluidHandler getITankContainer(int aX, int aY, int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public IFluidHandler getITankContainerOffset(int aX, int aY, int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public IFluidHandler getITankContainerAtSide(byte aSide) {
+		 
+		return null;
+	}
+
+	@Override
+	public IFluidHandler getITankContainerAtSideAndDistance(byte aSide,
+			int aDistance) {
+		 
+		return null;
+	}
+
+	@Override
+	public IGregTechTileEntity getIGregTechTileEntity(int aX, int aY, int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public IGregTechTileEntity getIGregTechTileEntityOffset(int aX, int aY,
+			int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public IGregTechTileEntity getIGregTechTileEntityAtSide(byte aSide) {
+		 
+		return null;
+	}
+
+	@Override
+	public IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(
+			byte aSide, int aDistance) {
+		 
+		return null;
+	}
+
+	@Override
+	public Block getBlock(int aX, int aY, int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public Block getBlockOffset(int aX, int aY, int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public Block getBlockAtSide(byte aSide) {
+		 
+		return null;
+	}
+
+	@Override
+	public Block getBlockAtSideAndDistance(byte aSide, int aDistance) {
+		 
+		return null;
+	}
+
+	@Override
+	public byte getMetaID(int aX, int aY, int aZ) {
+		 
+		return 0;
+	}
+
+	@Override
+	public byte getMetaIDOffset(int aX, int aY, int aZ) {
+		 
+		return 0;
+	}
+
+	@Override
+	public byte getMetaIDAtSide(byte aSide) {
+		 
+		return 0;
+	}
+
+	@Override
+	public byte getMetaIDAtSideAndDistance(byte aSide, int aDistance) {
+		 
+		return 0;
+	}
+
+	@Override
+	public byte getLightLevel(int aX, int aY, int aZ) {
+		 
+		return 0;
+	}
+
+	@Override
+	public byte getLightLevelOffset(int aX, int aY, int aZ) {
+		 
+		return 0;
+	}
+
+	@Override
+	public byte getLightLevelAtSide(byte aSide) {
+		 
+		return 0;
+	}
+
+	@Override
+	public byte getLightLevelAtSideAndDistance(byte aSide, int aDistance) {
+		 
+		return 0;
+	}
+
+	@Override
+	public boolean getOpacity(int aX, int aY, int aZ) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getOpacityOffset(int aX, int aY, int aZ) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getOpacityAtSide(byte aSide) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getOpacityAtSideAndDistance(byte aSide, int aDistance) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getSky(int aX, int aY, int aZ) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getSkyOffset(int aX, int aY, int aZ) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getSkyAtSide(byte aSide) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getSkyAtSideAndDistance(byte aSide, int aDistance) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getAir(int aX, int aY, int aZ) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getAirOffset(int aX, int aY, int aZ) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getAirAtSide(byte aSide) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean getAirAtSideAndDistance(byte aSide, int aDistance) {
+		 
+		return false;
+	}
+
+	@Override
+	public BiomeGenBase getBiome() {
+		 
+		return null;
+	}
+
+	@Override
+	public BiomeGenBase getBiome(int aX, int aZ) {
+		 
+		return null;
+	}
+
+	@Override
+	public int getOffsetX(byte aSide, int aMultiplier) {
+		 
+		return 0;
+	}
+
+	@Override
+	public short getOffsetY(byte aSide, int aMultiplier) {
+		 
+		return 0;
+	}
+
+	@Override
+	public int getOffsetZ(byte aSide, int aMultiplier) {
+		 
+		return 0;
+	}
+
+	@Override
+	public boolean isDead() {
+		 
+		return false;
+	}
+
+	@Override
+	public void sendBlockEvent(byte aID, byte aValue) {
+		 
+		
+	}
+
+	@Override
+	public long getTimer() {
+		 
+		return 0;
+	}
+
+	@Override
+	public void setLightValue(byte aLightValue) {
+		 
+		
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound aNBT) {
+		 
+		
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound aNBT) {
+		 
+		
+	}
+
+	@Override
+	public boolean isInvalidTileEntity() {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean openGUI(EntityPlayer aPlayer, int aID) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean openGUI(EntityPlayer aPlayer) {
+		 
+		return false;
+	}
+
+	@Override
+	public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) {
+		 
+		return 0;
+	}
+
+	@Override
+	public boolean inputEnergyFrom(byte aSide) {
+		 
+		return false;
+	}
+
+	@Override
+	public boolean outputsEnergyTo(byte aSide) {
+		 
+		return false;
+	}
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtConduit.java b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtConduit.java
new file mode 100644
index 0000000000..de0fc13371
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtConduit.java
@@ -0,0 +1,73 @@
+package miscutil.enderio.conduit.GregTech;
+
+import mekanism.api.gas.Gas;
+import mekanism.api.gas.GasStack;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraftforge.common.util.ForgeDirection;
+import crazypants.enderio.conduit.AbstractConduitNetwork;
+import crazypants.enderio.conduit.gas.AbstractGasConduit;
+import crazypants.enderio.conduit.geom.CollidableComponent;
+
+public class AbstractGtConduit extends AbstractGasConduit{
+
+	@Override
+	public ItemStack createItem() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public AbstractConduitNetwork<?, ?> getNetwork() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public boolean setNetwork(AbstractConduitNetwork<?, ?> network) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public IIcon getTextureForState(CollidableComponent component) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public IIcon getTransmitionTextureForState(CollidableComponent component) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public int receiveGas(ForgeDirection side, GasStack stack) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public GasStack drawGas(ForgeDirection side, int amount) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public boolean canReceiveGas(ForgeDirection side, Gas type) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public boolean canDrawGas(ForgeDirection side, Gas type) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	protected boolean canJoinNeighbour(IGtConduit n) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduit.java b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduit.java
new file mode 100644
index 0000000000..1b440aa0bb
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduit.java
@@ -0,0 +1,161 @@
+package miscutil.enderio.conduit.GregTech;
+
+import java.util.List;
+
+import mekanism.api.gas.GasStack;
+import mekanism.api.gas.IGasHandler;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import crazypants.enderio.conduit.AbstractConduitNetwork;
+import crazypants.enderio.conduit.ConduitUtil;
+import crazypants.enderio.conduit.ConnectionMode;
+import crazypants.enderio.conduit.RaytraceResult;
+import crazypants.enderio.tool.ToolUtil;
+import crazypants.util.BlockCoord;
+
+public abstract class AbstractGtTankConduit extends AbstractGtConduit {
+
+  protected ConduitGtTank tank = new ConduitGtTank(0);
+  protected boolean stateDirty = false;
+  protected long lastEmptyTick = 0;
+  protected int numEmptyEvents = 0;
+
+  @Override
+  public boolean onBlockActivated(EntityPlayer player, RaytraceResult res, List<RaytraceResult> all) {
+    if(player.getCurrentEquippedItem() == null) {
+      return false;
+    }
+    if(ToolUtil.isToolEquipped(player)) {
+
+      if(!getBundle().getEntity().getWorldObj().isRemote) {
+
+        if(res != null && res.component != null) {
+
+          ForgeDirection connDir = res.component.dir;
+          ForgeDirection faceHit = ForgeDirection.getOrientation(res.movingObjectPosition.sideHit);
+
+          if(connDir == ForgeDirection.UNKNOWN || connDir == faceHit) {
+
+            if(getConnectionMode(faceHit) == ConnectionMode.DISABLED) {
+              setConnectionMode(faceHit, getNextConnectionMode(faceHit));
+              return true;
+            }
+
+            BlockCoord loc = getLocation().getLocation(faceHit);
+            IGtConduit n = ConduitUtil.getConduit(getBundle().getEntity().getWorldObj(), loc.x, loc.y, loc.z, IGtConduit.class);
+            if(n == null) {
+              return false;
+            }
+            if(!canJoinNeighbour(n)) {
+              return false;
+            }
+            if(!(n instanceof AbstractGtTankConduit)) {
+              return false;
+            }
+            AbstractGtTankConduit neighbour = (AbstractGtTankConduit) n;
+            if(neighbour.getGasType() == null || getGasType() == null) {
+              GasStack type = getGasType();
+              type = type != null ? type : neighbour.getGasType();
+              neighbour.setGasTypeOnNetwork(neighbour, type);
+              setGasTypeOnNetwork(this, type);
+            }
+            return ConduitUtil.joinConduits(this, faceHit);
+          } else if(containsExternalConnection(connDir)) {
+            // Toggle extraction mode
+            setConnectionMode(connDir, getNextConnectionMode(connDir));
+          } else if(containsConduitConnection(connDir)) {
+            GasStack curGasType = null;
+            if(getTankNetwork() != null) {
+              curGasType = getTankNetwork().getGasType();
+            }
+            ConduitUtil.disconectConduits(this, connDir);
+            setGasType(curGasType);
+
+          }
+        }
+      }
+      return true;
+
+    }
+
+    return false;
+  }
+
+  private void setGasTypeOnNetwork(AbstractGtTankConduit con, GasStack type) {
+    AbstractConduitNetwork<?, ?> n = con.getNetwork();
+    if(n != null) {
+      AbstractGtTankConduitNetwork<?> network = (AbstractGtTankConduitNetwork<?>) n;
+      network.setGasType(type);
+    }
+
+  }
+
+  protected abstract boolean canJoinNeighbour(IGtConduit n);
+
+  public abstract AbstractGtTankConduitNetwork<? extends AbstractGtTankConduit> getTankNetwork();
+
+  public void setGasType(GasStack gasType) {
+    if(tank.getGas() != null && tank.getGas().isGasEqual(gasType)) {
+      return;
+    }
+    if(gasType != null) {
+      gasType = gasType.copy();
+    } else if(tank.getGas() == null) {
+      return;
+    }
+    tank.setGas(gasType);
+    stateDirty = true;
+  }
+
+  public ConduitGtTank getTank() {
+    return tank;
+  }
+
+  public GasStack getGasType() {
+    GasStack result = null;
+    if(getTankNetwork() != null) {
+      result = getTankNetwork().getGasType();
+    }
+    if(result == null) {
+      result = tank.getGas();
+    }
+    return result;
+  }
+  
+  @Override
+  public boolean canOutputToDir(ForgeDirection dir) {
+    if (super.canOutputToDir(dir)) {
+      IGasHandler ext = getExternalHandler(dir);
+      return ext != null && ext.canReceiveGas(dir.getOpposite(), tank.getGasType());
+    }
+    return false;
+  }
+
+  protected abstract void updateTank();
+
+  @Override
+  public void readFromNBT(NBTTagCompound nbtRoot, short nbtVersion) {
+    super.readFromNBT(nbtRoot, nbtVersion);
+    updateTank();
+    if(nbtRoot.hasKey("tank")) {
+      GasStack gas = GasStack.readFromNBT(nbtRoot.getCompoundTag("tank"));
+      tank.setGas(gas);
+    } else {
+      tank.setGas(null);
+    }
+  }
+
+  @Override
+  public void writeToNBT(NBTTagCompound nbtRoot) {
+    super.writeToNBT(nbtRoot);
+    GasStack gt = getGasType();
+    if(GtUtil.isGasValid(gt)) {
+      updateTank();
+      gt = gt.copy();
+      gt.amount = tank.getStored();
+      nbtRoot.setTag("tank", gt.write(new NBTTagCompound()));
+    }
+  }
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduitNetwork.java b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduitNetwork.java
new file mode 100644
index 0000000000..8cd720fa18
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduitNetwork.java
@@ -0,0 +1,64 @@
+package miscutil.enderio.conduit.GregTech;
+
+import mekanism.api.gas.GasStack;
+import crazypants.enderio.conduit.AbstractConduitNetwork;
+
+public class AbstractGtTankConduitNetwork<T extends AbstractGtTankConduit> extends AbstractConduitNetwork<IGtConduit, T> {
+
+  protected GasStack gasType;
+
+  protected AbstractGtTankConduitNetwork(Class<T> cl) {
+    super(cl);
+  }
+
+  public GasStack getGasType() {
+    return gasType;
+  }
+
+  @Override
+  public Class<IGtConduit> getBaseConduitType() {
+    return IGtConduit.class;
+  }
+
+  @Override
+  public void addConduit(T con) {
+    super.addConduit(con);
+    con.setGasType(gasType);
+  }
+
+  public boolean setGasType(GasStack newType) {
+    if(gasType != null && gasType.isGasEqual(newType)) {
+      return false;
+    }
+    if(newType != null) {
+      gasType = newType.copy();
+      gasType.amount = 0;
+    } else {
+      gasType = null;
+    }
+    for (AbstractGtTankConduit conduit : conduits) {
+      conduit.setGasType(gasType);
+    }
+    return true;
+  }
+
+  public boolean canAcceptGas(GasStack acceptable) {
+    return areGassCompatable(gasType, acceptable);
+  }
+
+  public static boolean areGassCompatable(GasStack a, GasStack b) {
+    if(a == null || b == null) {
+      return true;
+    }
+    return a.isGasEqual(b);
+  }
+
+  public int getTotalVolume() {
+    int totalVolume = 0;
+    for (T con : conduits) {
+      totalVolume += con.getTank().getStored();
+    }
+    return totalVolume;
+  }
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/ConduitGtTank.java b/src/Java/miscutil/enderio/conduit/GregTech/ConduitGtTank.java
new file mode 100644
index 0000000000..d1a81f32d2
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/ConduitGtTank.java
@@ -0,0 +1,153 @@
+package miscutil.enderio.conduit.GregTech;
+
+import mekanism.api.gas.GasStack;
+import mekanism.api.gas.GasTank;
+import net.minecraft.nbt.NBTTagCompound;
+
+public class ConduitGtTank extends GasTank {
+
+  private int capacity;
+
+  ConduitGtTank(int capacity) {
+    super(capacity);
+    this.capacity = capacity;
+  }
+
+  public float getFilledRatio() {
+    if(getStored() <= 0) {
+      return 0;
+    }
+    if(getMaxGas() <= 0) {
+      return -1;
+    }
+    float res = (float) getStored() / getMaxGas();
+    return res;
+  }
+
+  public boolean isFull() {
+    return getStored() >= getMaxGas();
+  }
+
+  public void setAmount(int amount) {
+    if(stored != null) {
+      stored.amount = amount;
+    }
+  }
+
+  public int getAvailableSpace() {
+    return getMaxGas() - getStored();
+  }
+
+  public void addAmount(int amount) {
+    setAmount(getStored() + amount);
+  }
+
+  @Override
+  public int getMaxGas() {
+    return this.capacity;
+  }
+
+  public void setCapacity(int capacity) {
+    this.capacity = capacity;
+    if(getStored() > capacity) {
+      setAmount(capacity);
+    }
+  }
+
+  @Override
+  public int receive(GasStack resource, boolean doReceive) {
+    if(resource == null || resource.getGas().getID() < 0) {
+      return 0;
+    }
+
+    if(stored == null || stored.getGas().getID() < 0) {
+      if(resource.amount <= capacity) {
+        if(doReceive) {
+          setGas(resource.copy());
+        }
+        return resource.amount;
+      } else {
+        if(doReceive) {
+          stored = resource.copy();
+          stored.amount = capacity;
+        }
+        return capacity;
+      }
+    }
+
+    if(!stored.isGasEqual(resource)) {
+      return 0;
+    }
+
+    int space = capacity - stored.amount;
+    if(resource.amount <= space) {
+      if(doReceive) {
+        addAmount(resource.amount);
+      }
+      return resource.amount;
+    } else {
+      if(doReceive) {
+        stored.amount = capacity;
+      }
+      return space;
+    }
+
+  }
+
+  @Override
+  public GasStack draw(int maxDrain, boolean doDraw) {
+    if(stored == null || stored.getGas().getID() < 0) {
+      return null;
+    }
+    if(stored.amount <= 0) {
+      return null;
+    }
+
+    int used = maxDrain;
+    if(stored.amount < used) {
+      used = stored.amount;
+    }
+
+    if(doDraw) {
+      addAmount(-used);
+    }
+
+    GasStack drained = new GasStack(stored.getGas().getID(), used);
+
+    if(stored.amount < 0) {
+      stored.amount = 0;
+    }
+    return drained;
+  }
+
+  public String getGasName() {
+    return stored != null ? stored.getGas().getLocalizedName() : null;
+  }
+
+  public boolean containsValidGas() {
+    return GtUtil.isGasValid(stored);
+  }
+
+  public NBTTagCompound write(NBTTagCompound nbt) {
+    if(containsValidGas()) {
+      stored.write(nbt);
+    } else {
+      nbt.setBoolean("emptyGasTank", true);
+    }
+    return nbt;
+  }
+
+  public void read(NBTTagCompound nbt) {
+    if(!nbt.hasKey("emptyGasTank")) {
+      GasStack gas = GasStack.readFromNBT(nbt);
+      if(gas != null) {
+        setGas(gas);
+      }
+    }
+  }
+
+  public boolean isEmpty() {
+    return stored == null || stored.amount == 0;
+  }
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/GtConduit.java b/src/Java/miscutil/enderio/conduit/GregTech/GtConduit.java
new file mode 100644
index 0000000000..3af9f089e4
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/GtConduit.java
@@ -0,0 +1,265 @@
+package miscutil.enderio.conduit.GregTech;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import mekanism.api.gas.Gas;
+import mekanism.api.gas.GasStack;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import crazypants.enderio.EnderIO;
+import crazypants.enderio.conduit.AbstractConduitNetwork;
+import crazypants.enderio.conduit.ConnectionMode;
+import crazypants.enderio.conduit.IConduit;
+import crazypants.enderio.conduit.geom.CollidableComponent;
+import crazypants.enderio.config.Config;
+import crazypants.render.IconUtil;
+import crazypants.util.BlockCoord;
+
+public class GtConduit extends AbstractGtTankConduit {
+
+  public static final int CONDUIT_VOLUME = 1000;
+
+  public static final String ICON_KEY = "enderio:gasConduit";
+  public static final String ICON_CORE_KEY = "enderio:gasConduitCore";
+  public static final String ICON_EXTRACT_KEY = "enderio:gasConduitInput";
+  public static final String ICON_INSERT_KEY = "enderio:gasConduitOutput";
+  public static final String ICON_EMPTY_EDGE = "enderio:gasConduitEdge";
+
+  static final Map<String, IIcon> ICONS = new HashMap<String, IIcon>();
+
+  @SideOnly(Side.CLIENT)
+  public static void initIcons() {
+    IconUtil.addIconProvider(new IconUtil.IIconProvider() {
+
+      @Override
+      public void registerIcons(IIconRegister register) {
+        ICONS.put(ICON_KEY, register.registerIcon(ICON_KEY));
+        ICONS.put(ICON_CORE_KEY, register.registerIcon(ICON_CORE_KEY));
+        ICONS.put(ICON_EXTRACT_KEY, register.registerIcon(ICON_EXTRACT_KEY));
+        ICONS.put(ICON_INSERT_KEY, register.registerIcon(ICON_INSERT_KEY));
+        ICONS.put(ICON_EMPTY_EDGE, register.registerIcon(ICON_EMPTY_EDGE));
+      }
+
+      @Override
+      public int getTextureType() {
+        return 0;
+      }
+
+    });
+  }
+
+  private GtConduitNetwork network;
+
+  private long ticksSinceFailedExtract = 0;
+
+  public static final int MAX_EXTRACT_PER_TICK = Config.gasConduitExtractRate;
+
+  public static final int MAX_IO_PER_TICK = Config.gasConduitMaxIoRate;
+
+  public GtConduit() {
+    updateTank();
+  }
+
+  @Override
+  public void updateEntity(World world) {
+    super.updateEntity(world);
+    if(world.isRemote) {
+      return;
+    }
+    doExtract();
+    if(stateDirty) {
+      getBundle().dirty();
+      stateDirty = false;
+    }
+  }
+
+  private void doExtract() {
+    BlockCoord loc = getLocation();
+    if(!hasConnectionMode(ConnectionMode.INPUT)) {
+      return;
+    }
+    if(network == null) {
+      return;
+    }
+
+    // assume failure, reset to 0 if we do extract
+    ticksSinceFailedExtract++;
+    if(ticksSinceFailedExtract > 25 && ticksSinceFailedExtract % 10 != 0) {
+      // after 25 ticks of failing, only check every 10 ticks
+      return;
+    }
+
+    Gas f = tank.getGas() == null ? null : tank.getGas().getGas();
+    for (ForgeDirection dir : externalConnections) {
+      if(autoExtractForDir(dir)) {
+        if(network.extractFrom(this, dir, MAX_EXTRACT_PER_TICK)) {
+          ticksSinceFailedExtract = 0;
+        }
+      }
+    }
+
+  }
+
+  @Override
+  protected void updateTank() {
+    tank.setCapacity(CONDUIT_VOLUME);
+    if(network != null) {
+      network.updateConduitVolumes();
+    }
+  }
+
+  @Override
+  public ItemStack createItem() {
+    return new ItemStack(EnderIO.itemGasConduit);
+  }
+
+  @Override
+  public AbstractConduitNetwork<?, ?> getNetwork() {
+    return network;
+  }
+
+  @Override
+  public boolean setNetwork(AbstractConduitNetwork<?, ?> network) {
+    if(network == null) {
+      this.network = null;
+      return true;
+    }
+    if(!(network instanceof GtConduitNetwork)) {
+      return false;
+    }
+
+    GtConduitNetwork n = (GtConduitNetwork) network;
+    if(tank.getGas() == null) {
+      tank.setGas(n.getGasType() == null ? null : n.getGasType().copy());
+    } else if(n.getGasType() == null) {
+      n.setGasType(tank.getGas());
+    } else if(!tank.getGas().isGasEqual(n.getGasType())) {
+      return false;
+    }
+    this.network = n;
+    return true;
+
+  }
+
+  @Override
+  public boolean canConnectToConduit(ForgeDirection direction, IConduit con) {
+    if(!super.canConnectToConduit(direction, con)) {
+      return false;
+    }
+    if(!(con instanceof GtConduit)) {
+      return false;
+    }
+    if(getGasType() != null && ((GtConduit) con).getGasType() == null) {
+      return false;
+    }
+    return GtConduitNetwork.areGassCompatable(getGasType(), ((GtConduit) con).getGasType());
+  }
+
+  @Override
+  public void setConnectionMode(ForgeDirection dir, ConnectionMode mode) {
+    super.setConnectionMode(dir, mode);
+    refreshInputs(dir);
+  }
+
+  private void refreshInputs(ForgeDirection dir) {
+    if(network == null) {
+      return;
+    }
+    GtOutput lo = new GtOutput(getLocation().getLocation(dir), dir.getOpposite());
+    network.removeInput(lo);
+    if(getConnectionMode(dir).acceptsOutput() && containsExternalConnection(dir)) {
+      network.addInput(lo);
+    }
+  }
+
+  @Override
+  public void externalConnectionAdded(ForgeDirection fromDirection) {
+    super.externalConnectionAdded(fromDirection);
+    refreshInputs(fromDirection);
+  }
+
+  @Override
+  public void externalConnectionRemoved(ForgeDirection fromDirection) {
+    super.externalConnectionRemoved(fromDirection);
+    refreshInputs(fromDirection);
+  }
+
+  @Override
+  public IIcon getTextureForState(CollidableComponent component) {
+    if(component.dir == ForgeDirection.UNKNOWN) {
+      return ICONS.get(ICON_CORE_KEY);
+    }
+    return ICONS.get(ICON_KEY);
+  }
+
+  public IIcon getTextureForInputMode() {
+    return ICONS.get(ICON_EXTRACT_KEY);
+  }
+
+  public IIcon getTextureForOutputMode() {
+    return ICONS.get(ICON_INSERT_KEY);
+  }
+
+  public IIcon getNotSetEdgeTexture() {
+    return ICONS.get(ICON_EMPTY_EDGE);
+  }
+
+  @Override
+  public IIcon getTransmitionTextureForState(CollidableComponent component) {
+    if(isActive() && tank.containsValidGas()) {
+      return tank.getGas().getGas().getIcon();
+    }
+    return null;
+  }
+
+  // ------------------------------------------- Gas API
+
+  @Override
+  public int receiveGas(ForgeDirection from, GasStack resource) {
+    if(network == null || !getConnectionMode(from).acceptsInput()) {
+      return 0;
+    }
+    return network.fill(from, resource, true);
+  }
+
+  @Override
+  public GasStack drawGas(ForgeDirection from, int maxDrain) {
+    if(network == null || !getConnectionMode(from).acceptsOutput()) {
+      return null;
+    }
+    return network.drain(from, maxDrain, true);
+  }
+
+  @Override
+  public boolean canReceiveGas(ForgeDirection from, Gas gas) {
+    if(network == null) {
+      return false;
+    }
+    return getConnectionMode(from).acceptsInput() && GtConduitNetwork.areGassCompatable(getGasType(), new GasStack(gas, 0));
+  }
+
+  @Override
+  public boolean canDrawGas(ForgeDirection from, Gas gas) {
+    if(network == null) {
+      return false;
+    }
+    return getConnectionMode(from).acceptsOutput() && GtConduitNetwork.areGassCompatable(getGasType(), new GasStack(gas, 0));
+  }
+
+  @Override
+  protected boolean canJoinNeighbour(IGtConduit n) {
+    return n instanceof GtConduit;
+  }
+
+  @Override
+  public AbstractGtTankConduitNetwork<? extends AbstractGtTankConduit> getTankNetwork() {
+    return network;
+  }
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/GtConduitNetwork.java b/src/Java/miscutil/enderio/conduit/GregTech/GtConduitNetwork.java
new file mode 100644
index 0000000000..7855547a7e
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/GtConduitNetwork.java
@@ -0,0 +1,310 @@
+package miscutil.enderio.conduit.GregTech;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import mekanism.api.gas.GasStack;
+import mekanism.api.gas.IGasHandler;
+import miscutil.enderio.conduit.ConduitGTHandler;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent;
+import crazypants.enderio.conduit.ConduitNetworkTickHandler;
+import crazypants.enderio.conduit.ConduitNetworkTickHandler.TickListener;
+import crazypants.enderio.conduit.IConduit;
+import crazypants.util.BlockCoord;
+
+public class GtConduitNetwork extends AbstractGtTankConduitNetwork<GtConduit> {
+
+  private final ConduitGtTank tank = new ConduitGtTank(0);
+
+  private final Set<GtOutput> outputs = new HashSet<GtOutput>();
+
+  private Iterator<GtOutput> outputIterator;
+
+  private int ticksActiveUnsynced;
+
+  private boolean lastSyncedActive = false;
+
+  private int lastSyncedVolume = -1;
+
+  private long timeAtLastApply;
+
+  private final InnerTickHandler tickHandler = new InnerTickHandler();
+
+  public GtConduitNetwork() {
+    super(GtConduit.class);
+  }
+
+  @Override
+  public Class<IGtConduit> getBaseConduitType() {
+    return IGtConduit.class;
+  }
+
+  @Override
+  public void addConduit(GtConduit con) {
+    tank.setCapacity(tank.getMaxGas() + GtConduit.CONDUIT_VOLUME);
+    if(con.getTank().containsValidGas()) {
+      tank.addAmount(con.getTank().getStored());
+    }
+    for (ForgeDirection dir : con.getExternalConnections()) {
+      if(con.getConnectionMode(dir).acceptsOutput()) {
+        outputs.add(new GtOutput(con.getLocation().getLocation(dir), dir.getOpposite()));
+      }
+    }
+    outputIterator = null;
+    super.addConduit(con);
+  }
+
+  @Override
+  public boolean setGasType(GasStack newType) {
+    if(super.setGasType(newType)) {
+
+      GasStack ft = getGasType();
+      tank.setGas(ft == null ? null : ft.copy());
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public void destroyNetwork() {
+    setConduitVolumes();
+    outputs.clear();
+    super.destroyNetwork();
+  }
+
+  private void setConduitVolumes() {
+    if(tank.containsValidGas() && !conduits.isEmpty()) {
+      GasStack gasPerConduit = tank.getGas().copy();
+      int numCons = conduits.size();
+      int leftOvers = gasPerConduit.amount % numCons;
+      gasPerConduit.amount = gasPerConduit.amount / numCons;
+
+      for (GtConduit con : conduits) {
+        GasStack f = gasPerConduit.copy();
+        if(leftOvers > 0) {
+          f.amount += 1;
+          leftOvers--;
+        }
+        con.getTank().setGas(f);
+        BlockCoord bc = con.getLocation();
+        con.getBundle().getEntity().getWorldObj().markTileEntityChunkModified(bc.x, bc.y, bc.z, con.getBundle().getEntity());
+      }
+
+    }
+  }
+
+  @Override
+  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 > 0 && curTime != timeAtLastApply) {
+      timeAtLastApply = curTime;
+      ConduitNetworkTickHandler.instance.addListener(tickHandler);
+    }
+
+  }
+
+  private void doTick() {
+    if(gasType == null || outputs.isEmpty() || !tank.containsValidGas() || tank.isEmpty()) {
+      updateActiveState();
+      return;
+    }
+
+    if(outputIterator == null || !outputIterator.hasNext()) {
+      outputIterator = outputs.iterator();
+    }
+
+    updateActiveState();
+
+    int numVisited = 0;
+    while (!tank.isEmpty() && numVisited < outputs.size()) {
+      if(!outputIterator.hasNext()) {
+        outputIterator = outputs.iterator();
+      }
+      GtOutput output = outputIterator.next();
+      if(output != null) {
+    	 ConduitGTHandler cont = (ConduitGTHandler) getTankContainer(output.location);
+        if(cont != null) {
+          GasStack offer = tank.getGas().copy();
+          int filled = cont.receiveGas(output.dir, offer);
+          if(filled > 0) {
+            tank.addAmount(-filled);
+
+          }
+        }
+      }
+      numVisited++;
+    }
+
+  }
+
+  private void updateActiveState() {
+    boolean isActive = tank.containsValidGas() && !tank.isEmpty();
+    if(lastSyncedActive != isActive) {
+      ticksActiveUnsynced++;
+    } else {
+      ticksActiveUnsynced = 0;
+    }
+    if(ticksActiveUnsynced >= 10 || ticksActiveUnsynced > 0 && isActive) {
+      if(!isActive) {
+        setGasType(null);
+      }
+      for (IConduit con : conduits) {
+        con.setActive(isActive);
+      }
+      lastSyncedActive = isActive;
+      ticksActiveUnsynced = 0;
+    }
+  }
+
+  public int fill(ForgeDirection from, GasStack resource, boolean doFill) {
+    if(resource == null) {
+      return 0;
+    }
+    resource.amount = Math.min(resource.amount, GtConduit.MAX_IO_PER_TICK);
+    boolean gasWasValid = tank.containsValidGas();
+    int res = tank.receive(resource, doFill);
+    if(doFill && res > 0 && gasWasValid) {
+      int vol = tank.getStored();
+      setGasType(resource);
+      tank.setAmount(vol);
+    }
+    return res;
+  }
+
+  public GasStack drain(ForgeDirection from, GasStack resource, boolean doDrain) {
+    if(resource == null || tank.isEmpty() || !tank.containsValidGas() || !GtConduitNetwork.areGassCompatable(getGasType(), resource)) {
+      return null;
+    }
+    int amount = Math.min(resource.amount, tank.getStored());
+    amount = Math.min(amount, GtConduit.MAX_IO_PER_TICK);
+    GasStack result = resource.copy();
+    result.amount = amount;
+    if(doDrain) {
+      tank.addAmount(-amount);
+    }
+    return result;
+  }
+
+  public GasStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
+    if(tank.isEmpty() || !tank.containsValidGas()) {
+      return null;
+    }
+    int amount = Math.min(maxDrain, tank.getStored());
+    GasStack result = tank.getGas().copy();
+    result.amount = amount;
+    if(doDrain) {
+      tank.addAmount(-amount);
+    }
+    return result;
+  }
+
+  public boolean extractFrom(GtConduit advancedGtConduit, ForgeDirection dir, int maxExtractPerTick) {
+
+    if(tank.isFull()) {
+      return false;
+    }
+
+    IGasHandler extTank = getTankContainer(advancedGtConduit, dir);
+    if(extTank != null) {
+      int maxExtract = Math.min(maxExtractPerTick, tank.getAvailableSpace());
+
+      if(gasType == null || !tank.containsValidGas()) {
+        GasStack drained = extTank.drawGas(dir.getOpposite(), maxExtract);
+        if(drained == null || drained.amount <= 0) {
+          return false;
+        }
+        setGasType(drained);
+        tank.setGas(drained.copy());
+        return true;
+      }
+
+      GasStack couldDrain = gasType.copy();
+      couldDrain.amount = maxExtract;
+
+      //      GasStack drained = extTank.drain(dir.getOpposite(), couldDrain, true);
+      //      if(drained == null || drained.amount <= 0) {
+      //        return false;
+      //      }
+      //      tank.addAmount(drained.amount);     
+
+      //Have to use this 'double handle' approach to work around an issue with TiC
+      GasStack drained = extTank.drawGas(dir.getOpposite(), maxExtract);
+      if(drained == null || drained.amount == 0) {
+        return false;
+      } else {
+        if(drained.isGasEqual(getGasType())) {
+          tank.addAmount(drained.amount);
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+
+  public IGasHandler getTankContainer(BlockCoord bc) {
+    World w = getWorld();
+    if(w == null) {
+      return null;
+    }
+    TileEntity te = w.getTileEntity(bc.x, bc.y, bc.z);
+    if(te instanceof IGasHandler) {
+      return (IGasHandler) te;
+    }
+    return null;
+  }
+
+  public IGasHandler getTankContainer(GtConduit con, ForgeDirection dir) {
+    BlockCoord bc = con.getLocation().getLocation(dir);
+    return getTankContainer(bc);
+  }
+
+  World getWorld() {
+    if(conduits.isEmpty()) {
+      return null;
+    }
+    return conduits.get(0).getBundle().getWorld();
+  }
+
+  public void removeInput(GtOutput lo) {
+    outputs.remove(lo);
+    outputIterator = null;
+  }
+
+  public void addInput(GtOutput lo) {
+    outputs.add(lo);
+    outputIterator = null;
+  }
+
+  public void updateConduitVolumes() {
+    if(tank.getStored() == lastSyncedVolume) {
+      return;
+    }
+    setConduitVolumes();
+    lastSyncedVolume = tank.getStored();
+  }
+
+  private class InnerTickHandler implements TickListener {
+
+    @Override
+    public void tickStart(ServerTickEvent evt) {
+    }
+
+    @Override
+    public void tickEnd(ServerTickEvent evt) {
+      doTick();
+    }
+  }
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/GtConduitRenderer.java b/src/Java/miscutil/enderio/conduit/GregTech/GtConduitRenderer.java
new file mode 100644
index 0000000000..00070b0db5
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/GtConduitRenderer.java
@@ -0,0 +1,180 @@
+package miscutil.enderio.conduit.GregTech;
+
+import static crazypants.render.CubeRenderer.addVecWithUV;
+
+import java.util.List;
+
+import mekanism.api.gas.GasStack;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.IIcon;
+import net.minecraftforge.common.util.ForgeDirection;
+import crazypants.enderio.EnderIO;
+import crazypants.enderio.conduit.ConnectionMode;
+import crazypants.enderio.conduit.IConduit;
+import crazypants.enderio.conduit.IConduitBundle;
+import crazypants.enderio.conduit.geom.CollidableComponent;
+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.RenderUtil;
+import crazypants.vecmath.Vector3d;
+import crazypants.vecmath.Vertex;
+
+public class GtConduitRenderer extends DefaultConduitRenderer {
+
+  @Override
+  public boolean isRendererForConduit(IConduit conduit) {
+    return conduit instanceof GtConduit;
+  }
+
+  @Override
+  public void renderEntity(ConduitBundleRenderer conduitBundleRenderer, IConduitBundle te, IConduit conduit, double x, double y, double z, float partialTick,
+      float worldLight, RenderBlocks rb) {
+    super.renderEntity(conduitBundleRenderer, te, conduit, x, y, z, partialTick, worldLight, rb);
+
+    if(!conduit.hasConnectionMode(ConnectionMode.INPUT) && !conduit.hasConnectionMode(ConnectionMode.OUTPUT)) {
+      return;
+    }
+    GtConduit pc = (GtConduit) conduit;
+    for (ForgeDirection dir : conduit.getExternalConnections()) {
+      IIcon tex = null;
+      if(conduit.getConnectionMode(dir) == ConnectionMode.INPUT) {
+        tex = pc.getTextureForInputMode();
+      } else if(conduit.getConnectionMode(dir) == ConnectionMode.OUTPUT) {
+        tex = pc.getTextureForOutputMode();
+      }
+      if(tex != null) {
+        Offset offset = te.getOffset(IGtConduit.class, dir);
+        ConnectionModeGeometry.renderModeConnector(dir, offset, tex, true);
+      }
+    }
+  }
+
+  @Override
+  protected void renderConduit(IIcon tex, IConduit conduit, CollidableComponent component, float brightness) {
+    super.renderConduit(tex, conduit, component, brightness);
+
+    if(isNSEWUD(component.dir)) {
+      GtConduit lc = (GtConduit) conduit;
+
+      GasStack gas = lc.getGasType();
+      IIcon texture = null;
+      if(gas != null) {
+        texture = gas.getGas().getIcon();
+      }
+
+      if(texture == null) {
+        texture = lc.getNotSetEdgeTexture();
+      }
+
+      float scaleFactor = 0.75f;
+      float xLen = Math.abs(component.dir.offsetX) == 1 ? 1 : scaleFactor;
+      float yLen = Math.abs(component.dir.offsetY) == 1 ? 1 : scaleFactor;
+      float zLen = Math.abs(component.dir.offsetZ) == 1 ? 1 : scaleFactor;
+
+      BoundingBox cube = component.bound;
+      BoundingBox bb = cube.scale(xLen, yLen, zLen);
+
+      for (ForgeDirection d : ForgeDirection.VALID_DIRECTIONS) {
+        if(d != component.dir && d != component.dir.getOpposite()) {
+
+          ForgeDirection vDir = RenderUtil.getVDirForFace(d);
+          if(component.dir == ForgeDirection.UP || component.dir == ForgeDirection.DOWN) {
+            vDir = RenderUtil.getUDirForFace(d);
+          } else if((component.dir == ForgeDirection.NORTH || component.dir == ForgeDirection.SOUTH) && d.offsetY != 0) {
+            vDir = RenderUtil.getUDirForFace(d);
+          }
+
+          float minU = texture.getMinU();
+          float maxU = texture.getMaxU();
+          float minV = texture.getMinV();
+          float maxV = texture.getMaxV();
+
+          float sideScale = Math.max(bb.sizeX(), bb.sizeY()) * 2 / 16f;
+          sideScale = Math.max(sideScale, bb.sizeZ() * 2 / 16f);
+          float width = Math.min(bb.sizeX(), bb.sizeY()) * 15f / 16f;
+
+          List<Vertex> corners = bb.getCornersWithUvForFace(d, minU, maxU, minV, maxV);
+          moveEdgeCorners(corners, vDir, width);
+          moveEdgeCorners(corners, component.dir.getOpposite(), sideScale);
+          for (Vertex c : corners) {
+            addVecWithUV(c.xyz, c.uv.x, c.uv.y);
+          }
+
+          corners = bb.getCornersWithUvForFace(d, minU, maxU, minV, maxV);
+          moveEdgeCorners(corners, vDir.getOpposite(), width);
+          moveEdgeCorners(corners, component.dir.getOpposite(), sideScale);
+          for (Vertex c : corners) {
+            addVecWithUV(c.xyz, c.uv.x, c.uv.y);
+          }
+
+        }
+      }
+
+      if(conduit.getConnectionMode(component.dir) == ConnectionMode.DISABLED) {
+        tex = EnderIO.blockConduitBundle.getConnectorIcon(component.data);
+        List<Vertex> corners = component.bound.getCornersWithUvForFace(component.dir, tex.getMinU(), tex.getMaxU(), tex.getMinV(), tex.getMaxV());
+        Tessellator tessellator = Tessellator.instance;
+        for (Vertex c : corners) {
+          addVecWithUV(c.xyz, c.uv.x, c.uv.y);
+        }
+        //back face
+        for (int i = corners.size() - 1; i >= 0; i--) {
+          Vertex c = corners.get(i);
+          addVecWithUV(c.xyz, c.uv.x, c.uv.y);
+        }
+      }
+
+    }
+
+  }
+
+  @Override
+  protected void renderTransmission(IConduit conduit, IIcon tex, CollidableComponent component, float selfIllum) {
+    super.renderTransmission(conduit, tex, component, selfIllum);
+  }
+
+  private void moveEdgeCorners(List<Vertex> vertices, ForgeDirection edge, float scaleFactor) {
+    int[] indices = getClosest(edge, vertices);
+    vertices.get(indices[0]).xyz.x -= scaleFactor * edge.offsetX;
+    vertices.get(indices[1]).xyz.x -= scaleFactor * edge.offsetX;
+    vertices.get(indices[0]).xyz.y -= scaleFactor * edge.offsetY;
+    vertices.get(indices[1]).xyz.y -= scaleFactor * edge.offsetY;
+    vertices.get(indices[0]).xyz.z -= scaleFactor * edge.offsetZ;
+    vertices.get(indices[1]).xyz.z -= scaleFactor * edge.offsetZ;
+  }
+
+  private int[] getClosest(ForgeDirection edge, List<Vertex> vertices) {
+    int[] res = new int[] { -1, -1 };
+    boolean highest = edge.offsetX > 0 || edge.offsetY > 0 || edge.offsetZ > 0;
+    double minMax = highest ? -Double.MAX_VALUE : Double.MAX_VALUE;
+    int index = 0;
+    for (Vertex v : vertices) {
+      double val = get(v.xyz, edge);
+      if(highest ? val >= minMax : val <= minMax) {
+        if(val != minMax) {
+          res[0] = index;
+        } else {
+          res[1] = index;
+        }
+        minMax = val;
+      }
+      index++;
+    }
+    return res;
+  }
+
+  private double get(Vector3d xyz, ForgeDirection edge) {
+    if(edge == ForgeDirection.EAST || edge == ForgeDirection.WEST) {
+      return xyz.x;
+    }
+    if(edge == ForgeDirection.UP || edge == ForgeDirection.DOWN) {
+      return xyz.y;
+    }
+    return xyz.z;
+  }
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/GtOutput.java b/src/Java/miscutil/enderio/conduit/GregTech/GtOutput.java
new file mode 100644
index 0000000000..afaa97eb00
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/GtOutput.java
@@ -0,0 +1,49 @@
+package miscutil.enderio.conduit.GregTech;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import crazypants.util.BlockCoord;
+
+public class GtOutput {
+
+  final ForgeDirection dir;
+  final BlockCoord location;
+
+  public GtOutput(BlockCoord bc, ForgeDirection dir) {
+    this.dir = dir;
+    this.location = bc;
+  }
+
+  @Override
+  public int hashCode() {
+    final int prime = 31;
+    int result = 1;
+    result = prime * result + ((location == null) ? 0 : location.hashCode());
+    result = prime * result + ((dir == null) ? 0 : dir.hashCode());
+    return result;
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if(this == obj)
+      return true;
+    if(obj == null)
+      return false;
+    if(getClass() != obj.getClass())
+      return false;
+    GtOutput other = (GtOutput) obj;
+    if(location == null) {
+      if(other.location != null)
+        return false;
+    } else if(!location.equals(other.location))
+      return false;
+    if(dir != other.dir)
+      return false;
+    return true;
+  }
+
+  @Override
+  public String toString() {
+    return "GasOutput [dir=" + dir + ", location=" + location + "]";
+  }
+
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/GtUtil.java b/src/Java/miscutil/enderio/conduit/GregTech/GtUtil.java
new file mode 100644
index 0000000000..16408ca88c
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/GtUtil.java
@@ -0,0 +1,69 @@
+package miscutil.enderio.conduit.GregTech;
+
+import mekanism.api.gas.GasStack;
+import mekanism.api.gas.IGasHandler;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockAccess;
+import cpw.mods.fml.common.Loader;
+import crazypants.enderio.conduit.IConduitBundle;
+import crazypants.enderio.config.Config;
+import crazypants.util.BlockCoord;
+
+public final class GtUtil {
+
+  private static boolean useCheckPerformed = false;
+  private static boolean isGasConduitEnabled = false;
+
+  public static boolean isGasConduitEnabled() {
+    if (!useCheckPerformed) {
+      String configOption = Config.isGasConduitEnabled;
+      if (configOption.equalsIgnoreCase("auto")) {
+        isGasConduitEnabled = Loader.isModLoaded("Mekanism");
+        if (isGasConduitEnabled) {
+          isGasConduitEnabled = Loader.instance().getIndexedModList().get("Mekanism").getVersion().startsWith("7");
+        }
+      } else if (configOption.equalsIgnoreCase("true")) {
+        isGasConduitEnabled = true;
+      } else {
+        isGasConduitEnabled = false;
+      }
+      useCheckPerformed = true;
+    }
+    return isGasConduitEnabled;
+  }
+
+  public static IGasHandler getExternalGasHandler(IBlockAccess world, BlockCoord bc) {
+    IGasHandler con = getGasHandler(world, bc);
+    return (con != null && !(con instanceof IConduitBundle)) ? con : null;
+  }
+
+  public static IGasHandler getGasHandler(IBlockAccess world, BlockCoord bc) {
+    return getGasHandler(world, bc.x, bc.y, bc.z);
+  }
+
+  public static IGasHandler getGasHandler(IBlockAccess world, int x, int y, int z) {
+    TileEntity te = world.getTileEntity(x, y, z);
+    return getGasHandler(te);
+  }
+
+  public static IGasHandler getGasHandler(TileEntity te) {
+    if(te instanceof IGasHandler) {
+      return (IGasHandler) te;
+    }
+    return null;
+  }
+
+  public static boolean isGasValid(GasStack gas) {
+    if(gas != null) {
+      String name = gas.getGas().getLocalizedName();
+      if(name != null && !name.trim().isEmpty()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private GtUtil() {
+  }
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/IGtConduit.java b/src/Java/miscutil/enderio/conduit/GregTech/IGtConduit.java
new file mode 100644
index 0000000000..869966e33d
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/IGtConduit.java
@@ -0,0 +1,12 @@
+package miscutil.enderio.conduit.GregTech;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import crazypants.enderio.conduit.IConduit;
+
+public interface IGtConduit extends IConduit {
+
+  boolean canOutputToDir(ForgeDirection dir);
+
+  boolean isExtractingFromDir(ForgeDirection dir);
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/ItemGtConduit.java b/src/Java/miscutil/enderio/conduit/GregTech/ItemGtConduit.java
new file mode 100644
index 0000000000..9ded118f20
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/ItemGtConduit.java
@@ -0,0 +1,76 @@
+package miscutil.enderio.conduit.GregTech;
+
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+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;
+
+public class ItemGtConduit extends AbstractItemConduit implements IAdvancedTooltipProvider {
+
+  private static ItemConduitSubtype[] subtypes = new ItemConduitSubtype[] {
+      new ItemConduitSubtype(ModObject.itemGasConduit.name(), "enderio:itemGasConduit"),
+  };
+
+  public static ItemGtConduit create() {
+    ItemGtConduit result = new ItemGtConduit();
+    if (GtUtil.isGasConduitEnabled()) {
+      result.init();
+    }
+    return result;
+  }
+
+  protected ItemGtConduit() {
+    super(ModObject.itemGasConduit, subtypes);
+    if(!GtUtil.isGasConduitEnabled()) {
+      setCreativeTab(null);
+    }
+  }
+
+  @Override
+  public Class<? extends IConduit> getBaseConduitType() {
+    return IGtConduit.class;
+  }
+
+  @Override
+  public IConduit createConduit(ItemStack stack, EntityPlayer player) {
+    return new GtConduit();
+  }
+
+  @Override
+  @SideOnly(Side.CLIENT)
+  public void addCommonEntries(ItemStack itemstack, EntityPlayer entityplayer, List list, boolean flag) {
+  }
+
+  @Override
+  @SideOnly(Side.CLIENT)
+  public void addBasicEntries(ItemStack itemstack, EntityPlayer entityplayer, List list, boolean flag) {
+
+  }
+
+  @Override
+  @SideOnly(Side.CLIENT)
+  public void addDetailedEntries(ItemStack itemstack, EntityPlayer entityplayer, List list, boolean flag) {
+    String gpt = " " + Lang.localize("gas.gasTick");
+    int extractRate = Config.gasConduitExtractRate;
+    int maxIo = Config.gasConduitMaxIoRate;
+    list.add(Lang.localize("itemGasConduit.tooltip.maxExtract") + " " + extractRate + gpt);
+    list.add(Lang.localize("itemGasConduit.tooltip.maxIo") + " " + maxIo + gpt);
+    TooltipAddera.addDetailedTooltipFromResources(list, "enderio.itemGasConduit");
+  }
+  
+  @Override
+  public boolean shouldHideFacades(ItemStack stack, EntityPlayer player) {
+    return true;
+  }
+
+}
diff --git a/src/Java/miscutil/enderio/conduit/GregTech/PacketGtLevel.java b/src/Java/miscutil/enderio/conduit/GregTech/PacketGtLevel.java
new file mode 100644
index 0000000000..9998d59d20
--- /dev/null
+++ b/src/Java/miscutil/enderio/conduit/GregTech/PacketGtLevel.java
@@ -0,0 +1,43 @@
+package miscutil.enderio.conduit.GregTech;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+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.gas.IGasConduit;
+import crazypants.enderio.network.MessageTileEntity;
+
+public class PacketGtLevel extends MessageTileEntity<TileEntity> implements IMessageHandler<PacketGtLevel, IMessage> {
+
+  public NBTTagCompound tc;
+
+  public PacketGtLevel() {
+  }
+
+  public PacketGtLevel(IGasConduit conduit) {
+    super(conduit.getBundle().getEntity());
+    tc = new NBTTagCompound();
+    conduit.writeToNBT(tc);
+  }
+
+  @Override
+  public void toBytes(ByteBuf buf) {
+    super.toBytes(buf);
+    ByteBufUtils.writeTag(buf, tc);
+  }
+
+  @Override
+  public void fromBytes(ByteBuf buf) {
+    super.fromBytes(buf);
+    tc = ByteBufUtils.readTag(buf);
+  }
+
+  @Override
+  public IMessage onMessage(PacketGtLevel message, MessageContext ctx) {
+    // TODO ClientUtil.doGasLevelUpdate(message.x, message.y, message.z, message);
+    return null;
+  }
+}