The Great Renaming (#3014)

* move kekztech to a single root dir

* move detrav to a single root dir

* move gtnh-lanthanides to a single root dir

* move tectech and delete some gross reflection in gt++

* remove more reflection inside gt5u

* delete more reflection in gt++

* fix imports

* move bartworks and bwcrossmod

* fix proxies

* move galactigreg and ggfab

* move gtneioreplugin

* try to fix gt++ bee loader

* apply the rename rules to BW

* apply rename rules to bwcrossmod

* apply rename rules to detrav scanner mod

* apply rename rules to galacticgreg

* apply rename rules to ggfab

* apply rename rules to goodgenerator

* apply rename rules to gtnh-lanthanides

* apply rename rules to gt++

* apply rename rules to kekztech

* apply rename rules to kubatech

* apply rename rules to tectech

* apply rename rules to gt

apply the rename rules to gt

* fix tt import

* fix mui hopefully

* fix coremod except intergalactic

* rename assline recipe class

* fix a class name i stumbled on

* rename StructureUtility to GTStructureUtility to prevent conflict with structurelib

* temporary rename of GTTooltipDataCache to old name

* fix gt client/server proxy names

5 files changed, 920 insertions, 0 deletions

diff --git a/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeBlockData.java b/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeBlockData.java
new file mode 100644
index 0000000000..803f38eda5
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeBlockData.java
@@ -0,0 +1,52 @@
+package tectech.thing.metaTileEntity.pipe;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+
+public class MTEPipeBlockData extends MTEPipeData {
+
+    public MTEPipeBlockData(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public MTEPipeBlockData(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new MTEPipeBlockData(mName);
+    }
+
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+        return AxisAlignedBB.getBoundingBox(aX, aY, aZ, aX + 1, aY + 1, aZ + 1);
+    }
+
+    @Override
+    public float getThickNess() {
+        return 1f;
+    }
+
+    @Override
+    public float getExplosionResistance(ForgeDirection side) {
+        return 1000.0f;
+    }
+
+    @Override
+    public String[] getDescription() {
+        return ArrayUtils.add(
+            super.getDescription(),
+            EnumChatFormatting.DARK_AQUA.toString() + EnumChatFormatting.BOLD
+                + translateToLocal("gt.blockmachines.pipe.desc.4"));
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeBlockEnergy.java b/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeBlockEnergy.java
new file mode 100644
index 0000000000..20cc2af16e
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeBlockEnergy.java
@@ -0,0 +1,52 @@
+package tectech.thing.metaTileEntity.pipe;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+
+public class MTEPipeBlockEnergy extends MTEPipeEnergy {
+
+    public MTEPipeBlockEnergy(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public MTEPipeBlockEnergy(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new MTEPipeBlockEnergy(mName);
+    }
+
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+        return AxisAlignedBB.getBoundingBox(aX, aY, aZ, aX + 1, aY + 1, aZ + 1);
+    }
+
+    @Override
+    public float getThickNess() {
+        return 1f;
+    }
+
+    @Override
+    public float getExplosionResistance(ForgeDirection side) {
+        return 1000.0f;
+    }
+
+    @Override
+    public String[] getDescription() {
+        return ArrayUtils.add(
+            super.getDescription(),
+            EnumChatFormatting.DARK_AQUA.toString() + EnumChatFormatting.BOLD
+                + translateToLocal("gt.blockmachines.pipe.desc.4"));
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeData.java b/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeData.java
new file mode 100644
index 0000000000..cd9d583c1b
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeData.java
@@ -0,0 +1,312 @@
+package tectech.thing.metaTileEntity.pipe;
+
+import static gregtech.api.enums.Dyes.MACHINE_METAL;
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+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 cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.GTMod;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.metatileentity.MetaPipeEntity;
+import gregtech.api.objects.GTRenderedTexture;
+import gregtech.common.GTClient;
+import tectech.TecTech;
+import tectech.loader.NetworkDispatcher;
+import tectech.mechanics.pipe.IActivePipe;
+import tectech.mechanics.pipe.IConnectsToDataPipe;
+import tectech.mechanics.pipe.PipeActivityMessage;
+import tectech.util.CommonValues;
+
+/**
+ * Created by Tec on 26.02.2017.
+ */
+public class MTEPipeData extends MetaPipeEntity implements IConnectsToDataPipe, IActivePipe {
+
+    private static Textures.BlockIcons.CustomIcon EMpipe;
+    private static Textures.BlockIcons.CustomIcon EMbar, EMbarActive;
+    public byte connectionCount = 0;
+
+    private boolean active;
+
+    public MTEPipeData(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional, 0);
+    }
+
+    public MTEPipeData(String aName) {
+        super(aName, 0);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new MTEPipeData(mName);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {
+        EMpipe = new Textures.BlockIcons.CustomIcon("iconsets/EM_DATA");
+        EMbar = new Textures.BlockIcons.CustomIcon("iconsets/EM_BAR");
+        EMbarActive = new Textures.BlockIcons.CustomIcon("iconsets/EM_BAR_ACTIVE");
+        super.registerIcons(aBlockIconRegister);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, int aConnections,
+        int colorIndex, boolean aConnected, boolean aRedstone) {
+        return new ITexture[] { new GTRenderedTexture(EMpipe),
+            new GTRenderedTexture(
+                getActive() ? EMbarActive : EMbar,
+                Dyes.getModulation(colorIndex, MACHINE_METAL.getRGBA())) };
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side,
+        ItemStack itemStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side,
+        ItemStack itemStack) {
+        return false;
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound nbtTagCompound) {
+        active = nbtTagCompound.getBoolean("eActive");
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound nbtTagCompound) {
+        nbtTagCompound.setBoolean("eActive", active);
+    }
+
+    @Override
+    public boolean renderInside(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public byte getTileEntityBaseType() {
+        return 4;
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.pipe.datastream.desc.0"), // Advanced
+                                                                                                                     // data
+                                                                                                                     // transmission
+            EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD
+                + translateToLocal("gt.blockmachines.pipe.datastream.desc.1"), // Don't stare at the beam!
+            EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.pipe.datastream.desc.2"), // Must be
+                                                                                                   // painted to
+                                                                                                   // work
+            EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.pipe.datastream.desc.3") // Do not cross or
+                                                                                                  // split
+        };
+    }
+
+    @Override
+    public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {
+        onPostTick(aBaseMetaTileEntity, 31);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if ((aTick & 31) == 31) {
+                if (TecTech.RANDOM.nextInt(15) == 0) {
+                    NetworkDispatcher.INSTANCE.sendToAllAround(
+                        new PipeActivityMessage.PipeActivityData(this),
+                        aBaseMetaTileEntity.getWorld().provider.dimensionId,
+                        aBaseMetaTileEntity.getXCoord(),
+                        aBaseMetaTileEntity.getYCoord(),
+                        aBaseMetaTileEntity.getZCoord(),
+                        256);
+                }
+                if (active) {
+                    active = false;
+                }
+                mConnections = 0;
+                connectionCount = 0;
+                byte myColor = aBaseMetaTileEntity.getColorization();
+                if (aBaseMetaTileEntity.getColorization() < 0) {
+                    return;
+                }
+                for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                    final ForgeDirection oppositeSide = side.getOpposite();
+                    TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(side);
+                    if (tTileEntity instanceof IConnectsToDataPipe) {
+                        byte tColor = ((IConnectsToDataPipe) tTileEntity).getColorization();
+                        if (tColor != myColor) {
+                            continue;
+                        }
+                        if (((IConnectsToDataPipe) tTileEntity).canConnectData(oppositeSide)) {
+                            mConnections |= 1 << side.ordinal();
+                            connectionCount++;
+                        }
+                    } else if (tTileEntity instanceof IGregTechTileEntity) {
+                        IMetaTileEntity meta = ((IGregTechTileEntity) tTileEntity).getMetaTileEntity();
+                        if (meta instanceof IConnectsToDataPipe) {
+                            byte tColor = ((IConnectsToDataPipe) meta).getColorization();
+                            if (tColor != myColor) {
+                                continue;
+                            }
+                            if (((IConnectsToDataPipe) meta).canConnectData(oppositeSide)) {
+                                mConnections |= 1 << side.ordinal();
+                                connectionCount++;
+                            }
+                        }
+                    }
+                }
+            }
+        } else if (aBaseMetaTileEntity.isClientSide() && GTClient.changeDetected == 4) {
+            aBaseMetaTileEntity.issueTextureUpdate();
+        }
+    }
+
+    @Override
+    public boolean canConnectData(ForgeDirection side) {
+        return true;
+    }
+
+    @Override
+    public IConnectsToDataPipe getNext(IConnectsToDataPipe source) {
+        if (connectionCount != 2) {
+            return null;
+        }
+        for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+            if ((mConnections & 1 << side.ordinal()) == 0) {
+                continue; // if not connected continue
+            }
+            TileEntity next = getBaseMetaTileEntity().getTileEntityAtSide(side);
+            if (next instanceof IConnectsToDataPipe && next != source) {
+                if (((IConnectsToDataPipe) next).isDataInputFacing(side.getOpposite())) {
+                    return (IConnectsToDataPipe) next;
+                }
+            } else if (next instanceof IGregTechTileEntity) {
+                IMetaTileEntity meta = ((IGregTechTileEntity) next).getMetaTileEntity();
+                if (meta instanceof IConnectsToDataPipe connecsToPipe && meta != source) {
+                    if (meta instanceof MTEPipeData pipeData && pipeData.connectionCount == 2) {
+                        pipeData.markUsed();
+                        return connecsToPipe;
+                    }
+                    if (connecsToPipe.isDataInputFacing(side.getOpposite())) {
+                        return connecsToPipe;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+        float tSpace = (1f - 0.375f) / 2;
+        float tSide0 = tSpace;
+        float tSide1 = 1f - tSpace;
+        float tSide2 = tSpace;
+        float tSide3 = 1f - tSpace;
+        float tSide4 = tSpace;
+        float tSide5 = 1f - tSpace;
+
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.DOWN) != 0) {
+            tSide0 = tSide2 = tSide4 = 0;
+            tSide3 = tSide5 = 1;
+        }
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.UP) != 0) {
+            tSide2 = tSide4 = 0;
+            tSide1 = tSide3 = tSide5 = 1;
+        }
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.NORTH) != 0) {
+            tSide0 = tSide2 = tSide4 = 0;
+            tSide1 = tSide5 = 1;
+        }
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.SOUTH) != 0) {
+            tSide0 = tSide4 = 0;
+            tSide1 = tSide3 = tSide5 = 1;
+        }
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.WEST) != 0) {
+            tSide0 = tSide2 = tSide4 = 0;
+            tSide1 = tSide3 = 1;
+        }
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.EAST) != 0) {
+            tSide0 = tSide2 = 0;
+            tSide1 = tSide3 = tSide5 = 1;
+        }
+
+        byte tConn = ((BaseMetaPipeEntity) getBaseMetaTileEntity()).mConnections;
+        if ((tConn & 1 << ForgeDirection.DOWN.ordinal()) != 0) {
+            tSide0 = 0f;
+        }
+        if ((tConn & 1 << ForgeDirection.UP.ordinal()) != 0) {
+            tSide1 = 1f;
+        }
+        if ((tConn & 1 << ForgeDirection.NORTH.ordinal()) != 0) {
+            tSide2 = 0f;
+        }
+        if ((tConn & 1 << ForgeDirection.SOUTH.ordinal()) != 0) {
+            tSide3 = 1f;
+        }
+        if ((tConn & 1 << ForgeDirection.WEST.ordinal()) != 0) {
+            tSide4 = 0f;
+        }
+        if ((tConn & 1 << ForgeDirection.EAST.ordinal()) != 0) {
+            tSide5 = 1f;
+        }
+
+        return AxisAlignedBB
+            .getBoundingBox(aX + tSide4, aY + tSide0, aZ + tSide2, aX + tSide5, aY + tSide1, aZ + tSide3);
+    }
+
+    @Override
+    public float getThickNess() {
+        if (GTMod.instance.isClientSide() && GTClient.hideValue == 1) {
+            return 0.0625F;
+        }
+        return 0.375f;
+    }
+
+    @Override
+    public boolean isDataInputFacing(ForgeDirection side) {
+        return true;
+    }
+
+    @Override
+    public byte getColorization() {
+        return getBaseMetaTileEntity().getColorization();
+    }
+
+    @Override
+    public void markUsed() {
+        this.active = true;
+    }
+
+    @Override
+    public void setActive(boolean state) {
+        if (state != active) {
+            active = state;
+            getBaseMetaTileEntity().issueTextureUpdate();
+        }
+    }
+
+    @Override
+    public boolean getActive() {
+        return active;
+    }
+
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeEnergy.java b/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeEnergy.java
new file mode 100644
index 0000000000..fcd23e5085
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeEnergy.java
@@ -0,0 +1,281 @@
+package tectech.thing.metaTileEntity.pipe;
+
+import static gregtech.api.enums.Dyes.MACHINE_METAL;
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+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 cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.GTMod;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IColoredTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.PowerLogic;
+import gregtech.api.logic.interfaces.PowerLogicHost;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.metatileentity.MetaPipeEntity;
+import gregtech.api.objects.GTRenderedTexture;
+import gregtech.common.GTClient;
+import tectech.TecTech;
+import tectech.loader.NetworkDispatcher;
+import tectech.mechanics.pipe.IActivePipe;
+import tectech.mechanics.pipe.IConnectsToEnergyTunnel;
+import tectech.mechanics.pipe.PipeActivityMessage;
+import tectech.util.CommonValues;
+
+public class MTEPipeEnergy extends MetaPipeEntity implements IConnectsToEnergyTunnel, IActivePipe {
+
+    static Textures.BlockIcons.CustomIcon EMcandy, EMCandyActive;
+    private static Textures.BlockIcons.CustomIcon EMpipe;
+    public byte connectionCount = 0;
+
+    private boolean active;
+
+    public MTEPipeEnergy(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional, 0);
+    }
+
+    public MTEPipeEnergy(String aName) {
+        super(aName, 0);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new MTEPipeEnergy(mName);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {
+        EMcandy = new Textures.BlockIcons.CustomIcon("iconsets/EM_CANDY");
+        EMCandyActive = new Textures.BlockIcons.CustomIcon("iconsets/EM_CANDY_ACTIVE");
+        EMpipe = new Textures.BlockIcons.CustomIcon("iconsets/EM_LASER");
+        super.registerIcons(aBlockIconRegister);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, int aConnections,
+        int colorIndex, boolean aConnected, boolean aRedstone) {
+        return new ITexture[] { new GTRenderedTexture(EMpipe),
+            new GTRenderedTexture(
+                getActive() ? EMCandyActive : EMcandy,
+                Dyes.getModulation(colorIndex, MACHINE_METAL.getRGBA())) };
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side,
+        ItemStack itemStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side,
+        ItemStack itemStack) {
+        return false;
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound nbtTagCompound) {
+        active = nbtTagCompound.getBoolean("eActive");
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound nbtTagCompound) {
+        nbtTagCompound.setBoolean("eActive", active);
+    }
+
+    @Override
+    public boolean renderInside(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public byte getTileEntityBaseType() {
+        return 4;
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.pipe.energystream.desc.0"), // Laser
+                                                                                                                       // tunneling
+                                                                                                                       // device.
+            EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD
+                + translateToLocal("gt.blockmachines.pipe.energystream.desc.1"), // Bright Vacuum!!!
+            EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.pipe.energystream.desc.2"), // Must be
+                                                                                                     // painted to
+                                                                                                     // work
+            EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.pipe.energystream.desc.3") // Do not split
+                                                                                                    // or turn
+        };
+    }
+
+    @Override
+    public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {
+        onPostTick(aBaseMetaTileEntity, 31);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if ((aTick & 31) == 31) {
+                if (TecTech.RANDOM.nextInt(15) == 0) {
+                    NetworkDispatcher.INSTANCE.sendToAllAround(
+                        new PipeActivityMessage.PipeActivityData(this),
+                        aBaseMetaTileEntity.getWorld().provider.dimensionId,
+                        aBaseMetaTileEntity.getXCoord(),
+                        aBaseMetaTileEntity.getYCoord(),
+                        aBaseMetaTileEntity.getZCoord(),
+                        256);
+                }
+                if (active) {
+                    active = false;
+                }
+                mConnections = 0;
+                connectionCount = 0;
+                if (aBaseMetaTileEntity.getColorization() < 0) {
+                    return;
+                }
+                for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                    final ForgeDirection oppositeSide = side.getOpposite();
+                    // if (!aBaseMetaTileEntity.getCoverBehaviorAtSide(b0).alwaysLookConnected(b0,
+                    // aBaseMetaTileEntity.getCoverIDAtSide(b0), aBaseMetaTileEntity.getCoverDataAtSide(b0),
+                    // aBaseMetaTileEntity)) {
+                    TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(side);
+                    if (tTileEntity instanceof IColoredTileEntity) {
+                        // if (aBaseMetaTileEntity.getColorization() >= 0) {
+                        byte tColor = ((IColoredTileEntity) tTileEntity).getColorization();
+                        if (tColor != aBaseMetaTileEntity.getColorization()) {
+                            continue;
+                        }
+                        // }
+                    }
+                    if (tTileEntity instanceof PowerLogicHost) {
+                        PowerLogic logic = ((PowerLogicHost) tTileEntity).getPowerLogic(oppositeSide);
+                        if (logic != null && logic.canUseLaser()) {
+                            mConnections |= 1 << side.ordinal();
+                            connectionCount++;
+                            continue;
+                        }
+                    }
+                    if (tTileEntity instanceof IConnectsToEnergyTunnel
+                        && ((IConnectsToEnergyTunnel) tTileEntity).canConnect(oppositeSide)) {
+                        mConnections |= 1 << side.ordinal();
+                        connectionCount++;
+                    } else if (tTileEntity instanceof IGregTechTileEntity
+                        && ((IGregTechTileEntity) tTileEntity).getMetaTileEntity() instanceof IConnectsToEnergyTunnel) {
+                            if (((IConnectsToEnergyTunnel) ((IGregTechTileEntity) tTileEntity).getMetaTileEntity())
+                                .canConnect(oppositeSide)) {
+                                mConnections |= 1 << side.ordinal();
+                                connectionCount++;
+                            }
+                        }
+                }
+            }
+
+        } else if (aBaseMetaTileEntity.isClientSide() && GTClient.changeDetected == 4) {
+            aBaseMetaTileEntity.issueTextureUpdate();
+        }
+    }
+
+    @Override
+    public void setActive(boolean state) {
+        if (state != active) {
+            active = state;
+            getBaseMetaTileEntity().issueTextureUpdate();
+        }
+    }
+
+    @Override
+    public boolean getActive() {
+        return active;
+    }
+
+    @Override
+    public void markUsed() {
+        this.active = true;
+    }
+
+    @Override
+    public boolean canConnect(ForgeDirection side) {
+        return true;
+    }
+
+    @Override
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+        float tSpace = (1f - 0.5f) / 2;
+        float tSide0 = tSpace;
+        float tSide1 = 1f - tSpace;
+        float tSide2 = tSpace;
+        float tSide3 = 1f - tSpace;
+        float tSide4 = tSpace;
+        float tSide5 = 1f - tSpace;
+
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.DOWN) != 0) {
+            tSide0 = tSide2 = tSide4 = 0;
+            tSide3 = tSide5 = 1;
+        }
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.UP) != 0) {
+            tSide2 = tSide4 = 0;
+            tSide1 = tSide3 = tSide5 = 1;
+        }
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.NORTH) != 0) {
+            tSide0 = tSide2 = tSide4 = 0;
+            tSide1 = tSide5 = 1;
+        }
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.SOUTH) != 0) {
+            tSide0 = tSide4 = 0;
+            tSide1 = tSide3 = tSide5 = 1;
+        }
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.WEST) != 0) {
+            tSide0 = tSide2 = tSide4 = 0;
+            tSide1 = tSide3 = 1;
+        }
+        if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.EAST) != 0) {
+            tSide0 = tSide2 = 0;
+            tSide1 = tSide3 = tSide5 = 1;
+        }
+
+        byte tConn = ((BaseMetaPipeEntity) getBaseMetaTileEntity()).mConnections;
+        if ((tConn & 1 << ForgeDirection.DOWN.ordinal()) != 0) {
+            tSide0 = 0f;
+        }
+        if ((tConn & 1 << ForgeDirection.UP.ordinal()) != 0) {
+            tSide1 = 1f;
+        }
+        if ((tConn & 1 << ForgeDirection.NORTH.ordinal()) != 0) {
+            tSide2 = 0f;
+        }
+        if ((tConn & 1 << ForgeDirection.SOUTH.ordinal()) != 0) {
+            tSide3 = 1f;
+        }
+        if ((tConn & 1 << ForgeDirection.WEST.ordinal()) != 0) {
+            tSide4 = 0f;
+        }
+        if ((tConn & 1 << ForgeDirection.EAST.ordinal()) != 0) {
+            tSide5 = 1f;
+        }
+
+        return AxisAlignedBB
+            .getBoundingBox(aX + tSide4, aY + tSide0, aZ + tSide2, aX + tSide5, aY + tSide1, aZ + tSide3);
+    }
+
+    @Override
+    public float getThickNess() {
+        if (GTMod.instance.isClientSide() && GTClient.hideValue == 1) {
+            return 0.0625F;
+        }
+        return 0.5f;
+    }
+
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeEnergyMirror.java b/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeEnergyMirror.java
new file mode 100644
index 0000000000..cb9ce4d13d
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/pipe/MTEPipeEnergyMirror.java
@@ -0,0 +1,223 @@
+package tectech.thing.metaTileEntity.pipe;
+
+import static gregtech.api.enums.Dyes.MACHINE_METAL;
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.GTMod;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IColoredTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.PowerLogic;
+import gregtech.api.logic.interfaces.PowerLogicHost;
+import gregtech.api.objects.GTRenderedTexture;
+import gregtech.common.GTClient;
+import tectech.TecTech;
+import tectech.loader.NetworkDispatcher;
+import tectech.mechanics.pipe.IConnectsToEnergyTunnel;
+import tectech.mechanics.pipe.PipeActivityMessage;
+import tectech.thing.metaTileEntity.hatch.MTEHatchEnergyTunnel;
+import tectech.util.CommonValues;
+
+public class MTEPipeEnergyMirror extends MTEPipeEnergy {
+
+    private static Textures.BlockIcons.CustomIcon EMpipe;
+    private ForgeDirection[] connectedSides = { null, null };
+    private ForgeDirection chainedFrontFacing = null;
+
+    private boolean active;
+
+    public MTEPipeEnergyMirror(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public MTEPipeEnergyMirror(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new MTEPipeEnergyMirror(mName);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {
+        EMpipe = new Textures.BlockIcons.CustomIcon("iconsets/EM_LASERMIRROR");
+        super.registerIcons(aBlockIconRegister);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, int aConnections,
+        int colorIndex, boolean aConnected, boolean aRedstone) {
+        return new ITexture[] { new GTRenderedTexture(EMpipe),
+            new GTRenderedTexture(
+                getActive() ? EMCandyActive : EMcandy,
+                Dyes.getModulation(colorIndex, MACHINE_METAL.getRGBA())) };
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.pipe.energymirror.desc.0"),
+            EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD
+                + translateToLocal("gt.blockmachines.pipe.energystream.desc.1"),
+            EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.pipe.energystream.desc.2"),
+            EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.pipe.energymirror.desc.1") };
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if ((aTick & 31) == 31) {
+                if (TecTech.RANDOM.nextInt(15) == 0) {
+                    NetworkDispatcher.INSTANCE.sendToAllAround(
+                        new PipeActivityMessage.PipeActivityData(this),
+                        aBaseMetaTileEntity.getWorld().provider.dimensionId,
+                        aBaseMetaTileEntity.getXCoord(),
+                        aBaseMetaTileEntity.getYCoord(),
+                        aBaseMetaTileEntity.getZCoord(),
+                        256);
+                }
+                if (active) {
+                    active = false;
+                }
+                mConnections = 0;
+                connectedSides[0] = null;
+                connectedSides[1] = null;
+                connectionCount = 0;
+                if (aBaseMetaTileEntity.getColorization() < 0) {
+                    return;
+                }
+                for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                    // We only allow a single bend
+                    if (connectionCount < 2) {
+                        final ForgeDirection oppositeSide = side.getOpposite();
+                        TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(side);
+                        if (tTileEntity instanceof IColoredTileEntity) {
+                            byte tColor = ((IColoredTileEntity) tTileEntity).getColorization();
+                            if (tColor != aBaseMetaTileEntity.getColorization()) {
+                                continue;
+                            }
+                        }
+                        if (tTileEntity instanceof PowerLogicHost) {
+                            PowerLogic logic = ((PowerLogicHost) tTileEntity).getPowerLogic(oppositeSide);
+                            if (logic != null && logic.canUseLaser()) {
+                                mConnections |= 1 << side.ordinal();
+                                connectedSides[connectionCount] = side;
+                                connectionCount++;
+                                continue;
+                            }
+                        }
+                        if (tTileEntity instanceof IConnectsToEnergyTunnel
+                            && ((IConnectsToEnergyTunnel) tTileEntity).canConnect(oppositeSide)) {
+                            mConnections |= 1 << side.ordinal();
+                            connectedSides[connectionCount] = side;
+                            connectionCount++;
+                        } else if (tTileEntity instanceof IGregTechTileEntity && ((IGregTechTileEntity) tTileEntity)
+                            .getMetaTileEntity() instanceof IConnectsToEnergyTunnel) {