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

16 files changed, 1250 insertions, 0 deletions

diff --git a/src/main/java/tectech/mechanics/dataTransport/DataPacket.java b/src/main/java/tectech/mechanics/dataTransport/DataPacket.java
new file mode 100644
index 0000000000..96af1f1afb
--- /dev/null
+++ b/src/main/java/tectech/mechanics/dataTransport/DataPacket.java
@@ -0,0 +1,104 @@
+package tectech.mechanics.dataTransport;
+
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+import com.gtnewhorizon.structurelib.util.Vec3Impl;
+
+/**
+ * Created by Tec on 05.04.2017.
+ */
+public abstract class DataPacket<T> {
+
+    private static final byte MAX_HISTORY = 64;
+    private final Set<Vec3Impl> trace = new LinkedHashSet<>();
+
+    protected T content;
+
+    protected DataPacket(T content) {
+        this.content = content;
+    }
+
+    protected DataPacket(NBTTagCompound nbt) {
+        content = contentFromNBT(nbt.getCompoundTag("qContent"));
+        for (int i = 0; i < nbt.getByte("qHistory"); i++) {
+            trace.add(new Vec3Impl(nbt.getInteger("qX" + i), nbt.getInteger("qY" + i), nbt.getInteger("qZ" + i)));
+        }
+    }
+
+    public final NBTTagCompound toNbt() {
+        NBTTagCompound nbt = new NBTTagCompound();
+        NBTTagCompound contentTag = contentToNBT();
+        if (contentTag != null) {
+            nbt.setTag("qContent", contentTag);
+        }
+        nbt.setByte("qHistory", (byte) trace.size());
+        int i = 0;
+        for (Vec3Impl v : trace) {
+            nbt.setInteger("qX" + i, v.get0());
+            nbt.setInteger("qY" + i, v.get1());
+            nbt.setInteger("qZ" + i, v.get2());
+            i++;
+        }
+        return nbt;
+    }
+
+    protected abstract NBTTagCompound contentToNBT();
+
+    protected abstract T contentFromNBT(NBTTagCompound nbt);
+
+    protected abstract T unifyContentWith(T content);
+
+    public final boolean contains(Vec3Impl v) {
+        return trace.contains(v);
+    }
+
+    public final boolean check() {
+        return trace.size() <= MAX_HISTORY;
+    }
+
+    public abstract boolean extraCheck();
+
+    protected final DataPacket<T> unifyTrace(Vec3Impl... positions) {
+        Collections.addAll(trace, positions);
+        return (check() && extraCheck()) ? this : null;
+    }
+
+    protected final DataPacket<T> unifyTrace(DataPacket<T> p) {
+        if (p == null) return this;
+        trace.addAll(p.trace);
+        return (check() && extraCheck()) ? this : null;
+    }
+
+    protected final DataPacket<T> unifyWith(DataPacket<T> p) {
+        if (p == null) return this;
+        trace.addAll(p.trace);
+        if (check() && extraCheck()) {
+            content = unifyContentWith(p.content);
+            return this;
+        }
+        return null;
+    }
+
+    public final T contentIfNotInTrace(Vec3Impl pos) {
+        if (trace.contains(pos)) {
+            return null;
+        }
+        return getContent();
+    }
+
+    public T getContent() {
+        return content;
+    }
+
+    public String getContentString() {
+        return content.toString();
+    }
+
+    public final int getTraceSize() {
+        return trace.size();
+    }
+}
diff --git a/src/main/java/tectech/mechanics/dataTransport/InventoryDataPacket.java b/src/main/java/tectech/mechanics/dataTransport/InventoryDataPacket.java
new file mode 100644
index 0000000000..b779a2c897
--- /dev/null
+++ b/src/main/java/tectech/mechanics/dataTransport/InventoryDataPacket.java
@@ -0,0 +1,62 @@
+package tectech.mechanics.dataTransport;
+
+import java.util.ArrayList;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+import tectech.recipe.TTRecipeAdder;
+
+public class InventoryDataPacket extends DataPacket<ItemStack[]> {
+
+    public InventoryDataPacket(ItemStack[] content) {
+        super(content);
+    }
+
+    public InventoryDataPacket(NBTTagCompound compound) {
+        super(compound);
+    }
+
+    @Override
+    protected ItemStack[] contentFromNBT(NBTTagCompound nbt) {
+        int count = nbt.getInteger("count");
+        if (count > 0) {
+            ArrayList<ItemStack> stacks = new ArrayList<>();
+            for (int i = 0; i < count; i++) {
+                ItemStack stack = ItemStack.loadItemStackFromNBT(nbt.getCompoundTag(Integer.toString(i)));
+                if (stack != null) {
+                    stacks.add(stack);
+                }
+            }
+            return stacks.size() > 0 ? stacks.toArray(TTRecipeAdder.nullItem) : null;
+        }
+        return null;
+    }
+
+    @Override
+    protected NBTTagCompound contentToNBT() {
+        NBTTagCompound compound = new NBTTagCompound();
+        if (content != null && content.length > 0) {
+            compound.setInteger("count", content.length);
+            for (int i = 0; i < content.length; i++) {
+                compound.setTag(Integer.toString(i), content[i].writeToNBT(new NBTTagCompound()));
+            }
+        }
+        return compound;
+    }
+
+    @Override
+    public boolean extraCheck() {
+        return true;
+    }
+
+    @Override
+    protected ItemStack[] unifyContentWith(ItemStack[] content) {
+        throw new NoSuchMethodError("Unavailable to unify item stack data packet");
+    }
+
+    @Override
+    public String getContentString() {
+        return "Stack Count: " + (content == null ? 0 : content.length);
+    }
+}
diff --git a/src/main/java/tectech/mechanics/dataTransport/QuantumDataPacket.java b/src/main/java/tectech/mechanics/dataTransport/QuantumDataPacket.java
new file mode 100644
index 0000000000..974831df07
--- /dev/null
+++ b/src/main/java/tectech/mechanics/dataTransport/QuantumDataPacket.java
@@ -0,0 +1,50 @@
+package tectech.mechanics.dataTransport;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+import com.gtnewhorizon.structurelib.util.Vec3Impl;
+
+public class QuantumDataPacket extends DataPacket<Long> {
+
+    public QuantumDataPacket(Long content) {
+        super(content);
+    }
+
+    public QuantumDataPacket(NBTTagCompound compound) {
+        super(compound);
+    }
+
+    @Override
+    protected Long contentFromNBT(NBTTagCompound nbt) {
+        return nbt.getLong("computation");
+    }
+
+    @Override
+    protected NBTTagCompound contentToNBT() {
+        NBTTagCompound compound = new NBTTagCompound();
+        compound.setLong("computation", content);
+        return compound;
+    }
+
+    @Override
+    public boolean extraCheck() {
+        return true;
+    }
+
+    @Override
+    protected Long unifyContentWith(Long content) {
+        return this.content + content;
+    }
+
+    public QuantumDataPacket unifyTraceWith(Vec3Impl... positions) {
+        return (QuantumDataPacket) super.unifyTrace(positions);
+    }
+
+    public QuantumDataPacket unifyTraceWith(QuantumDataPacket p) {
+        return (QuantumDataPacket) super.unifyTrace(p);
+    }
+
+    public QuantumDataPacket unifyPacketWith(QuantumDataPacket p) {
+        return (QuantumDataPacket) super.unifyWith(p);
+    }
+}
diff --git a/src/main/java/tectech/mechanics/enderStorage/EnderFluidContainer.java b/src/main/java/tectech/mechanics/enderStorage/EnderFluidContainer.java
new file mode 100644
index 0000000000..f77a5a1b51
--- /dev/null
+++ b/src/main/java/tectech/mechanics/enderStorage/EnderFluidContainer.java
@@ -0,0 +1,134 @@
+package tectech.mechanics.enderStorage;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+
+import net.minecraft.nbt.CompressedStreamTools;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+import net.minecraftforge.fluids.IFluidHandler;
+
+import tectech.TecTech;
+
+public class EnderFluidContainer implements IFluidHandler, Serializable {
+
+    private static final long serialVersionUID = 2L;
+    private static final int SERIALIZE_TYPE_WITH_NBT = 0;
+    private static final int SERIALIZE_TYPE_WITHOUT_NBT = 1;
+    private static final int SERIALIZE_TYPE_NULL = 2;
+
+    private static final int CAPACITY = 64000;
+    private transient FluidStack fluidStack;
+
+    public EnderFluidContainer() {}
+
+    private FluidStack getFluidStack() {
+        return fluidStack;
+    }
+
+    private void setFluidStack(FluidStack fluidStack) {
+        this.fluidStack = fluidStack;
+    }
+
+    @Override
+    public int fill(ForgeDirection side, FluidStack fluidStackIn, boolean doFill) {
+        int filledFluid = 0;
+        FluidStack fluidStackStored = getFluidStack();
+        if (fluidStackIn != null) {
+            if (fluidStackStored == null) {
+                fluidStackStored = fluidStackIn.copy();
+                fluidStackStored.amount = 0;
+            }
+            if (fluidStackStored.amount < CAPACITY && fluidStackIn.isFluidEqual(fluidStackStored)) {
+                filledFluid = Math.min(CAPACITY - fluidStackStored.amount, fluidStackIn.amount);
+                if (doFill) {
+                    fluidStackStored.amount += filledFluid;
+                    setFluidStack(fluidStackStored);
+                }
+            }
+        }
+        return filledFluid;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection side, FluidStack fluidStack, boolean doDrain) {
+        FluidStack fluidStackOutput = null;
+        if (fluidStack != null && fluidStack.isFluidEqual(getFluidStack())) {
+            fluidStackOutput = drain(side, fluidStack.amount, doDrain);
+        }
+        return fluidStackOutput;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection side, int amount, boolean doDrain) {
+        FluidStack fluidStackOutput = null;
+        FluidStack fluidStackStored = getFluidStack();
+        if (fluidStackStored != null && fluidStackStored.amount > 0) {
+            int drainedFluid = Math.min(fluidStackStored.amount, amount);
+            fluidStackOutput = fluidStackStored.copy();
+            fluidStackOutput.amount = drainedFluid;
+            if (doDrain) {
+                fluidStackStored.amount -= drainedFluid;
+                if (fluidStackStored.amount == 0) {
+                    fluidStackStored = null;
+                }
+                setFluidStack(fluidStackStored);
+            }
+        }
+        return fluidStackOutput;
+    }
+
+    @Override
+    public boolean canFill(ForgeDirection forgeDirection, Fluid fluid) {
+        return true;
+    }
+
+    @Override
+    public boolean canDrain(ForgeDirection forgeDirection, Fluid fluid) {
+        return true;
+    }
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection forgeDirection) {
+        return new FluidTankInfo[] { new FluidTankInfo(getFluidStack(), CAPACITY) };
+    }
+
+    private void writeObject(ObjectOutputStream out) throws IOException {
+        if (fluidStack != null) {
+            out.writeByte(fluidStack.tag != null ? SERIALIZE_TYPE_WITH_NBT : SERIALIZE_TYPE_WITHOUT_NBT);
+            if (fluidStack.tag != null) CompressedStreamTools.write(fluidStack.tag, out);
+            out.writeUTF(
+                fluidStack.getFluid()
+                    .getName());
+            out.writeInt(fluidStack.amount);
+        } else {
+            out.writeByte(SERIALIZE_TYPE_NULL);
+        }
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        byte type = in.readByte();
+        NBTTagCompound tag = null;
+        switch (type) {
+            case SERIALIZE_TYPE_WITH_NBT:
+                tag = CompressedStreamTools.read(new DataInputStream(in));
+            case SERIALIZE_TYPE_WITHOUT_NBT:
+                fluidStack = FluidRegistry.getFluidStack(in.readUTF(), in.readInt());
+                break;
+            case SERIALIZE_TYPE_NULL:
+                fluidStack = null;
+                break;
+            default:
+                TecTech.LOGGER.error("Something very wrong... got a fluid container with state " + type);
+                fluidStack = null;
+        }
+        if (fluidStack != null) fluidStack.tag = tag;
+    }
+}
diff --git a/src/main/java/tectech/mechanics/enderStorage/EnderLinkTag.java b/src/main/java/tectech/mechanics/enderStorage/EnderLinkTag.java
new file mode 100644
index 0000000000..516b7fd637
--- /dev/null
+++ b/src/main/java/tectech/mechanics/enderStorage/EnderLinkTag.java
@@ -0,0 +1,39 @@
+package tectech.mechanics.enderStorage;
+
+import java.io.Serializable;
+import java.util.UUID;
+
+import com.google.common.base.Objects;
+
+public class EnderLinkTag implements Serializable {
+
+    private static final long serialVersionUID = 6884008436570077863L;
+    private final String frequency;
+    private final UUID player;
+
+    public EnderLinkTag(String frequency, UUID player) {
+        this.frequency = frequency;
+        this.player = player;
+    }
+
+    public String getFrequency() {
+        return frequency;
+    }
+
+    public UUID getUUID() {
+        return player;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        EnderLinkTag that = (EnderLinkTag) o;
+        return Objects.equal(frequency, that.frequency) && Objects.equal(player, that.player);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(frequency, player);
+    }
+}
diff --git a/src/main/java/tectech/mechanics/enderStorage/EnderLinkTank.java b/src/main/java/tectech/mechanics/enderStorage/EnderLinkTank.java
new file mode 100644
index 0000000000..1b14c1371a
--- /dev/null
+++ b/src/main/java/tectech/mechanics/enderStorage/EnderLinkTank.java
@@ -0,0 +1,47 @@
+package tectech.mechanics.enderStorage;
+
+import java.io.Serializable;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.DimensionManager;
+import net.minecraftforge.fluids.IFluidHandler;
+
+import com.google.common.base.Objects;
+
+public class EnderLinkTank implements Serializable {
+
+    private static final long serialVersionUID = 1030297456736434221L;
+    private final int X;
+    private final int Y;
+    private final int Z;
+    private final int D;
+
+    public EnderLinkTank(IFluidHandler fluidHandler) {
+        TileEntity tile = (TileEntity) fluidHandler;
+        X = tile.xCoord;
+        Y = tile.yCoord;
+        Z = tile.zCoord;
+        D = tile.getWorldObj().provider.dimensionId;
+    }
+
+    public IFluidHandler getFluidHandler() {
+        IFluidHandler fluidHandler = null;
+        TileEntity tile = DimensionManager.getWorld(D)
+            .getTileEntity(X, Y, Z);
+        if (tile instanceof IFluidHandler) fluidHandler = (IFluidHandler) tile;
+        return fluidHandler;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        EnderLinkTank that = (EnderLinkTank) o;
+        return X == that.X && Y == that.Y && Z == that.Z && D == that.D;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(X, Y, Z, D);
+    }
+}
diff --git a/src/main/java/tectech/mechanics/enderStorage/EnderWorldSavedData.java b/src/main/java/tectech/mechanics/enderStorage/EnderWorldSavedData.java
new file mode 100644
index 0000000000..d6182794b7
--- /dev/null
+++ b/src/main/java/tectech/mechanics/enderStorage/EnderWorldSavedData.java
@@ -0,0 +1,144 @@
+package tectech.mechanics.enderStorage;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.WorldSavedData;
+import net.minecraft.world.storage.MapStorage;
+import net.minecraftforge.common.DimensionManager;
+import net.minecraftforge.event.world.WorldEvent;
+import net.minecraftforge.fluids.IFluidHandler;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import tectech.Reference;
+
+public class EnderWorldSavedData extends WorldSavedData {
+
+    private static EnderWorldSavedData INSTANCE;
+
+    private static final String DATA_NAME = Reference.MODID + "_EnderWorldSavedData";
+    private static final String ENDER_LIQUID_TAG_LINK = DATA_NAME + "_EnderLiquidTagLink";
+    private static final String ENDER_LIQUID_TANK_LINK = DATA_NAME + "_EnderLiquidTankLink";
+    private static final EnderLinkTag DEFAULT_LINK_TAG = new EnderLinkTag("", null);
+
+    private Map<EnderLinkTag, EnderFluidContainer> EnderLiquidTagLink = new HashMap<>();
+    private Map<EnderLinkTank, EnderLinkTag> EnderLiquidTankLink = new HashMap<>();
+
+    public EnderWorldSavedData() {
+        super(DATA_NAME);
+    }
+
+    public EnderWorldSavedData(String s) {
+        super(s);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void readFromNBT(NBTTagCompound nbtTagCompound) {
+        try {
+            byte[] ba = nbtTagCompound.getByteArray(ENDER_LIQUID_TAG_LINK);
+            InputStream is = new ByteArrayInputStream(ba);
+            ObjectInputStream ois = new ObjectInputStream(is);
+            Object data = ois.readObject();
+            EnderLiquidTagLink = (Map<EnderLinkTag, EnderFluidContainer>) data;
+        } catch (IOException | ClassNotFoundException ignored) {
+            System.out.println("ENDER_LIQUID_TAG_LINK LOAD FAILED");
+            System.out.println(ignored);
+        }
+
+        try {
+            byte[] ba = nbtTagCompound.getByteArray(ENDER_LIQUID_TANK_LINK);
+            InputStream is = new ByteArrayInputStream(ba);
+            ObjectInputStream ois = new ObjectInputStream(is);
+            Object data = ois.readObject();
+            EnderLiquidTankLink = (Map<EnderLinkTank, EnderLinkTag>) data;
+        } catch (IOException | ClassNotFoundException ignored) {
+            System.out.println("ENDER_LIQUID_TANK_LINK LOAD FAILED");
+            System.out.println(ignored);
+        }
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound nbtTagCompound) {
+        try {
+            ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            ObjectOutputStream oos = new ObjectOutputStream(bos);
+            oos.writeObject(EnderLiquidTagLink);
+            oos.flush();
+            byte[] data = bos.toByteArray();
+            nbtTagCompound.setByteArray(ENDER_LIQUID_TAG_LINK, data);
+        } catch (IOException ignored) {
+            System.out.println("ENDER_LIQUID_TAG_LINK SAVE FAILED");
+            System.out.println(ignored);
+        }
+
+        try {
+            ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            ObjectOutputStream oos = new ObjectOutputStream(bos);
+            oos.writeObject(EnderLiquidTankLink);
+            oos.flush();
+            byte[] data = bos.toByteArray();
+            nbtTagCompound.setByteArray(ENDER_LIQUID_TANK_LINK, data);
+        } catch (IOException ignored) {
+            System.out.println("ENDER_LIQUID_TANK_LINK SAVE FAILED");
+            System.out.println(ignored);
+        }
+    }
+
+    private static void loadInstance() {
+        if (INSTANCE == null) {
+            MapStorage storage = DimensionManager.getWorld(0).mapStorage;
+            INSTANCE = (EnderWorldSavedData) storage.loadData(EnderWorldSavedData.class, DATA_NAME);
+            if (INSTANCE == null) {
+                INSTANCE = new EnderWorldSavedData();
+                storage.setData(DATA_NAME, INSTANCE);
+            }
+        }
+        INSTANCE.markDirty();
+    }
+
+    private static Map<EnderLinkTag, EnderFluidContainer> getEnderLiquidLink() {
+        loadInstance();
+        return INSTANCE.EnderLiquidTagLink;
+    }
+
+    private static Map<EnderLinkTank, EnderLinkTag> getEnderLiquidTankLink() {
+        loadInstance();
+        return INSTANCE.EnderLiquidTankLink;
+    }
+
+    public static EnderFluidContainer getEnderFluidContainer(EnderLinkTag tag) {
+        if (!getEnderLiquidLink().containsKey(tag)) {
+            getEnderLiquidLink().put(tag, new EnderFluidContainer());
+        }
+        return getEnderLiquidLink().get(tag);
+    }
+
+    public static EnderLinkTag getEnderLinkTag(IFluidHandler handler) {
+        EnderLinkTank tank = new EnderLinkTank(handler);
+        if (!getEnderLiquidTankLink().containsKey(tank)) {
+            getEnderLiquidTankLink().put(tank, DEFAULT_LINK_TAG);
+        }
+        return getEnderLiquidTankLink().get(tank);
+    }
+
+    public static void bindEnderLinkTag(IFluidHandler handler, EnderLinkTag tag) {
+        EnderLinkTank tank = new EnderLinkTank(handler);
+        getEnderLiquidTankLink().remove(tank);
+        getEnderLiquidTankLink().put(tank, tag);
+    }
+
+    @SubscribeEvent
+    public void onWorldUnload(WorldEvent.Unload event) {
+        if (event.world.provider.dimensionId == 0) {
+            INSTANCE = null;
+        }
+    }
+}
diff --git a/src/main/java/tectech/mechanics/pipe/IActivePipe.java b/src/main/java/tectech/mechanics/pipe/IActivePipe.java
new file mode 100644
index 0000000000..e6f981d627
--- /dev/null
+++ b/src/main/java/tectech/mechanics/pipe/IActivePipe.java
@@ -0,0 +1,12 @@
+package tectech.mechanics.pipe;
+
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+
+public interface IActivePipe extends IMetaTileEntity {
+
+    void setActive(boolean active);
+
+    boolean getActive();
+
+    void markUsed();
+}
diff --git a/src/main/java/tectech/mechanics/pipe/IConnectsToDataPipe.java b/src/main/java/tectech/mechanics/pipe/IConnectsToDataPipe.java
new file mode 100644
index 0000000000..b186840a42
--- /dev/null
+++ b/src/main/java/tectech/mechanics/pipe/IConnectsToDataPipe.java
@@ -0,0 +1,17 @@
+package tectech.mechanics.pipe;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * Created by Tec on 26.02.2017.
+ */
+public interface IConnectsToDataPipe {
+
+    boolean canConnectData(ForgeDirection side);
+
+    IConnectsToDataPipe getNext(IConnectsToDataPipe source);
+
+    boolean isDataInputFacing(ForgeDirection side);
+
+    byte getColorization();
+}
diff --git a/src/main/java/tectech/mechanics/pipe/IConnectsToEnergyTunnel.java b/src/main/java/tectech/mechanics/pipe/IConnectsToEnergyTunnel.java
new file mode 100644
index 0000000000..b2381b2b69
--- /dev/null
+++ b/src/main/java/tectech/mechanics/pipe/IConnectsToEnergyTunnel.java
@@ -0,0 +1,11 @@
+package tectech.mechanics.pipe;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * Created by Tec on 26.02.2017.
+ */
+public interface IConnectsToEnergyTunnel {
+
+    boolean canConnect(ForgeDirection side);
+}
diff --git a/src/main/java/tectech/mechanics/pipe/PipeActivityMessage.java b/src/main/java/tectech/mechanics/pipe/PipeActivityMessage.java
new file mode 100644
index 0000000000..d6b3717eb5
--- /dev/null
+++ b/src/main/java/tectech/mechanics/pipe/PipeActivityMessage.java
@@ -0,0 +1,136 @@
+package tectech.mechanics.pipe;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+
+import cpw.mods.fml.common.network.ByteBufUtils;
+import cpw.mods.fml.common.network.simpleimpl.IMessage;
+import cpw.mods.fml.common.network.simpleimpl.MessageContext;
+import eu.usrv.yamcore.network.client.AbstractClientMessageHandler;
+import eu.usrv.yamcore.network.server.AbstractServerMessageHandler;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import io.netty.buffer.ByteBuf;
+
+public class PipeActivityMessage implements IMessage {
+
+    int mPosX;
+    int mPosY;
+    int mPosZ;
+    int mPosD;
+    int mActive;
+
+    public PipeActivityMessage() {}
+
+    private PipeActivityMessage(IActivePipe metaTile) {
+        IGregTechTileEntity base = metaTile.getBaseMetaTileEntity();
+        mPosX = base.getXCoord();
+        mPosY = base.getYCoord();
+        mPosZ = base.getZCoord();
+        mPosD = base.getWorld().provider.dimensionId;
+        mActive = metaTile.getActive() ? 1 : 0;
+    }
+
+    private PipeActivityMessage(World world, int x, int y, int z, boolean active) {
+        mPosX = x;
+        mPosY = y;
+        mPosZ = z;
+        mPosD = world.provider.dimensionId;
+        mActive = active ? 1 : 0;
+    }
+
+    @Override
+    public void fromBytes(ByteBuf pBuffer) {
+        NBTTagCompound tTag = ByteBufUtils.readTag(pBuffer);
+        mPosX = tTag.getInteger("posx");
+        mPosY = tTag.getInteger("posy");
+        mPosZ = tTag.getInteger("posz");
+        mPosD = tTag.getInteger("posd");
+        mActive = tTag.getInteger("active");
+    }
+
+    @Override
+    public void toBytes(ByteBuf pBuffer) {
+        NBTTagCompound tFXTag = new NBTTagCompound();
+        tFXTag.setInteger("posx", mPosX);
+        tFXTag.setInteger("posy", mPosY);
+        tFXTag.setInteger("posz", mPosZ);
+        tFXTag.setInteger("posd", mPosD);
+        tFXTag.setInteger("active", mActive);
+
+        ByteBufUtils.writeTag(pBuffer, tFXTag);
+    }
+
+    public static class PipeActivityQuery extends PipeActivityMessage {
+
+        public PipeActivityQuery() {}
+
+        public PipeActivityQuery(IActivePipe metaTile) {
+            super(metaTile);
+        }
+
+        public PipeActivityQuery(World world, int x, int y, int z, boolean active) {
+            super(world, x, y, z, active);
+        }
+    }
+
+    public static class PipeActivityData extends PipeActivityMessage {
+
+        public PipeActivityData() {}
+
+        private PipeActivityData(PipeActivityQuery query) {
+            mPosX = query.mPosX;
+            mPosY = query.mPosY;
+            mPosZ = query.mPosZ;
+            mPosD = query.mPosD;
+            mActive = query.mActive;
+        }
+
+        public PipeActivityData(IActivePipe metaTile) {
+            super(metaTile);
+        }
+
+        public PipeActivityData(World world, int x, int y, int z, boolean active) {
+            super(world, x, y, z, active);
+        }
+    }
+
+    public static class ClientHandler extends AbstractClientMessageHandler<PipeActivityData> {
+
+        @Override
+        public IMessage handleClientMessage(EntityPlayer pPlayer, PipeActivityData pMessage, MessageContext pCtx) {
+            if (pPlayer.worldObj.provider.dimensionId == pMessage.mPosD) {
+                TileEntity te = pPlayer.worldObj.getTileEntity(pMessage.mPosX, pMessage.mPosY, pMessage.mPosZ);
+                if (te instanceof IGregTechTileEntity) {
+                    IMetaTileEntity meta = ((IGregTechTileEntity) te).getMetaTileEntity();
+                    if (meta instanceof IActivePipe) {
+                        ((IActivePipe) meta).setActive(pMessage.mActive == 1);
+                    }
+                }
+            }
+            return null;
+        }
+    }
+
+    public static class ServerHandler extends AbstractServerMessageHandler<PipeActivityQuery> {
+
+        @Override
+        public IMessage handleServerMessage(EntityPlayer pPlayer, PipeActivityQuery pMessage, MessageContext pCtx) {
+            World world = DimensionManager.getWorld(pMessage.mPosD);
+            if (world != null) {
+                TileEntity te = world.getTileEntity(pMessage.mPosX, pMessage.mPosY, pMessage.mPosZ);
+                if (te instanceof IGregTechTileEntity) {
+                    IMetaTileEntity meta = ((IGregTechTileEntity) te).getMetaTileEntity();
+                    if (meta instanceof IActivePipe) {
+                        pMessage.mActive = ((IActivePipe) meta).getActive() ? 1 : 0;
+                        return new PipeActivityData(pMessage);
+                    }
+                }
+            }
+            return null;
+        }
+    }
+}
diff --git a/src/main/java/tectech/mechanics/spark/RendererMessage.java b/src/main/java/tectech/mechanics/spark/RendererMessage.java
new file mode 100644
index 0000000000..6c52e43b0d
--- /dev/null
+++ b/src/main/java/tectech/mechanics/spark/RendererMessage.java
@@ -0,0 +1,148 @@
+package tectech.mechanics.spark;
+
+import static gregtech.api.enums.Mods.Thaumcraft;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamClass;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Random;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
+
+import org.apache.logging.log4j.LogManager;
+i