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

23 files changed, 4647 insertions, 0 deletions

diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCapacitor.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCapacitor.java
new file mode 100644
index 0000000000..d3cfb21c29
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCapacitor.java
@@ -0,0 +1,241 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static gregtech.api.enums.GTValues.V;
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.internal.wrapper.BaseSlot;
+import com.gtnewhorizons.modularui.common.widget.SlotGroup;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.modularui.GTUIInfos;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.modularui.IAddUIWidgets;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import gregtech.api.objects.GTRenderedTexture;
+import tectech.Reference;
+import tectech.TecTech;
+import tectech.loader.TecTechConfig;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by Tec on 03.04.2017.
+ */
+public class MTEHatchCapacitor extends MTEHatch implements IAddUIWidgets {
+
+    private static Textures.BlockIcons.CustomIcon TM_H;
+    private static Textures.BlockIcons.CustomIcon TM_H_ACTIVE;
+    private static final Map<String, MTEHatchCapacitor.CapacitorComponent> componentBinds = new HashMap<>();
+
+    public MTEHatchCapacitor(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            16,
+            new String[] { CommonValues.THETA_MOVEMENT, translateToLocal("gt.blockmachines.hatch.capacitor.desc.0"),
+                EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.capacitor.desc.1") });
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchCapacitor(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 16, aDescription, aTextures);
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 1;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {
+        super.registerIcons(aBlockIconRegister);
+        TM_H_ACTIVE = new Textures.BlockIcons.CustomIcon("iconsets/TM_TESLA_CAPS_ACTIVE");
+        TM_H = new Textures.BlockIcons.CustomIcon("iconsets/TM_TESLA_CAPS");
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(TM_H_ACTIVE) };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(TM_H) };
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchCapacitor(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return true;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return side == aBaseMetaTileEntity.getFrontFacing();
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return side == aBaseMetaTileEntity.getFrontFacing();
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
+        return true;
+    }
+
+    @Override
+    public int getSizeInventory() {
+        return getBaseMetaTileEntity().isActive() ? 0 : mInventory.length;
+    }
+
+    public long[] getCapacitors() {
+        long tier = -1;
+        long tCurrent = 0;
+        long tEnergyMax = 0;
+        for (int i = 0; i < mInventory.length; i++) {
+            if (mInventory[i] == null || mInventory[i].stackSize != 1) {
+                continue;
+            }
+            CapacitorComponent cap = componentBinds.get(TTUtility.getUniqueIdentifier(mInventory[i]));
+            if (cap != null && cap.tier > tier) {
+                tier = cap.tier;
+            }
+        }
+        if (tier >= 0) {
+            for (int i = 0; i < mInventory.length; i++) {
+                if (mInventory[i] == null || mInventory[i].stackSize != 1) {
+                    continue;
+                }
+                CapacitorComponent cap = componentBinds.get(TTUtility.getUniqueIdentifier(mInventory[i]));
+                if (cap == null) {
+                    continue;
+                }
+                if (cap.tier < tier) {
+                    if (getBaseMetaTileEntity().isActive()) {
+                        mInventory[i] = null;
+                        getBaseMetaTileEntity().setOnFire();
+                    }
+                } else {
+                    tCurrent += cap.current;
+                    tEnergyMax += cap.energyMax;
+                }
+            }
+        }
+        return new long[] { tier, tCurrent, tEnergyMax };
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        builder.widget(
+            SlotGroup.ofItemHandler(inventoryHandler, 4)
+                .startFromSlot(0)
+                .endAtSlot(15)
+                .slotCreator(index -> new BaseSlot(inventoryHandler, index) {
+
+                    @Override
+                    public int getSlotStackLimit() {
+                        return 1;
+                    }
+
+                    @Override
+                    public boolean isEnabled() {
+                        return !getBaseMetaTileEntity().isActive();
+                    }
+                })
+                .background(getGUITextureSet().getItemSlot())
+                .build()
+                .setPos(52, 7));
+    }
+
+    public static void run() {
+        new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.0", 0, 1, V[1] * 512); // LV
+                                                                                                                       // Capacitor
+        new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.1", 1, 1, V[2] * 512); // MV
+                                                                                                                       // Capacitor
+        new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.2", 2, 1, V[3] * 512); // HV
+                                                                                                                       // Capacitor
+        new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.3", 3, 1, V[4] * 512); // EV
+                                                                                                                       // Capacitor
+        new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.4", 4, 1, V[5] * 512); // IV
+                                                                                                                       // Capacitor
+        new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.5", 5, 1, V[6] * 512); // LuV
+                                                                                                                       // Capacitor
+        new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.6", 6, 1, V[7] * 512); // ZPM
+                                                                                                                       // Capacitor
+    }
+
+    public static class CapacitorComponent implements Comparable<MTEHatchCapacitor.CapacitorComponent> {
+
+        private final String unlocalizedName;
+        private final long tier, current, energyMax;
+
+        CapacitorComponent(ItemStack is, long tier, long current, long energyMax) {
+            this(TTUtility.getUniqueIdentifier(is), tier, current, energyMax);
+        }
+
+        CapacitorComponent(String is, long tier, long current, long energyMax) {
+            unlocalizedName = is;
+            this.tier = tier;
+            this.current = current;
+            this.energyMax = energyMax;
+            componentBinds.put(unlocalizedName, this);
+            if (TecTechConfig.DEBUG_MODE) {
+                TecTech.LOGGER.info("Tesla Capacitor registered: " + unlocalizedName);
+            }
+        }
+
+        @Override
+        public int compareTo(CapacitorComponent o) {
+            return unlocalizedName.compareTo(o.unlocalizedName);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof CapacitorComponent) {
+                return compareTo((CapacitorComponent) obj) == 0;
+            }
+            return false;
+        }
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeData.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeData.java
new file mode 100644
index 0000000000..ed162e59e6
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeData.java
@@ -0,0 +1,129 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import tectech.mechanics.dataTransport.QuantumDataPacket;
+import tectech.mechanics.pipe.IConnectsToDataPipe;
+import tectech.thing.metaTileEntity.pipe.MTEPipeData;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 27.10.2016.
+ */
+public class MTEHatchCreativeData extends MTEHatchDataConnector<QuantumDataPacket> {
+
+    public MTEHatchCreativeData(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.debug.tt.data.desc.0"),
+                translateToLocal("gt.blockmachines.debug.tt.data.desc.1"),
+                EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.debug.tt.data.desc.2") });
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchCreativeData(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchCreativeData(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isInputFacing(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isDataInputFacing(ForgeDirection side) {
+        return isInputFacing(side);
+    }
+
+    @Override
+    protected QuantumDataPacket loadPacketFromNBT(NBTTagCompound nbt) {
+        return new QuantumDataPacket(nbt);
+    }
+
+    @Override
+    public boolean canConnectData(ForgeDirection side) {
+        return isOutputFacing(side);
+    }
+
+    @Override
+    public void moveAround(IGregTechTileEntity aBaseMetaTileEntity) {
+        IConnectsToDataPipe current = this, source = this, next;
+        int range = 0;
+        while ((next = current.getNext(source)) != null && range++ < 1000) {
+            if (next instanceof MTEHatchDataInput) {
+                ((MTEHatchDataInput) next).setContents(q);
+                break;
+            }
+            source = current;
+            current = next;
+        }
+        q = null;
+    }
+
+    @Override
+    public IConnectsToDataPipe getNext(IConnectsToDataPipe source /* ==this */) {
+        IGregTechTileEntity base = getBaseMetaTileEntity();
+        byte color = base.getColorization();
+        if (color < 0) {
+            return null;
+        }
+        IGregTechTileEntity next = base.getIGregTechTileEntityAtSide(base.getFrontFacing());
+        if (next == null) {
+            return null;
+        }
+        IMetaTileEntity meta = next.getMetaTileEntity();
+        if (meta instanceof MTEPipeData) {
+            ((MTEPipeData) meta).markUsed();
+            return (IConnectsToDataPipe) meta;
+        } else if (meta instanceof MTEHatchDataInput && ((MTEHatchDataInput) meta).getColorization() == color
+            && ((MTEHatchDataInput) meta).canConnectData(
+                base.getFrontFacing()
+                    .getOpposite())) {
+                        return (IConnectsToDataPipe) meta;
+                    }
+        return null;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if (CommonValues.MOVE_AT == aTick % 20) {
+                if (aBaseMetaTileEntity.isAllowedToWork()) {
+                    getBaseMetaTileEntity().setActive(true);
+                    if (q == null) q = new QuantumDataPacket(0xFFFFFFFFL);
+                    moveAround(aBaseMetaTileEntity);
+                } else {
+                    q = null;
+                    getBaseMetaTileEntity().setActive(false);
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeMaintenance.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeMaintenance.java
new file mode 100644
index 0000000000..28d631e606
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeMaintenance.java
@@ -0,0 +1,90 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+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.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatchMaintenance;
+import gregtech.api.objects.GTRenderedTexture;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+public class MTEHatchCreativeMaintenance extends MTEHatchMaintenance {
+
+    private static Textures.BlockIcons.CustomIcon face;
+
+    public MTEHatchCreativeMaintenance(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier);
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchCreativeMaintenance(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures, false);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { CommonValues.THETA_MOVEMENT,
+            translateToLocal("gt.blockmachines.debug.tt.maintenance.desc.0"), // For automatically maintaining
+                                                                              // Multiblocks
+            translateToLocal("gt.blockmachines.debug.tt.maintenance.desc.1"), // Does fix everything but itself.
+            EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.debug.tt.maintenance.desc.2") // Fixing is
+                                                                                                       // for plebs!
+        };
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {
+        super.registerIcons(aBlockIconRegister);
+        face = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_FULLAUTOMAINTENANCE");
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(face) };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(face) };
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchCreativeMaintenance(this.mName, this.mTier, this.mDescriptionArray, this.mTextures);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        this.mWrench = this.mScrewdriver = this.mSoftHammer = this.mHardHammer = this.mCrowbar = this.mSolderingTool = true;
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, ForgeDirection side,
+        float aX, float aY, float aZ) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeUncertainty.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeUncertainty.java
new file mode 100644
index 0000000000..953506e4d9
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeUncertainty.java
@@ -0,0 +1,56 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.util.EnumChatFormatting;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import tectech.util.CommonValues;
+
+public class MTEHatchCreativeUncertainty extends MTEHatchUncertainty {
+
+    public MTEHatchCreativeUncertainty(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier);
+    }
+
+    public MTEHatchCreativeUncertainty(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new MTEHatchCreativeUncertainty(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.debug.tt.certain.desc.0"), // Feeling
+                                                                                                                      // certain,
+                                                                                                                      // for
+                                                                                                                      // sure
+            EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD
+                + translateToLocal("gt.blockmachines.debug.tt.certain.desc.1") // Schrödinger's cat escaped the
+                                                                               // box
+        };
+    }
+
+    @Override
+    public void regenerate() {
+        // no-op
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide() && (aTick % 100) == 0) {
+            if (mode == 0) {
+                aBaseMetaTileEntity.setActive(false);
+                status = -128;
+            } else {
+                aBaseMetaTileEntity.setActive(true);
+                compute();
+            }
+        }
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataConnector.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataConnector.java
new file mode 100644
index 0000000000..484fcdaff1
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataConnector.java
@@ -0,0 +1,198 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static gregtech.api.enums.Dyes.MACHINE_METAL;
+import static net.minecraft.util.StatCollector.translateToLocalFormatted;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import gregtech.api.objects.GTRenderedTexture;
+import tectech.mechanics.dataTransport.DataPacket;
+import tectech.mechanics.pipe.IConnectsToDataPipe;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 11.12.2016.
+ */
+public abstract class MTEHatchDataConnector<T extends DataPacket> extends MTEHatch implements IConnectsToDataPipe {
+
+    public static Textures.BlockIcons.CustomIcon EM_D_SIDES;
+    public static Textures.BlockIcons.CustomIcon EM_D_ACTIVE;
+    public static Textures.BlockIcons.CustomIcon EM_D_CONN;
+
+    private String clientLocale = "en_US";
+
+    public T q;
+
+    public short id = -1;
+
+    protected MTEHatchDataConnector(int aID, String aName, String aNameRegional, int aTier, String[] descr) {
+        super(aID, aName, aNameRegional, aTier, 0, descr);
+        TTUtility.setTier(aTier, this);
+    }
+
+    protected MTEHatchDataConnector(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {
+        super.registerIcons(aBlockIconRegister);
+        EM_D_ACTIVE = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_EM_D_ACTIVE");
+        EM_D_SIDES = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_EM_D_SIDES");
+        EM_D_CONN = new Textures.BlockIcons.CustomIcon("iconsets/EM_DATA_CONN");
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture,
+            new GTRenderedTexture(
+                EM_D_ACTIVE,
+                Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())),
+            new GTRenderedTexture(EM_D_CONN) };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture,
+            new GTRenderedTexture(
+                EM_D_SIDES,
+                Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())),
+            new GTRenderedTexture(EM_D_CONN) };
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setShort("eID", id);
+        if (q != null) {
+            aNBT.setTag("eDATA", q.toNbt());
+        }
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        id = aNBT.getShort("eID");
+        if (aNBT.hasKey("eDATA")) {
+            q = loadPacketFromNBT(aNBT.getCompoundTag("eDATA"));
+        }
+    }
+
+    protected abstract T loadPacketFromNBT(NBTTagCompound nbt);
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if (CommonValues.MOVE_AT == aTick % 20) {
+                if (q == null) {
+                    getBaseMetaTileEntity().setActive(false);
+                } else {
+                    getBaseMetaTileEntity().setActive(true);
+                    moveAround(aBaseMetaTileEntity);
+                }
+            }
+        }
+    }
+
+    public abstract void moveAround(IGregTechTileEntity aBaseMetaTileEntity);
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) {
+            return true;
+        }
+        try {
+            EntityPlayerMP player = (EntityPlayerMP) aPlayer;
+            clientLocale = (String) FieldUtils.readField(player, "translator", true);
+        } catch (Exception e) {
+            clientLocale = "en_US";
+        }
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isLiquidInput(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean isFluidInputAllowed(FluidStack aFluid) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        if (id > 0) {
+            return new String[] {
+                translateToLocalFormatted("tt.keyword.ID", clientLocale) + ": " + EnumChatFormatting.AQUA + id,
+                translateToLocalFormatted("tt.keyword.Content", clientLocale) + ": "
+                    + EnumChatFormatting.AQUA
+                    + (q != null ? q.getContentString() : 0),
+                translateToLocalFormatted("tt.keyword.PacketHistory", clientLocale) + ": "
+                    + EnumChatFormatting.RED
+                    + (q != null ? q.getTraceSize() : 0), };
+        }
+        return new String[] {
+            translateToLocalFormatted("tt.keyword.Content", clientLocale) + ": "
+                + EnumChatFormatting.AQUA
+                + (q != null ? q.getContentString() : 0),
+            translateToLocalFormatted("tt.keyword.PacketHistory", clientLocale) + ": "
+                + EnumChatFormatting.RED
+                + (q != null ? q.getTraceSize() : 0), };
+    }
+
+    @Override
+    public byte getColorization() {
+        return getBaseMetaTileEntity().getColorization();
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataInput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataInput.java
new file mode 100644
index 0000000000..57ecd948b5
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataInput.java
@@ -0,0 +1,101 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import tectech.mechanics.dataTransport.QuantumDataPacket;
+import tectech.mechanics.pipe.IConnectsToDataPipe;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 27.10.2016.
+ */
+public class MTEHatchDataInput extends MTEHatchDataConnector<QuantumDataPacket> {
+
+    private boolean delDelay = true;
+
+    public MTEHatchDataInput(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.datain.desc.0"),
+                translateToLocal("gt.blockmachines.hatch.datain.desc.1"),
+                EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.datain.desc.2") });
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchDataInput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchDataInput(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    protected QuantumDataPacket loadPacketFromNBT(NBTTagCompound nbt) {
+        return new QuantumDataPacket(nbt);
+    }
+
+    @Override
+    public boolean isInputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isDataInputFacing(ForgeDirection side) {
+        return isInputFacing(side);
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean canConnectData(ForgeDirection side) {
+        return isInputFacing(side);
+    }
+
+    @Override
+    public IConnectsToDataPipe getNext(IConnectsToDataPipe source) {
+        return null;
+    }
+
+    public void setContents(QuantumDataPacket qIn) {
+        if (qIn == null) {
+            this.q = null;
+        } else {
+            if (qIn.getContent() > 0) {
+                this.q = qIn;
+                delDelay = true;
+            } else {
+                this.q = null;
+            }
+        }
+    }
+
+    @Override
+    public void moveAround(IGregTechTileEntity aBaseMetaTileEntity) {
+        if (delDelay) {
+            delDelay = false;
+        } else {
+            setContents(null);
+        }
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsInput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsInput.java
new file mode 100644
index 0000000000..533c9cb695
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsInput.java
@@ -0,0 +1,255 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static gregtech.api.enums.Dyes.MACHINE_METAL;
+import static net.minecraft.util.StatCollector.translateToLocal;
+import static net.minecraft.util.StatCollector.translateToLocalFormatted;
+import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_ACTIVE;
+import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_CONN;
+import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_SIDES;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import gregtech.api.enums.Dyes;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatchDataAccess;
+import gregtech.api.objects.GTRenderedTexture;
+import tectech.mechanics.dataTransport.InventoryDataPacket;
+import tectech.mechanics.pipe.IConnectsToDataPipe;
+import tectech.recipe.TTRecipeAdder;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+public class MTEHatchDataItemsInput extends MTEHatchDataAccess implements IConnectsToDataPipe {
+
+    public boolean delDelay = true;
+    private ItemStack[] stacks;
+
+    private String clientLocale = "en_US";
+
+    public MTEHatchDataItemsInput(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier);
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchDataItemsInput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture,
+            new GTRenderedTexture(
+                EM_D_ACTIVE,
+                Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())),
+            new GTRenderedTexture(EM_D_CONN) };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture,
+            new GTRenderedTexture(
+                EM_D_SIDES,
+                Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())),
+            new GTRenderedTexture(EM_D_CONN) };
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchDataItemsInput(this.mName, this.mTier, mDescriptionArray, this.mTextures);
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) {
+            return true;
+        }
+        try {
+            EntityPlayerMP player = (EntityPlayerMP) aPlayer;
+            clientLocale = (String) FieldUtils.readField(player, "translator", true);
+        } catch (Exception e) {
+            clientLocale = "en_US";
+        }
+        return true;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 1;
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean isInputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isDataInputFacing(ForgeDirection side) {
+        return isInputFacing(side);
+    }
+
+    @Override
+    public boolean canConnectData(ForgeDirection side) {
+        return isInputFacing(side);
+    }
+
+    @Override
+    public IConnectsToDataPipe getNext(IConnectsToDataPipe source) {
+        return null;
+    }
+
+    public void setContents(InventoryDataPacket iIn) {
+        if (iIn == null) {
+            stacks = null;
+        } else {
+            if (iIn.getContent().length > 0) {
+                stacks = iIn.getContent();
+                delDelay = true;
+            } else {
+                stacks = null;
+            }
+        }
+    }
+
+    @Override
+    public void onRemoval() {
+        stacks = null;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        NBTTagCompound stacksTag = new NBTTagCompound();
+        if (stacks != null) {
+            stacksTag.setInteger("count", stacks.length);
+            for (int i = 0; i < stacks.length; i++) {
+                stacksTag.setTag(Integer.toString(i), stacks[i].writeToNBT(new NBTTagCompound()));
+            }
+        }
+        aNBT.setTag("data_stacks", stacksTag);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        NBTTagCompound stacksTag = aNBT.getCompoundTag("data_stacks");
+        int count = stacksTag.getInteger("count");
+        if (count > 0) {
+            ArrayList<ItemStack> stacks = new ArrayList<>();
+            for (int i = 0; i < count; i++) {
+                ItemStack stack = ItemStack.loadItemStackFromNBT(stacksTag.getCompoundTag(Integer.toString(i)));
+                if (stack != null) {
+                    stacks.add(stack);
+                }
+            }
+            if (stacks.size() > 0) {
+                this.stacks = stacks.toArray(TTRecipeAdder.nullItem);
+            }
+        }
+    }
+
+    @Override
+    public int getSizeInventory() {
+        return stacks != null ? stacks.length : 0;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int aIndex) {
+        return stacks != null && aIndex < stacks.length ? stacks[aIndex] : null;
+    }
+
+    @Override
+    public List<ItemStack> getInventoryItems(Predicate<ItemStack> filter) {
+        if (stacks == null) return Collections.emptyList();
+        return Arrays.stream(stacks)
+            .filter(stack -> stack != null && filter.test(stack))
+            .collect(Collectors.toList());
+    }
+
+    @Override
+    public boolean shouldDropItemAt(int index) {
+        return false;
+    }
+
+    @Override
+    public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPreTick(aBaseMetaTileEntity, aTick);
+        if (CommonValues.MOVE_AT == aTick % 20) {
+            if (stacks == null) {
+                getBaseMetaTileEntity().setActive(false);
+            } else {
+                getBaseMetaTileEntity().setActive(true);
+                if (delDelay) {
+                    delDelay = false;
+                } else {
+                    setContents(null);
+                }
+            }
+        }
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.datainass.desc.0"),
+            translateToLocal("gt.blockmachines.hatch.datainass.desc.1"),
+            EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.datainass.desc.2") };
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[] { translateToLocalFormatted("tt.keyphrase.Content_Stack_Count", clientLocale) + ": "
+            + (stacks == null ? 0 : stacks.length) };
+    }
+
+    @Override
+    public byte getColorization() {
+        return getBaseMetaTileEntity().getColorization();
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsOutput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsOutput.java
new file mode 100644
index 0000000000..8a2c005fec
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsOutput.java
@@ -0,0 +1,133 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import tectech.mechanics.dataTransport.InventoryDataPacket;
+import tectech.mechanics.pipe.IConnectsToDataPipe;
+import tectech.thing.metaTileEntity.pipe.MTEPipeData;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+public class MTEHatchDataItemsOutput extends MTEHatchDataConnector<InventoryDataPacket> {
+
+    public MTEHatchDataItemsOutput(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.dataoutass.desc.0"),
+                translateToLocal("gt.blockmachines.hatch.dataoutass.desc.1"),
+                EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.dataoutass.desc.2") });
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchDataItemsOutput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchDataItemsOutput(this.mName, this.mTier, this.mDescriptionArray, this.mTextures);
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 1;
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isInputFacing(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    protected InventoryDataPacket loadPacketFromNBT(NBTTagCompound nbt) {
+        return new InventoryDataPacket(nbt);
+    }
+
+    @Override
+    public boolean isDataInputFacing(ForgeDirection side) {
+        return isInputFacing(side);
+    }
+
+    @Override
+    public boolean canConnectData(ForgeDirection side) {
+        return isOutputFacing(side);
+    }
+
+    @Override
+    public void moveAround(IGregTechTileEntity aBaseMetaTileEntity) {
+        IConnectsToDataPipe current = this, source = this, next;
+        int range = 0;
+        while ((next = current.getNext(source)) != null && range++ < 1000) {
+            if (next instanceof MTEHatchDataItemsInput) {
+                ((MTEHatchDataItemsInput) next).setContents(q);
+                break;
+            }
+            source = current;
+            current = next;
+        }
+        q = null;
+    }
+
+    @Override
+    public IConnectsToDataPipe getNext(IConnectsToDataPipe source /* ==this */) {
+        IGregTechTileEntity base = getBaseMetaTileEntity();
+        byte color = base.getColorization();
+        if (color < 0) {
+            return null;
+        }
+        IGregTechTileEntity next = base.getIGregTechTileEntityAtSide(base.getFrontFacing());
+        if (next == null) {
+            return null;
+        }
+        IMetaTileEntity meta = next.getMetaTileEntity();
+        if (meta instanceof MTEPipeData) {
+            ((MTEPipeData) meta).markUsed();
+            return (IConnectsToDataPipe) meta;
+        } else if (meta instanceof MTEHatchDataItemsInput && ((MTEHatchDataItemsInput) meta).getColorization() == color
+            && ((MTEHatchDataItemsInput) meta).canConnectData(
+                base.getFrontFacing()
+                    .getOpposite())) {
+                        return (IConnectsToDataPipe) meta;
+                    }
+        return null;
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataOutput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataOutput.java
new file mode 100644
index 0000000000..094423cb0a
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataOutput.java
@@ -0,0 +1,113 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import tectech.mechanics.dataTransport.QuantumDataPacket;
+import tectech.mechanics.pipe.IConnectsToDataPipe;
+import tectech.thing.metaTileEntity.pipe.MTEPipeData;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 27.10.2016.
+ */
+public class MTEHatchDataOutput extends MTEHatchDataConnector<QuantumDataPacket> {
+
+    public MTEHatchDataOutput(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.dataout.desc.0"),
+                translateToLocal("gt.blockmachines.hatch.dataout.desc.1"),
+                EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.dataout.desc.2") });
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchDataOutput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchDataOutput(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isInputFacing(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isDataInputFacing(ForgeDirection side) {
+        return isInputFacing(side);
+    }
+
+    @Override
+    protected QuantumDataPacket loadPacketFromNBT(NBTTagCompound nbt) {
+        return new QuantumDataPacket(nbt);
+    }
+
+    @Override
+    public boolean canConnectData(ForgeDirection side) {
+        return isOutputFacing(side);
+    }
+
+    @Override
+    public void moveAround(IGregTechTileEntity aBaseMetaTileEntity) {
+        IConnectsToDataPipe current = this, source = this, next;
+        int range = 0;
+        while ((next = current.getNext(source)) != null && range++ < 1000) {
+            if (next instanceof MTEHatchDataInput) {
+                ((MTEHatchDataInput) next).setContents(q);
+                break;
+            }
+            source = current;
+            current = next;
+        }
+        q = null;
+    }
+
+    @Override
+    public IConnectsToDataPipe getNext(IConnectsToDataPipe source /* ==this */) {
+        IGregTechTileEntity base = getBaseMetaTileEntity();
+        byte color = base.getColorization();
+        if (color < 0) {
+            return null;
+        }
+        IGregTechTileEntity next = base.getIGregTechTileEntityAtSide(base.getFrontFacing());
+        if (next == null) {
+            return null;
+        }
+        IMetaTileEntity meta = next.getMetaTileEntity();
+        if (meta instanceof MTEPipeData) {
+            ((MTEPipeData) meta).markUsed();
+            return (IConnectsToDataPipe) meta;
+        } else if (meta instanceof MTEHatchDataInput && ((MTEHatchDataInput) meta).getColorization() == color
+            && ((MTEHatchDataInput) meta).canConnectData(
+                base.getFrontFacing()
+                    .getOpposite())) {
+                        return (IConnectsToDataPipe) meta;
+                    }
+        return null;
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoMulti.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoMulti.java
new file mode 100644
index 0000000000..e5f457ccc2
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoMulti.java
@@ -0,0 +1,127 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static gregtech.api.enums.GTValues.V;
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import tectech.thing.metaTileEntity.Textures;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 16.12.2016.
+ */
+public class MTEHatchDynamoMulti extends MTEHatch {
+
+    public final int maxAmperes;
+    public int Amperes;
+
+    public MTEHatchDynamoMulti(int aID, String aName, String aNameRegional, int aTier, int aAmp) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            0,
+            new String[] { CommonValues.TEC_MARK_GENERAL,
+                translateToLocal("gt.blockmachines.hatch.dynamomulti.desc.0") }); // Multiple Ampere Energy
+                                                                                  // Extractor for Multiblocks
+        Amperes = maxAmperes = aAmp;
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchDynamoMulti(String aName, int aTier, int aAmp, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+        Amperes = maxAmperes = aAmp;
+    }
+
+    public MTEHatchDynamoMulti(int aID, String aName, String aNameRegional, int aTier, int i, String[] description,
+        int aAmp) {
+        super(aID, aName, aNameRegional, aTier, 0, description);
+        Amperes = maxAmperes = aAmp;
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier] };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier] };
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isEnetOutput() {
+        return true;
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public long getMinimumStoredEU() {
+        return 128L * Amperes;
+    }
+
+    @Override
+    public long maxEUOutput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxEUStore() {
+        return 512L + V[mTier] * 4L * Amperes;
+    }
+
+    @Override
+    public long maxAmperesOut() {
+        return Amperes;
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchDynamoMulti(mName, mTier, Amperes, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoTunnel.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoTunnel.java
new file mode 100644
index 0000000000..2a72fb31f2
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoTunnel.java
@@ -0,0 +1,286 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static gregtech.api.enums.GTValues.V;
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+import com.gtnewhorizons.modularui.common.widget.textfield.NumericWidget;
+
+import gregtech.api.gui.modularui.GTUIInfos;
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.PowerLogic;
+import gregtech.api.logic.interfaces.PowerLogicHost;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.util.GTUtility;
+import tectech.mechanics.pipe.IConnectsToEnergyTunnel;
+import tectech.thing.metaTileEntity.Textures;
+import tectech.thing.metaTileEntity.pipe.MTEPipeEnergy;
+import tectech.thing.metaTileEntity.pipe.MTEPipeEnergyMirror;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 16.12.2016.
+ */
+public class MTEHatchDynamoTunnel extends MTEHatchDynamoMulti implements IConnectsToEnergyTunnel {
+
+    public MTEHatchDynamoTunnel(int ID, String unlocalisedName, String localisedName, int tier, int amps) {
+        super(
+            ID,
+            unlocalisedName,
+            localisedName,
+            tier,
+            0,
+            new String[] { CommonValues.TEC_MARK_GENERAL,
+                translateToLocal("gt.blockmachines.hatch.dynamotunnel.desc.0"),
+                translateToLocal("gt.blockmachines.hatch.dynamotunnel.desc.1") + ": "
+                    + EnumChatFormatting.YELLOW
+                    + GTUtility.formatNumbers(amps * V[tier])
+                    + EnumChatFormatting.RESET
+                    + " EU/t" },
+            amps);
+
+        TTUtility.setTier(tier, this);
+    }
+
+    public MTEHatchDynamoTunnel(String aName, int aTier, int aAmp, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aAmp, aDescription, aTextures);
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_OUT_LASER_TT[mTier] };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_OUT_LASER_TT[mTier] };
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public long getMinimumStoredEU() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxEUOutput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxEUStore() {
+        return V[mTier] * 24L * Amperes;
+    }
+
+    @Override
+    public boolean isEnetOutput() {
+        return false;
+    }
+
+    @Override
+    public boolean isEnetInput() {
+        return false;
+    }
+
+    @Override
+    public ConnectionType getConnectionType() {
+        return ConnectionType.LASER;
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchDynamoTunnel(mName, mTier, Amperes, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            byte Tick = (byte) (aTick % 20);
+            if (CommonValues.TRANSFER_AT == Tick) {
+                if (aBaseMetaTileEntity.getStoredEU() > 0) {
+                    setEUVar(aBaseMetaTileEntity.getStoredEU() - Amperes);
+                    if (aBaseMetaTileEntity.getStoredEU() < 0) {
+                        setEUVar(0);
+                    }
+                }
+                if (aBaseMetaTileEntity.getStoredEU() > getMinimumStoredEU()) {
+                    moveAround(aBaseMetaTileEntity);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        if (Amperes != maxAmperes) {
+            aNBT.setInteger("amperes", Amperes);
+        }
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        int savedAmperes = aNBT.getInteger("amperes");
+        if (savedAmperes != 0) {
+            Amperes = savedAmperes;
+        }
+    }
+
+    private void moveAround(IGregTechTileEntity aBaseMetaTileEntity) {
+        byte color = getBaseMetaTileEntity().getColorization();
+        if (color < 0) {
+            return;
+        }
+        final ForgeDirection front = aBaseMetaTileEntity.getFrontFacing();
+        ForgeDirection opposite = front.getOpposite();
+        for (short dist = 1; dist < 1000; dist++) {
+
+            IGregTechTileEntity tGTTileEntity = aBaseMetaTileEntity
+                .getIGregTechTileEntityAtSideAndDistance(front, dist);
+            if (tGTTileEntity != null && tGTTileEntity.getColorization() == color) {
+                IMetaTileEntity aMetaTileEntity = tGTTileEntity.getMetaTileEntity();
+                if (aMetaTileEntity != null) {
+                    // If we hit a mirror, use the mirror's view instead
+                    if (aMetaTileEntity instanceof MTEPipeEnergyMirror tMirror) {
+
+                        tGTTileEntity = tMirror.bendAround(opposite);
+                        if (tGTTileEntity == null) {
+                            break;
+                        } else {
+                            aMetaTileEntity = tGTTileEntity.getMetaTileEntity();
+                            opposite = tMirror.getChainedFrontFacing();
+                        }
+                    }
+
+                    if (aMetaTileEntity instanceof MTEHatchEnergyTunnel && opposite == tGTTileEntity.getFrontFacing()) {
+                        if (maxEUOutput() > ((MTEHatchEnergyTunnel) aMetaTileEntity).maxEUInput()) {
+                            aMetaTileEntity.doExplosion(maxEUOutput());
+                            setEUVar(aBaseMetaTileEntity.getStoredEU() - maxEUOutput());
+                            return;
+                        } else if (maxEUOutput() == ((MTEHatchEnergyTunnel) aMetaTileEntity).maxEUInput()) {
+                            long diff = Math.min(
+                                Amperes * 20L * maxEUOutput(),
+                                Math.min(
+                                    ((MTEHatchEnergyTunnel) aMetaTileEntity).maxEUStore()
+                                        - aMetaTileEntity.getBaseMetaTileEntity()
+                                            .getStoredEU(),
+                                    aBaseMetaTileEntity.getStoredEU()));
+
+                            setEUVar(aBaseMetaTileEntity.getStoredEU() - diff);
+
+                            ((MTEHatchEnergyTunnel) aMetaTileEntity).setEUVar(
+                                aMetaTileEntity.getBaseMetaTileEntity()
+                                    .getStoredEU() + diff);
+                        }
+                        return;
+                    } else if (aMetaTileEntity instanceof MTEPipeEnergy) {
+                        if (((MTEPipeEnergy) aMetaTileEntity).connectionCount < 2) {
+                            return;
+                        } else {
+                            ((MTEPipeEnergy) aMetaTileEntity).markUsed();
+                        }
+                    } else {
+                        return;
+                    }
+                } else {
+                    if (tGTTileEntity instanceof PowerLogicHost) {
+                        PowerLogic logic = ((PowerLogicHost) tGTTileEntity).getPowerLogic(opposite);
+                        if (logic == null || !logic.canUseLaser() || opposite != tGTTileEntity.getFrontFacing()) {
+                            return;
+                        }
+
+                        long ampsUsed = logic.injectEnergy(maxEUOutput(), Amperes);
+                        setEUVar(aBaseMetaTileEntity.getStoredEU() - ampsUsed * maxEUOutput());
+                    }
+                    return;
+                }
+            } else {
+                return;
+            }
+        }
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
+        return true;
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        builder.setBackground(GTUITextures.BACKGROUND_SINGLEBLOCK_DEFAULT);
+        builder.setGuiTint(getGUIColorization());
+        final int x = getGUIWidth() / 2 - 37;
+        final int y = getGUIHeight() / 5 - 7;
+        builder.widget(
+            TextWidget.localised("GT5U.machines.laser_hatch.amperage")
+                .setPos(x, y)
+                .setSize(74, 14))
+            .widget(
+                new NumericWidget().setSetter(val -> Amperes = (int) val)
+                    .setGetter(() -> Amperes)
+                    .setBounds(1, maxAmperes)
+                    .setScrollValues(1, 4, 64)
+                    .setTextAlignment(Alignment.Center)
+                    .setTextColor(Color.WHITE.normal)
+                    .setSize(70, 18)
+                    .setPos(x, y + 16)
+                    .setBackground(GTUITextures.BACKGROUND_TEXT_FIELD));
+    }
+
+    @Override
+    public boolean canConnect(ForgeDirection side) {
+        return isOutputFacing(side);
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchEnergyMulti.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchEnergyMulti.java
new file mode 100644
index 0000000000..12112b0290
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchEnergyMulti.java
@@ -0,0 +1,133 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static gregtech.api.enums.GTValues.V;
+import static net.minecraft.util.StatCollector.translateToLocal;
+import static net.minecraft.util.StatCollector.translateToLocalFormatted;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import tectech.thing.metaTileEntity.Textures;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 16.12.2016.
+ */
+public class MTEHatchEnergyMulti extends MTEHatch {
+
+    public final int maxAmperes;
+    public int Amperes;
+
+    public MTEHatchEnergyMulti(int aID, String aName, String aNameRegional, int aTier, int aAmp) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            0,
+            new String[] { CommonValues.TEC_MARK_GENERAL, translateToLocal("gt.blockmachines.hatch.energymulti.desc.0"),
+                translateToLocalFormatted("gt.blockmachines.hatch.energymulti.desc.2", aAmp + (aAmp >> 2)),
+                translateToLocalFormatted("gt.blockmachines.hatch.energymulti.desc.3", aAmp) });
+        Amperes = maxAmperes = aAmp;
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchEnergyMulti(String aName, int aTier, int aAmp, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+        Amperes = maxAmperes = aAmp;
+    }
+
+    public MTEHatchEnergyMulti(int aID, String aName, String aNameRegional, int aTier, int i, String[] description,
+        int aAmp) {
+        super(aID, aName, aNameRegional, aTier, 0, description);
+        Amperes = maxAmperes = aAmp;
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier] };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier] };
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isEnetInput() {
+        return true;
+    }
+
+    @Override
+    public boolean isInputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public long getMinimumStoredEU() {
+        return 128L * Amperes;
+    }
+
+    @Override
+    public long maxEUInput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxEUStore() {
+        return 512L + V[mTier] * 4L * Amperes;
+    }
+
+    @Override
+    public long maxAmperesIn() {
+        return Amperes + (Amperes >> 2);
+    }
+
+    @Override
+    public long maxWorkingAmperesIn() {
+        return Amperes;
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchEnergyMulti(mName, mTier, Amperes, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchEnergyTunnel.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchEnergyTunnel.java
new file mode 100644
index 0000000000..f01415606b
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchEnergyTunnel.java
@@ -0,0 +1,203 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static gregtech.api.enums.GTValues.V;
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+import com.gtnewhorizons.modularui.common.widget.textfield.NumericWidget;
+
+import gregtech.api.gui.modularui.GTUIInfos;
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.util.GTUtility;
+import tectech.mechanics.pipe.IConnectsToEnergyTunnel;
+import tectech.thing.metaTileEntity.Textures;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 16.12.2016.
+ */
+public class MTEHatchEnergyTunnel extends MTEHatchEnergyMulti implements IConnectsToEnergyTunnel {
+
+    public MTEHatchEnergyTunnel(int aID, String aName, String aNameRegional, int aTier, int aAmp) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            0,
+            new String[] { CommonValues.TEC_MARK_GENERAL,
+                translateToLocal("gt.blockmachines.hatch.energytunnel.desc.0"),
+                translateToLocal("gt.blockmachines.hatch.energytunnel.desc.1") + ": "
+                    + EnumChatFormatting.YELLOW
+                    + GTUtility.formatNumbers(aAmp * V[aTier])
+                    + EnumChatFormatting.RESET
+                    + " EU/t" },
+            aAmp); // Energy injecting terminal for Multiblocks
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchEnergyTunnel(String aName, int aTier, int aAmp, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aAmp, aDescription, aTextures);
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_IN_LASER_TT[mTier] };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_IN_LASER_TT[mTier] };
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isInputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public long getMinimumStoredEU() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxEUInput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxEUStore() {
+        return V[mTier] * 24L * Amperes;
+    }
+
+    @Override
+    public boolean isEnetOutput() {
+        return false;
+    }
+
+    @Override
+    public boolean isEnetInput() {
+        return false;
+    }
+
+    @Override
+    public ConnectionType getConnectionType() {
+        return ConnectionType.LASER;
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchEnergyTunnel(mName, mTier, Amperes, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        if (Amperes != maxAmperes) {
+            aNBT.setInteger("amperes", Amperes);
+        }
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        int savedAmperes = aNBT.getInteger("amperes");
+        if (savedAmperes != 0) {
+            Amperes = savedAmperes;
+        }
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
+        return true;
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        builder.setBackground(GTUITextures.BACKGROUND_SINGLEBLOCK_DEFAULT);
+        builder.setGuiTint(getGUIColorization());
+        final int x = getGUIWidth() / 2 - 37;
+        final int y = getGUIHeight() / 5 - 7;
+        builder.widget(
+            TextWidget.localised("GT5U.machines.laser_hatch.amperage")
+                .setPos(x, y)
+                .setSize(74, 14))
+            .widget(
+                new NumericWidget().setSetter(val -> Amperes = (int) val)
+                    .setGetter(() -> Amperes)
+                    .setBounds(1, maxAmperes)
+                    .setScrollValues(1, 4, 64)
+                    .setTextAlignment(Alignment.Center)
+                    .setTextColor(Color.WHITE.normal)
+                    .setSize(70, 18)
+                    .setPos(x, y + 16)
+                    .setBackground(GTUITextures.BACKGROUND_TEXT_FIELD));
+    }
+
+    @Override
+    public boolean canConnect(ForgeDirection side) {
+        return isInputFacing(side);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            byte Tick = (byte) (aTick % 20);
+            if (CommonValues.TRANSFER_AT == Tick) {
+                if (aBaseMetaTileEntity.getStoredEU() > 0) {
+                    setEUVar(aBaseMetaTileEntity.getStoredEU() - Amperes);
+                    if (aBaseMetaTileEntity.getStoredEU() < 0) {
+                        setEUVar(0);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchObjectHolder.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchObjectHolder.java
new file mode 100644
index 0000000000..201b54e24c
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchObjectHolder.java
@@ -0,0 +1,176 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.internal.wrapper.BaseSlot;
+import com.gtnewhorizons.modularui.common.widget.DrawableWidget;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.modularui.GTUIInfos;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.modularui.IAddGregtechLogo;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import gregtech.api.objects.GTRenderedTexture;
+import tectech.thing.gui.TecTechUITextures;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by Tec on 03.04.2017.
+ */
+public class MTEHatchObjectHolder extends MTEHatch implements IAddGregtechLogo {
+
+    private static Textures.BlockIcons.CustomIcon EM_H;
+    private static Textures.BlockIcons.CustomIcon EM_H_ACTIVE;
+
+    public MTEHatchObjectHolder(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            1,
+            new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.holder.desc.0"),
+                EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.holder.desc.1") });
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchObjectHolder(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 1, aDescription, aTextures);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {
+        super.registerIcons(aBlockIconRegister);
+        EM_H_ACTIVE = new Textures.BlockIcons.CustomIcon("iconsets/EM_HOLDER_ACTIVE");
+        EM_H = new Textures.BlockIcons.CustomIcon("iconsets/EM_HOLDER");
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(EM_H_ACTIVE) };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(EM_H) };
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchObjectHolder(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return facing.offsetY == 0;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return true;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return side == aBaseMetaTileEntity.getFrontFacing();
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return side == aBaseMetaTileEntity.getFrontFacing();
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) {
+            return true;
+        }
+        // if(aBaseMetaTileEntity.isActive())
+        // aPlayer.addChatComponentMessage(new ChatComponentText("It is still active..."));
+        // else if(heat>0)
+        // aPlayer.addChatComponentMessage(new ChatComponentText("It is still warm..."));
+        // else
+        GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
+        return true;
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 1;
+    }
+
+    @Override
+    public void addGregTechLogo(ModularWindow.Builder builder) {
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_TECTECH_LOGO)
+                .setSize(18, 18)
+                .setPos(151, 63));
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_HEAT_SINK)
+                .setPos(46, 17)
+                .setSize(84, 60))
+            .widget(
+                new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_RACK_LARGE)
+                    .setPos(68, 27)
+                    .setSize(40, 40))
+            .widget(new SlotWidget(new BaseSlot(inventoryHandler, 0) {
+
+                @Override
+                public int getSlotStackLimit() {
+                    return 1;
+                }
+
+                @Override
+                public boolean isEnabled() {
+                    return !getBaseMetaTileEntity().isActive();
+                }
+            }).setPos(79, 38))
+            .widget(
+                new DrawableWidget().setDrawable(TecTechUITextures.BUTTON_STANDARD_LIGHT_16x16)
+                    .setPos(152, 24)
+                    .setSize(16, 16))
+            .widget(
+                new DrawableWidget()
+                    .setDrawable(
+                        () -> getBaseMetaTileEntity().isActive() ? TecTechUITextures.OVERLAY_BUTTON_POWER_SWITCH_ON
+                            : TecTechUITextures.OVERLAY_BUTTON_POWER_SWITCH_DISABLED)
+                    .setPos(152, 24)
+                    .setSize(16, 16))
+            .widget(
+                new FakeSyncWidget.BooleanSyncer(
+                    () -> getBaseMetaTileEntity().isActive(),
+                    val -> getBaseMetaTileEntity().setActive(val)));
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchParam.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchParam.java
new file mode 100644
index 0000000000..259bc4d164
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchParam.java
@@ -0,0 +1,554 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static net.minecraft.util.StatCollector.translateToLocalFormatted;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.DrawableWidget;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.modularui.GTUIInfos;
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.modularui.IAddGregtechLogo;
+import gregtech.api.interfaces.modularui.IAddUIWidgets;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import gregtech.api.objects.GTRenderedTexture;
+import tectech.TecTech;
+import tectech.thing.gui.TecTechUITextures;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 15.12.2016.
+ */
+public class MTEHatchParam extends MTEHatch implements IAddGregtechLogo, IAddUIWidgets {
+
+    public int pointer = 0;
+    public int param = -1;
+    public double value0D = 0;
+    public double value1D = 0;
+    public double input0D = 0;
+    public double input1D = 0;
+    private static Textures.BlockIcons.CustomIcon ScreenON;
+    private static Textures.BlockIcons.CustomIcon ScreenOFF;
+
+    private String clientLocale = "en_US";
+
+    public MTEHatchParam(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            0,
+            new String[] { CommonValues.TEC_MARK_GENERAL,
+                EnumChatFormatting.DARK_RED
+                    + "Deprecated; Now you can set parameter by clicking LED on multiblock GUI.",
+                EnumChatFormatting.DARK_RED
+                    + "If it doesn't work, try removing Parametrizer from multiblock structure." });
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchParam(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {
+        super.registerIcons(aBlockIconRegister);
+        ScreenOFF = new Textures.BlockIcons.CustomIcon("iconsets/PARAM");
+        ScreenON = new Textures.BlockIcons.CustomIcon("iconsets/PARAM_ACTIVE");
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(ScreenON) };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(ScreenOFF) };
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new MTEHatchParam(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[] {
+            translateToLocalFormatted("tt.keyword.Parametrizer", clientLocale) + " "
+                + translateToLocalFormatted("tt.keyword.ID", clientLocale)
+                + ": "
+                + EnumChatFormatting.GREEN
+                + param,
+            translateToLocalFormatted("tt.keyword.Value", clientLocale) + " 0D: " + EnumChatFormatting.AQUA + value0D,
+            translateToLocalFormatted("tt.keyword.Value", clientLocale) + " 1D: " + EnumChatFormatting.BLUE + value1D,
+            translateToLocalFormatted("tt.keyword.Input", clientLocale) + " 0D: " + EnumChatFormatting.GOLD + input0D,
+            translateToLocalFormatted("tt.keyword.Input", clientLocale) + " 1D: "
+                + EnumChatFormatting.YELLOW
+                + input1D, };
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setInteger("ePointer", pointer);
+        aNBT.setDouble("eValue0D", value0D);
+        aNBT.setDouble("eValue1D", value1D);
+        aNBT.setDouble("eInput0D", input0D);
+        aNBT.setDouble("eInput1D", input1D);
+        aNBT.setInteger("eParam", param);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        pointer = aNBT.getInteger("ePointer");
+        if (aNBT.hasKey("eFloats") || aNBT.hasKey("eValue0i")
+            || aNBT.hasKey("eValue1i")
+            || aNBT.hasKey("eInput0i")
+            || aNBT.hasKey("eInput1i")) {
+            boolean usesFloat = aNBT.getBoolean("eFloats");
+            if (usesFloat) {
+                value0D = Double.longBitsToDouble(aNBT.getLong("eValue0i"));
+                value1D = Double.longBitsToDouble(aNBT.getLong("eValue1i"));
+                input0D = Double.longBitsToDouble(aNBT.getLong("eInput0i"));
+                input1D = Double.longBitsToDouble(aNBT.getLong("eInput1i"));
+            } else {
+                value0D = aNBT.getLong("eValue0i");
+                value1D = aNBT.getLong("eValue1i");
+                input0D = aNBT.getLong("eInput0i");
+                input1D = aNBT.getLong("eInput1i");
+            }
+        } else {
+            value0D = aNBT.getDouble("eValue0D");
+            value1D = aNBT.getDouble("eValue1D");
+            input0D = aNBT.getDouble("eInput0D");
+            input1D = aNBT.getDouble("eInput1D");
+        }
+        param = aNBT.getInteger("eParam");
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public boolean isLiquidInput(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean isFluidInputAllowed(FluidStack aFluid) {
+        return false;
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) {
+            return true;
+        }
+        try {
+            EntityPlayerMP player = (EntityPlayerMP) aPlayer;
+            clientLocale = (String) FieldUtils.readField(player, "translator", true);
+        } catch (Exception e) {
+            clientLocale = "en_US";
+        }
+        GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
+        return true;
+    }
+
+    @Override
+    public void addGregTechLogo(ModularWindow.Builder builder) {
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_TECTECH_LOGO_DARK)
+                .setSize(18, 18)
+                .setPos(112, 55));
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        final boolean isAdvanced = mTier > 5;
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.BACKGROUND_SCREEN_BLUE)
+                .setPos(43, 4)
+                .setSize(90, 72));
+
+        addChangeParamButton(
+            builder,
+            (shift, columnPointer, secondRow) -> param -= shift ? 16 : 4,
+            7,
+            4,
+            GTUITextures.OVERLAY_BUTTON_MINUS_LARGE,
+            TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_ID);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (secondRow.get()) {
+                    secondRow.set(false);
+                } else {
+                    columnPointer.addAndGet(shift ? -16 : -4);
+                }
+            } else {
+                value0D -= shift ? 4096 : 256;
+            }
+        }, 7, 22, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_0);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (secondRow.get()) {
+                    columnPointer.addAndGet(shift ? -16 : -4);
+                } else {
+                    secondRow.set(true);
+                }
+            } else {
+                value1D -= shift ? 4096 : 256;
+            }
+        }, 7, 40, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_1);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (shift) {
+                    if (secondRow.get()) {
+                        value1D = Double.longBitsToDouble(0xFFFF_FFFF_FFFF_FFFFL);
+                    } else {
+                        value0D = Double.longBitsToDouble(0xFFFF_FFFF_FFFF_FFFFL);
+                    }
+                } else {
+                    if (secondRow.get()) {
+                        long temp = Double.doubleToLongBits(value1D);
+                        temp |= 1L << (long) columnPointer.get();
+                        value1D = Double.longBitsToDouble(temp);
+                    } else {
+                        long temp = Double.doubleToLongBits(value0D);
+                        temp |= 1L << (long) columnPointer.get();
+                        value0D = Double.longBitsToDouble(temp);
+                    }
+                }
+            } else {
+                value0D /= shift ? 4096 : 256;
+                value1D /= shift ? 4096 : 256;
+            }
+        },
+            7,
+            58,
+            isAdvanced ? TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_S : GTUITextures.OVERLAY_BUTTON_MINUS_LARGE,
+            isAdvanced ? null : TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_ID);
+
+        addChangeParamButton(
+            builder,
+            (shift, columnPointer, secondRow) -> param -= shift ? 2 : 1,
+            25,
+            4,
+            GTUITextures.OVERLAY_BUTTON_MINUS_SMALL,
+            TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_ID);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (secondRow.get()) {
+                    secondRow.set(false);
+                } else {
+                    columnPointer.addAndGet(shift ? -2 : -1);
+                }
+            } else {
+                value0D -= shift ? 16 : 1;
+            }
+        }, 25, 22, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_0);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (secondRow.get()) {
+                    columnPointer.addAndGet(shift ? -2 : -1);
+                } else {
+                    secondRow.set(true);
+                }
+            } else {
+                value1D -= shift ? 16 : 1;
+            }
+        }, 25, 40, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_1);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (shift) {
+                    if (secondRow.get()) {
+                        value1D = Double.longBitsToDouble(0);
+                    } else {
+                        value0D = Double.longBitsToDouble(0);
+                    }
+                } else {
+                    if (secondRow.get()) {
+                        long temp = Double.doubleToLongBits(value1D);
+                        temp &= ~(1L << (long) columnPointer.get());
+                        value1D = Double.longBitsToDouble(temp);
+                    } else {
+                        long temp = Double.doubleToLongBits(value0D);
+                        temp &= ~(1L << (long) columnPointer.get());
+                        value0D = Double.longBitsToDouble(temp);
+                    }
+                }
+            } else {
+                value0D /= shift ? 16 : 2;
+                value1D /= shift ? 16 : 2;
+            }
+        },
+            25,
+            58,
+            isAdvanced ? TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_C : GTUITextures.OVERLAY_BUTTON_MINUS_SMALL,
+            isAdvanced ? null : TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_X);
+
+        addChangeParamButton(
+            builder,
+            (shift, columnPointer, secondRow) -> param += shift ? 2 : 1,
+            133,
+            4,
+            GTUITextures.OVERLAY_BUTTON_PLUS_SMALL,
+            TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_ID);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (secondRow.get()) {
+                    secondRow.set(false);
+                } else {
+                    columnPointer.addAndGet(shift ? 2 : 1);
+                }
+            } else {
+                value0D += shift ? 16 : 1;
+            }
+        }, 133, 22, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_0);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (secondRow.get()) {
+                    columnPointer.addAndGet(shift ? 2 : 1);
+                } else {
+                    secondRow.set(true);
+                }
+            } else {
+                value1D += shift ? 16 : 1;
+            }
+        }, 133, 40, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_1);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (shift) {
+                    if (secondRow.get()) {
+                        value1D = Double.longBitsToDouble(~Double.doubleToLongBits(value1D));
+                    } else {
+                        value0D = Double.longBitsToDouble(~Double.doubleToLongBits(value1D));
+                    }
+                } else {
+                    if (secondRow.get()) {
+                        long temp = Double.doubleToLongBits(value1D);
+                        temp ^= 1L << (long) columnPointer.get();
+                        value1D = Double.longBitsToDouble(temp);
+                    } else {
+                        long temp = Double.doubleToLongBits(value0D);
+                        temp ^= 1L << (long) columnPointer.get();
+                        value0D = Double.longBitsToDouble(temp);
+                    }
+                }
+            } else {
+                value0D *= shift ? 16 : 2;
+                value1D *= shift ? 16 : 2;
+            }
+        },
+            133,
+            58,
+            isAdvanced ? TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_T : GTUITextures.OVERLAY_BUTTON_PLUS_SMALL,
+            isAdvanced ? null : TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_ID);
+
+        addChangeParamButton(
+            builder,
+            (shift, columnPointer, secondRow) -> param += shift ? 16 : 4,
+            151,
+            4,
+            GTUITextures.OVERLAY_BUTTON_PLUS_LARGE,
+            TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_ID);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (secondRow.get()) {
+                    secondRow.set(false);
+                } else {
+                    columnPointer.addAndGet(shift ? 16 : 4);
+                }
+            } else {
+                value0D += shift ? 4096 : 256;
+            }
+        }, 151, 22, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_0);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                if (secondRow.get()) {
+                    columnPointer.addAndGet(shift ? 16 : 4);
+                } else {
+                    secondRow.set(true);
+                }
+            } else {
+                value1D += shift ? 4096 : 256;
+            }
+        }, 151, 40, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_1);
+        addChangeParamButton(builder, (shift, columnPointer, secondRow) -> {
+            if (isAdvanced) {
+                value0D = input0D;
+                value1D = input1D;
+            } else {
+                value0D *= shift ? 4096 : 256;
+                value1D *= shift ? 4096 : 256;
+            }
+        },
+            151,
+            58,
+            isAdvanced ? TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_IF : GTUITextures.OVERLAY_BUTTON_PLUS_LARGE,
+            isAdvanced ? null : TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_ID);
+
+        builder.widget(new FakeSyncWidget.IntegerSyncer(() -> pointer, val -> pointer = val))
+            .widget(new FakeSyncWidget.IntegerSyncer(() -> param, val -> param = val))
+            .widget(new FakeSyncWidget.DoubleSyncer(() -> value0D, val -> value0D = val))
+            .widget(new FakeSyncWidget.DoubleSyncer(() -> value1D, val -> value1D = val))
+            .widget(new FakeSyncWidget.DoubleSyncer(() -> input0D, val -> input0D = val))
+            .widget(new FakeSyncWidget.DoubleSyncer(() -> input1D, val -> input1D = val));
+
+        final String CIRCLED_0 = "\u24EA";
+        final String CIRCLED_1 = "\u2460";
+        final String ARROW_DOWN = "\u2b07";
+        final String ARROW_UP = "\u2b06";
+        builder.widget(
+            TextWidget.dynamicString(() -> (isAdvanced ? "Parameters X: " : "Parameters: ") + param)
+                .setSynced(false)
+                .setDefaultColor(COLOR_TEXT_WHITE.get())
+                .setPos(46, 7))
+            .widget(
+                TextWidget.dynamicString(() -> CIRCLED_0 + ARROW_DOWN + TTUtility.formatNumberExp(input0D))
+                    .setSynced(false)
+                    .setDefaultColor(0x22ddff)
+                    .setPos(46, 16))
+            .widget(
+                TextWidget.dynamicString(() -> CIRCLED_1 + ARROW_DOWN + TTUtility.formatNumberExp(input1D))
+                    .setSynced(false)
+                    .setDefaultColor(0x00ffff)
+                    .setPos(46, 24))
+            .widget(
+                TextWidget.dynamicString(() -> CIRCLED_0 + ARROW_UP + TTUtility.formatNumberExp(value0D))
+                    .setSynced(false)
+                    .setDefaultColor(0x00bbff)
+                    .setPos(46, 33))
+            .widget(
+                TextWidget.dynamicString(() -> CIRCLED_1 + ARROW_UP + TTUtility.formatNumberExp(value1D))
+                    .setSynced(false)
+                    .setDefaultColor(0x0077ff)
+                    .setPos(46, 41))
+            .widget(
+                TextWidget
+                    .dynamicString(
+                        () -> CIRCLED_0 + ARROW_UP + TTUtility.longBitsToShortString(Double.doubleToLongBits(value0D)))
+                    .setSynced(false)
+                    .setDefaultColor(0x00bbff)
+                    .setScale(.5f)
+                    .setTextAlignment(Alignment.CenterLeft)
+                    .setPos(46, 50))
+            .widget(
+                TextWidget
+                    .dynamicString(
+                        () -> CIRCLED_1 + ARROW_UP + TTUtility.longBitsToShortString(Double.doubleToLongBits(value1D)))
+                    .setSynced(false)
+                    .setDefaultColor(0x0077ff)
+                    .setScale(.5f)
+                    .setTextAlignment(Alignment.CenterLeft)
+                    .setPos(46, 58));
+        if (isAdvanced) {
+            builder.widget(
+                TextWidget.dynamicString(
+                    () -> "Pointer " + Integer.toHexString(pointer | 0x10000)
+                        .substring(1))
+                    .setSynced(false)
+                    .setDefaultColor(0x0033ff)
+                    .setPos(46, 66));
+        }
+    }
+
+    private void addChangeParamButton(ModularWindow.Builder builder, OnClick onClick, int xPos, int yPos,
+        IDrawable overlay1, IDrawable overlay2) {
+        final boolean isAdvanced = mTier > 5;
+        builder.widget(new ButtonWidget().setOnClick((clickData, widget) -> {
+            AtomicInteger columnPointer = new AtomicInteger(pointer & 0xff);
+            AtomicBoolean secondRow = new AtomicBoolean((pointer & 0x0100) != 0);
+            onClick.accept(clickData.shift, columnPointer, secondRow);
+            TecTech.proxy.playSound(getBaseMetaTileEntity(), "fx_click");
+            if (isAdvanced) {
+                if (columnPointer.get() >= 64) {
+                    columnPointer.set(63);
+                } else if (columnPointer.get() < 0) {
+                    columnPointer.set(0);
+                }
+                pointer = secondRow.get() ? columnPointer.get() + 0x100 : columnPointer.get();
+            }
+            if (param > 9) {
+                param = 9;
+            } else if (param < -1) {
+                param = -1;
+            }
+        })
+            .setPlayClickSound(false)
+            .setBackground(
+                overlay2 != null ? new IDrawable[] { GTUITextures.BUTTON_STANDARD, overlay1, overlay2 }
+                    : new IDrawable[] { GTUITextures.BUTTON_STANDARD, overlay1 })
+            .setSize(18, 18)
+            .setPos(xPos, yPos));
+    }
+
+    @FunctionalInterface
+    private interface OnClick {
+
+        void accept(boolean shift, AtomicInteger columnPointer, AtomicBoolean secondRow);
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchParamText.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchParamText.java
new file mode 100644
index 0000000000..7efe4e1fd0
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchParamText.java
@@ -0,0 +1,291 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static net.minecraft.util.StatCollector.translateToLocalFormatted;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.DrawableWidget;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget;
+
+import gregtech.api.gui.modularui.GTUIInfos;
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import tectech.TecTech;
+import tectech.thing.gui.TecTechUITextures;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 15.12.2016.
+ */
+public class MTEHatchParamText extends MTEHatchParam {
+
+    public String value0s = "";
+    public String value1s = "";
+
+    private String clientLocale = "en_US";
+
+    public MTEHatchParamText(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier);
+    }
+
+    public MTEHatchParamText(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new MTEHatchParamText(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[] {
+            translateToLocalFormatted("tt.keyword.Parametrizer", clientLocale) + " "
+                + translateToLocalFormatted("tt.keyword.ID", clientLocale)
+                + ": "
+                + EnumChatFormatting.GREEN
+                + param,
+            translateToLocalFormatted("tt.keyword.Value", clientLocale) + " 0S: "
+                + EnumChatFormatting.DARK_AQUA
+                + value0s,
+            translateToLocalFormatted("tt.keyword.Value", clientLocale) + " 1S: "
+                + EnumChatFormatting.DARK_BLUE
+                + value1s,
+            translateToLocalFormatted("tt.keyword.Value", clientLocale) + " 0D: " + EnumChatFormatting.AQUA + value0D,
+            translateToLocalFormatted("tt.keyword.Value", clientLocale) + " 1D: " + EnumChatFormatting.BLUE + value1D,
+            translateToLocalFormatted("tt.keyword.Input", clientLocale) + " 0D: " + EnumChatFormatting.GOLD + input0D,
+            translateToLocalFormatted("tt.keyword.Input", clientLocale) + " 1D: "
+                + EnumChatFormatting.YELLOW
+                + input1D, };
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setString("eIeValue0S", value0s);
+        aNBT.setString("eIeValue1S", value1s);
+        aNBT.removeTag("ePointer");
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        value0s = aNBT.getString("eIeValue0S");
+        value1s = aNBT.getString("eIeValue1S");
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public boolean isLiquidInput(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean isFluidInputAllowed(FluidStack aFluid) {
+        return false;
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) {
+            return true;
+        }
+        try {
+            EntityPlayerMP player = (EntityPlayerMP) aPlayer;
+            clientLocale = (String) FieldUtils.readField(player, "translator", true);
+        } catch (Exception e) {
+            clientLocale = "en_US";
+        }
+        GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
+        return true;
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { CommonValues.TEC_MARK_GENERAL,
+            EnumChatFormatting.DARK_RED + "Deprecated; Now you can set parameter by clicking LED on multiblock GUI.",
+            EnumChatFormatting.DARK_RED + "If it doesn't work, try removing Parametrizer from multiblock structure.", };
+    }
+
+    @Override
+    public void addGregTechLogo(ModularWindow.Builder builder) {
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_TECTECH_LOGO_DARK)
+                .setSize(18, 18)
+                .setPos(148, 55));
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.BACKGROUND_SCREEN_BLUE_PARAMETRIZER_TXT)
+                .setPos(7, 4)
+                .setSize(162, 72));
+
+        addChangeNumberButton(builder, -16, -4, 7, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE);
+        addChangeNumberButton(builder, -2, -1, 25, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL);
+        addChangeNumberButton(builder, 2, 1, 133, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL);
+        addChangeNumberButton(builder, 16, 4, 151, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE);
+
+        builder.widget(new FakeSyncWidget.IntegerSyncer(() -> param, val -> param = val))
+            .widget(new FakeSyncWidget.DoubleSyncer(() -> value0D, val -> value0D = val))
+            .widget(new FakeSyncWidget.DoubleSyncer(() -> value1D, val -> value1D = val))
+            .widget(new FakeSyncWidget.DoubleSyncer(() -> input0D, val -> input0D = val))
+            .widget(new FakeSyncWidget.DoubleSyncer(() -> input1D, val -> input1D = val));
+        // .widget(new FakeSyncWidget.StringSyncer(() -> value0s, val -> value0s = val))
+        // .widget(new FakeSyncWidget.StringSyncer(() -> value1s, val -> value1s = val));
+
+        final String CIRCLED_0 = "\u24EA";
+        final String CIRCLED_1 = "\u2460";
+        final String ARROW_DOWN = "\u2b07";
+        final String ARROW_UP = "\u2b06";
+        builder.widget(
+            TextWidget.dynamicString(() -> "Parameters: " + param)
+                .setSynced(false)
+                .setDefaultColor(COLOR_TEXT_WHITE.get())
+                .setPos(46, 7))
+            .widget(
+                new TextWidget(CIRCLED_0 + ARROW_UP).setDefaultColor(0x00bbff)
+                    .setPos(10, 29))
+            .widget(
+                new TextWidget(CIRCLED_1 + ARROW_UP).setDefaultColor(0x0077ff)
+                    .setPos(10, 44))
+            .widget(
+                TextWidget.dynamicString(() -> CIRCLED_0 + ARROW_DOWN + TTUtility.formatNumberExp(input0D))
+                    .setSynced(false)
+                    .setDefaultColor(0x22ddff)
+                    .setPos(10, 56))
+            .widget(
+                TextWidget.dynamicString(() -> CIRCLED_1 + ARROW_DOWN + TTUtility.formatNumberExp(input1D))
+                    .setSynced(false)
+                    .setDefaultColor(0x00ffff)
+                    .setPos(10, 65));
+
+        addTextField(builder, true);
+        addTextField(builder, false);
+    }
+
+    private void addChangeNumberButton(ModularWindow.Builder builder, int changeNumberShift, int changeNumber, int xPos,
+        IDrawable overlay) {
+        builder.widget(new ButtonWidget().setOnClick((clickData, widget) -> {
+            param += clickData.shift ? changeNumberShift : changeNumber;
+            TecTech.proxy.playSound(getBaseMetaTileEntity(), "fx_click");
+            if (param > 9) {
+                param = 9;
+            } else if (param < -1) {
+                param = -1;
+            }
+        })
+            .setPlayClickSound(false)
+            .setBackground(GTUITextures.BUTTON_STANDARD, overlay, TecTechUITextures.OVERLAY_BUTTON_PARAMETRIZER_ID)
+            .setSize(18, 18)
+            .setPos(xPos, 4));
+    }
+
+    private void addTextField(ModularWindow.Builder builder, boolean isIndex0) {
+        TextFieldWidget widget = new TextFieldWidget();
+        builder.widget(
+            widget.setGetter(() -> isIndex0 ? value0s : value1s)
+                .setSetter(str -> {
+                    double val;
+                    try {
+                        val = parse(str);
+                    } catch (Exception e) {
+                        // This shouldn't happen as long as validator works
+                        str = "";
+                        val = 0;
+                    }
+                    if (isIndex0) {
+                        value0s = str;
+                        value0D = val;
+                    } else {
+                        value1s = str;
+                        value1D = val;
+                    }
+                })
+                .setValidator(str -> {
+                    try {
+                        parse(str);
+                        return str;
+                    } catch (Exception e) {
+                        return widget.getLastText()
+                            .size() > 0 ? widget.getLastText()
+                                .get(0) : "";
+                    }
+                })
+                .setTextColor(Color.WHITE.dark(1))
+                .setTextAlignment(Alignment.CenterLeft)
+                .setBackground(GTUITextures.BACKGROUND_TEXT_FIELD.withOffset(-1, -1, 2, 2))
+                .setPos(26, isIndex0 ? 26 : 41)
+                .setSize(138, 12));
+    }
+
+    private double parse(String str) {
+        double val;
+        if (str.contains("b")) {
+            String[] split = str.split("b");
+            val = TTUtility.bitStringToInt(split[0].replaceAll("[^-]", "") + split[1].replaceAll("_", ""));
+        } else if (str.contains("x")) {
+            String[] split = str.split("x");
+            val = TTUtility.hexStringToInt(split[0].replaceAll("[^-]", "") + split[1].replaceAll("_", ""));
+        } else {
+            val = TTUtility.stringToDouble(str);
+        }
+        return val;
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchRack.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchRack.java
new file mode 100644
index 0000000000..03e11cc4f1
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchRack.java
@@ -0,0 +1,412 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static gregtech.api.enums.Mods.GraviSuite;
+import static gregtech.api.enums.Mods.NewHorizonsCoreMod;
+import static gregtech.api.enums.Mods.OpenComputers;
+import static gregtech.api.util.GTModHandler.getModItem;
+import static net.minecraft.util.StatCollector.translateToLocal;
+import static net.minecraft.util.StatCollector.translateToLocalFormatted;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.internal.wrapper.BaseSlot;
+import com.gtnewhorizons.modularui.common.widget.DrawableWidget;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.modularui.GTUIInfos;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.modularui.IAddGregtechLogo;
+import gregtech.api.interfaces.modularui.IAddUIWidgets;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import gregtech.api.objects.GTRenderedTexture;
+import tectech.TecTech;
+import tectech.loader.TecTechConfig;
+import tectech.thing.gui.TecTechUITextures;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by Tec on 03.04.2017.
+ */
+public class MTEHatchRack extends MTEHatch implements IAddGregtechLogo, IAddUIWidgets {
+
+    private static Textures.BlockIcons.CustomIcon EM_R;
+    private static Textures.BlockIcons.CustomIcon EM_R_ACTIVE;
+    public int heat = 0;
+    private float overClock = 1, overVolt = 1;
+    private static final Map<String, RackComponent> componentBinds = new HashMap<>();
+
+    private String clientLocale = "en_US";
+
+    public MTEHatchRack(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            4,
+            new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.rack.desc.0"),
+                EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.rack.desc.1") });
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchRack(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 4, aDescription, aTextures);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setInteger("eHeat", heat);
+        aNBT.setFloat("eOverClock", overClock);
+        aNBT.setFloat("eOverVolt", overVolt);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        heat = aNBT.getInteger("eHeat");
+        overClock = aNBT.getFloat("eOverClock");
+        overVolt = aNBT.getFloat("eOverVolt");
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {
+        super.registerIcons(aBlockIconRegister);
+        EM_R_ACTIVE = new Textures.BlockIcons.CustomIcon("iconsets/EM_RACK_ACTIVE");
+        EM_R = new Textures.BlockIcons.CustomIcon("iconsets/EM_RACK");
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(EM_R_ACTIVE) };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(EM_R) };
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchRack(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return true;
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 1;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        if (aBaseMetaTileEntity.isActive() || heat > 2000) {
+            return false;
+        }
+        return side == aBaseMetaTileEntity.getFrontFacing();
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        if (aBaseMetaTileEntity.isActive() || heat > 2000) {
+            return false;
+        }
+        return side == aBaseMetaTileEntity.getFrontFacing();
+    }
+
+    @Override
+    public int getSizeInventory() { // HACK TO NOT DROP CONTENTS!!!
+        return heat > 2000 || getBaseMetaTileEntity().isActive() ? 0 : mInventory.length;
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) {
+            return true;
+        }
+        try {
+            EntityPlayerMP player = (EntityPlayerMP) aPlayer;
+            clientLocale = (String) FieldUtils.readField(player, "translator", true);
+        } catch (Exception e) {
+            clientLocale = "en_US";
+        }
+        // if(aBaseMetaTileEntity.isActive())
+        // aPlayer.addChatComponentMessage(new ChatComponentText("It is still active..."));
+        // else if(heat>0)
+        // aPlayer.addChatComponentMessage(new ChatComponentText("It is still warm..."));
+        // else
+        GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
+        return true;
+    }
+
+    private int getComputationPower(float overclock, float overvolt, boolean tickingComponents) {
+        float computation = 0, heat = 0;
+        for (int i = 0; i < mInventory.length; i++) {
+            if (mInventory[i] == null || mInventory[i].stackSize != 1) {
+                continue;
+            }
+            RackComponent comp = componentBinds.get(TTUtility.getUniqueIdentifier(mInventory[i]));
+            if (comp == null) {
+                continue;
+            }
+            if (tickingComponents) {
+                if (this.heat > comp.maxHeat) {
+                    mInventory[i] = null;
+                    continue;
+                } else if (comp.subZero || this.heat >= 0) {
+                    heat += (1f + comp.coolConstant * this.heat / 100000f)
+                        * (comp.heatConstant > 0 ? comp.heatConstant * overclock * overvolt * overvolt : -10f);
+
+                    if (overvolt > TecTech.RANDOM.nextFloat()) {
+                        computation += comp.computation * (1 + overclock * overclock)
+                            / (1 + (overclock - overvolt) * (overclock - overvolt));
+                    }
+                }
+            } else {
+                computation += comp.computation * (1 + overclock * overclock)
+                    / (1 + (overclock - overvolt) * (overclock - overvolt)); // For getInfoData()
+            }
+        }
+        if (tickingComponents) {
+            this.heat += Math.ceil(heat);
+        }
+        return (int) Math.floor(computation);
+    }
+
+    public int tickComponents(float oc, float ov) {
+        overClock = oc;
+        overVolt = ov;
+        return getComputationPower(overClock, overVolt, true);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if (aTick % 20 == CommonValues.MULTI_CHECK_AT) {
+                if (heat > 0) {
+                    float heatC = 0;
+                    for (int i = 0; i < mInventory.length; i++) {
+                        if (mInventory[i] == null || mInventory[i].stackSize != 1) {
+                            continue;
+                        }
+                        RackComponent comp = componentBinds.get(TTUtility.getUniqueIdentifier(mInventory[i]));
+                        if (comp == null) {
+                            continue;
+                        }
+                        if (heat - 20 > comp.maxHeat) {
+                            mInventory[i] = null;
+                        } else if (comp.heatConstant < 0) {
+                            heatC += comp.heatConstant * (heat / 10000f);
+                        }
+                    }
+                    heat += Math.max(-heat, Math.ceil(heatC));
+                    heat -= Math.max(heat / 1000, 20);
+                }
+            }
+        }
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[] {
+            translateToLocalFormatted("tt.keyphrase.Base_computation", clientLocale) + ": "
+                + EnumChatFormatting.AQUA
+                + getComputationPower(overClock, overVolt, false),
+            translateToLocalFormatted("tt.keyphrase.Heat_Accumulated", clientLocale) + ": "
+                + EnumChatFormatting.RED
+                + heat
+                + EnumChatFormatting.RESET };
+    }
+
+    @Override
+    public void addGregTechLogo(ModularWindow.Builder builder) {
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_TECTECH_LOGO)
+                .setSize(18, 18)
+                .setPos(151, 63));
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_HEAT_SINK)
+                .setPos(46, 17)
+                .setSize(84, 60));
+
+        Pos2d[] positions = new Pos2d[] { new Pos2d(68, 27), new Pos2d(90, 27), new Pos2d(68, 49), new Pos2d(90, 49), };
+        for (int i = 0; i < positions.length; i++) {
+            builder.widget(new SlotWidget(new BaseSlot(inventoryHandler, i) {
+
+                @Override
+                public int getSlotStackLimit() {
+                    return 1;
+                }
+
+                @Override
+                public boolean isEnabled() {
+                    return !getBaseMetaTileEntity().isActive() && heat <= 0;
+                }
+            }).setBackground(getGUITextureSet().getItemSlot(), TecTechUITextures.OVERLAY_SLOT_RACK)
+                .setPos(positions[i]));
+
+            builder.widget(
+                new DrawableWidget().setDrawable(TecTechUITextures.BUTTON_STANDARD_LIGHT_16x16)
+                    .setPos(152, 24)
+                    .setSize(16, 16))
+                .widget(
+                    new DrawableWidget()
+                        .setDrawable(
+                            () -> getBaseMetaTileEntity().isActive() ? TecTechUITextures.OVERLAY_BUTTON_POWER_SWITCH_ON
+                                : TecTechUITextures.OVERLAY_BUTTON_POWER_SWITCH_DISABLED)
+                        .setPos(152, 24)
+                        .setSize(16, 16))
+                .widget(
+                    new FakeSyncWidget.BooleanSyncer(
+                        () -> getBaseMetaTileEntity().isActive(),
+                        val -> getBaseMetaTileEntity().setActive(val)));
+            builder.widget(
+                new DrawableWidget().setDrawable(TecTechUITextures.BUTTON_STANDARD_LIGHT_16x16)
+                    .setPos(152, 41)
+                    .setSize(16, 16))
+                .widget(
+                    new DrawableWidget()
+                        .setDrawable(
+                            () -> heat > 0 ? TecTechUITextures.OVERLAY_BUTTON_HEAT_ON
+                                : TecTechUITextures.OVERLAY_BUTTON_HEAT_OFF)
+                        .setPos(152, 41)
+                        .setSize(16, 16))
+                .widget(new FakeSyncWidget.IntegerSyncer(() -> heat, val -> heat = val));
+        }
+    }
+
+    public static void run() { // 20k heat cap max!
+        new RackComponent(ItemList.Circuit_Crystalprocessor.get(1), 60, 56, -1f, 2000, true); // IV
+        new RackComponent(ItemList.Circuit_Crystalcomputer.get(1), 80, 54, -1f, 2000, true); // LuV
+        new RackComponent(ItemList.Circuit_Ultimatecrystalcomputer.get(1), 100, 52, -1f, 2000, true); // ZPM
+        new RackComponent(ItemList.Circuit_Crystalmainframe.get(1), 120, 50, -1f, 2000, true); // UV
+
+        new RackComponent(ItemList.Circuit_Neuroprocessor.get(1), 160, 46, -1f, 4000, true); // LuV
+        new RackComponent(ItemList.Circuit_Wetwarecomputer.get(1), 180, 44, -1f, 4000, true); // ZPM
+        new RackComponent(ItemList.Circuit_Wetwaresupercomputer.get(1), 200, 42, -1f, 4000, true); // UV
+        new RackComponent(ItemList.Circuit_Wetwaremainframe.get(1), 220, 40, -1f, 4000, true); // UHV
+
+        new RackComponent("IC2:ic2.reactorVent", 0, -1, 40f, 2000, false); // Heat Vent
+        new RackComponent("IC2:ic2.reactorVentCore", 0, -1, 80f, 4000, false); // Reactor Heat Vent
+        new RackComponent("IC2:ic2.reactorVentGold", 0, -1, 120f, 6000, false); // Overclocked Heat Vent
+        new RackComponent("IC2:ic2.reactorVentDiamond", 0, -1, 160f, 8000, false); // Advanced Heat Vent
+
+        if (NewHorizonsCoreMod.isModLoaded()) {
+            // GTNH-GT5u circuits (these components causes crashes when used with the original GT5u)
+            new RackComponent(ItemList.Circuit_Bioprocessor.get(1), 200, 36, -1f, 6000, true); // ZPM
+            new RackComponent(ItemList.Circuit_Biowarecomputer.get(1), 220, 34, -1f, 6000, true); // UV
+            new RackComponent(ItemList.Circuit_Biowaresupercomputer.get(1), 240, 32, -1f, 6000, true); // UHV
+            new RackComponent(ItemList.Circuit_Biomainframe.get(1), 260, 30, -1f, 6000, true); // UEV
+
+            new RackComponent(ItemList.Circuit_OpticalProcessor.get(1), 200, 26, -1f, 8000, true); // UV
+            new RackComponent(ItemList.Circuit_OpticalAssembly.get(1), 220, 24, -1f, 8000, true); // UHV
+            new RackComponent(ItemList.Circuit_OpticalComputer.get(1), 240, 22, -1f, 8000, true); // UEV
+            new RackComponent(ItemList.Circuit_OpticalMainframe.get(1), 260, 20, -1f, 8000, true); // UIV
+
+            new RackComponent("dreamcraft:item.PikoCircuit", 260, 12, -1f, 9500, true); // UMV
+            new RackComponent("dreamcraft:item.QuantumCircuit", 320, 10, -1f, 10000, true); // UXV
+        }
+
+        if (OpenComputers.isModLoaded()) {
+            new RackComponent("OpenComputers:item.oc.CPU2", 80, 46, -1f, 2000, true); // CPU T3
+            new RackComponent("OpenComputers:item.oc.GraphicsCard2", 100, 44, -1f, 2000, true); // GPU T3
+            new RackComponent("OpenComputers:item.oc.APU1", 120, 42, -1f, 2000, true); // APU T3
+            new RackComponent("OpenComputers:item.oc.APU2", 240, 40, -1f, 2000, true); // APU Creative
+        }
+
+        if (GraviSuite.isModLoaded()) {
+            new RackComponent(getModItem(GraviSuite.ID, "itemSimpleItem", 1, 2), 0, -1, 200f, 10000, false); // CC
+        }
+    }
+
+    public static class RackComponent implements Comparable<RackComponent> {
+
+        private final String unlocalizedName;
+        private final float heatConstant, coolConstant, computation, maxHeat;
+        private final boolean subZero;
+
+        RackComponent(ItemStack is, float computation, float heatConstant, float coolConstant, float maxHeat,
+            boolean subZero) {
+            this(TTUtility.getUniqueIdentifier(is), computation, heatConstant, coolConstant, maxHeat, subZero);
+        }
+
+        RackComponent(String is, float computation, float heatConstant, float coolConstant, float maxHeat,
+            boolean subZero) {
+            unlocalizedName = is;
+            this.computation = computation;
+            this.heatConstant = heatConstant;
+            this.coolConstant = coolConstant;
+            this.maxHeat = maxHeat;
+            this.subZero = subZero;
+            componentBinds.put(unlocalizedName, this);
+            if (TecTechConfig.DEBUG_MODE) {
+                TecTech.LOGGER.info("Component registered: " + unlocalizedName);
+            }
+        }
+
+        @Override
+        public int compareTo(RackComponent o) {
+            return unlocalizedName.compareTo(o.unlocalizedName);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof RackComponent) {
+                return compareTo((RackComponent) obj) == 0;
+            }
+            return false;
+        }
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchUncertainty.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchUncertainty.java
new file mode 100644
index 0000000000..f8c2587269
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchUncertainty.java
@@ -0,0 +1,467 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static net.minecraft.util.StatCollector.translateToLocal;
+import static net.minecraft.util.StatCollector.translateToLocalFormatted;
+import static org.lwjgl.opengl.GL11.GL_BLEND;
+import static org.lwjgl.opengl.GL11.GL_ONE_MINUS_SRC_ALPHA;
+import static org.lwjgl.opengl.GL11.GL_SRC_ALPHA;
+import static org.lwjgl.opengl.GL11.glBlendFunc;
+import static org.lwjgl.opengl.GL11.glColor4f;
+import static org.lwjgl.opengl.GL11.glDisable;
+import static org.lwjgl.opengl.GL11.glEnable;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import com.gtnewhorizons.modularui.api.GlStateManager;
+import com.gtnewhorizons.modularui.api.drawable.UITexture;
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.DrawableWidget;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.modularui.GTUIInfos;
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.modularui.IAddGregtechLogo;
+import gregtech.api.interfaces.modularui.IAddUIWidgets;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import gregtech.api.objects.GTRenderedTexture;
+import tectech.TecTech;
+import tectech.thing.gui.TecTechUITextures;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+/**
+ * Created by danie_000 on 15.12.2016.
+ */
+public class MTEHatchUncertainty extends MTEHatch implements IAddGregtechLogo, IAddUIWidgets {
+
+    private static Textures.BlockIcons.CustomIcon ScreenON;
+    private static Textures.BlockIcons.CustomIcon ScreenOFF;
+    public short[] matrix = new short[] { 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500,
+        500 };
+    public byte selection = -1, mode = 0, status = -128; // all 8 bits set
+
+    private String clientLocale = "en_US";
+
+    public MTEHatchUncertainty(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, 0, "");
+        TTUtility.setTier(aTier, this);
+        regenerate();
+    }
+
+    public MTEHatchUncertainty(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+        regenerate();
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister aBlockIconRegister) {
+        super.registerIcons(aBlockIconRegister);
+        ScreenOFF = new Textures.BlockIcons.CustomIcon("iconsets/UC");
+        ScreenON = new Textures.BlockIcons.CustomIcon("iconsets/UC_ACTIVE");
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(ScreenON) };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, new GTRenderedTexture(ScreenOFF) };
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide() && (aTick & 15) == 0) {
+            if (mode == 0) {
+                aBaseMetaTileEntity.setActive(false);
+                status = -128;
+            } else {
+                aBaseMetaTileEntity.setActive(true);
+                shift();
+                compute();
+            }
+        }
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new MTEHatchUncertainty(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[] {
+            translateToLocalFormatted("tt.keyword.Status", clientLocale) + ": " + EnumChatFormatting.GOLD + status };
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setByte("mSel", selection);
+        aNBT.setByte("mMode", mode);
+        aNBT.setByte("mStatus", status);
+        NBTTagCompound mat = new NBTTagCompound();
+        for (int i = 0; i < 16; i++) {
+            mat.setShort(Integer.toString(i), matrix[i]);
+        }
+        aNBT.setTag("mMat", mat);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        selection = aNBT.getByte("mSel");
+        mode = aNBT.getByte("mMode");
+        status = aNBT.getByte("mStatus");
+        NBTTagCompound mat = aNBT.getCompoundTag("mMat");
+        for (int i = 0; i < 16; i++) {
+            matrix[i] = mat.getShort(Integer.toString(i));
+        }
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public boolean isLiquidInput(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean isFluidInputAllowed(FluidStack aFluid) {
+        return false;
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) {
+            return true;
+        }
+        try {
+            EntityPlayerMP player = (EntityPlayerMP) aPlayer;
+            clientLocale = (String) FieldUtils.readField(player, "translator", true);
+        } catch (Exception e) {
+            clientLocale = "en_US";
+        }
+        GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
+        return true;
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.certain.desc.0"), // Feeling
+                                                                                                                   // certain,
+                                                                                                                   // or
+                                                                                                                   // not?
+            EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD
+                + translateToLocal("gt.blockmachines.hatch.certain.desc.1") // Schrödinger equation in a box
+        };
+    }
+
+    private boolean balanceCheck(int sideLenY, short... masses) {
+        float inequality = 0;
+        for (int i = 0; i < masses.length >> 1; i++) {
+            inequality += Math.abs(masses[i] - masses[masses.length - i - 1]);
+        }
+        return inequality < masses.length << 7;
+    }
+
+    public void regenerate() {
+        for (int i = 0; i < matrix.length; i++) {
+            matrix[i] = (short) TecTech.RANDOM.nextInt(1000);
+        }
+    }
+
+    public byte compute() {
+        int result = 0;
+        switch (mode) {
+            case 1: // ooo oxo ooo
+                result = balanceCheck(4, matrix) ? 0 : 1;
+                break;
+            case 2: // ooo xox ooo
+                result += balanceCheck(
+                    4,
+                    matrix[0],
+                    matrix[4],
+                    matrix[1],
+                    matrix[5],
+                    matrix[2],
+                    matrix[6],
+                    matrix[3],
+                    matrix[7]) ? 0 : 1;
+                result += balanceCheck(
+                    4,
+                    matrix[8],
+                    matrix[12],
+                    matrix[9],
+                    matrix[13],
+                    matrix[10],
+                    matrix[14],
+                    matrix[11],
+                    matrix[15]) ? 0 : 2;
+                break;
+            case 3: // oxo xox oxo
+                result += balanceCheck(
+                    2,
+                    matrix[0],
+                    matrix[4],
+                    matrix[8],
+                    matrix[12],
+                    matrix[1],
+                    matrix[5],
+                    matrix[9],
+                    matrix[13]) ? 0 : 1;
+                result += balanceCheck(
+                    4,
+                    matrix[0],
+                    matrix[4],
+                    matrix[1],
+                    matrix[5],
+                    matrix[2],
+                    matrix[6],
+                    matrix[3],
+                    matrix[7]) ? 0 : 2;
+                result += balanceCheck(
+                    4,
+                    matrix[8],
+                    matrix[12],
+                    matrix[9],
+                    matrix[13],
+                    matrix[10],
+                    matrix[14],
+                    matrix[11],
+                    matrix[15]) ? 0 : 4;
+                result += balanceCheck(
+                    2,
+                    matrix[2],
+                    matrix[6],
+                    matrix[10],
+                    matrix[14],
+                    matrix[3],
+                    matrix[7],
+                    matrix[11],
+                    matrix[15]) ? 0 : 8;
+                break;
+            case 4: // xox ooo xox
+                result += balanceCheck(2, matrix[0], matrix[4], matrix[1], matrix[5]) ? 0 : 1;
+                result += balanceCheck(2, matrix[8], matrix[12], matrix[9], matrix[13]) ? 0 : 2;
+                result += balanceCheck(2, matrix[2], matrix[6], matrix[3], matrix[7]) ? 0 : 4;
+                result += balanceCheck(2, matrix[10], matrix[14], matrix[11], matrix[15]) ? 0 : 8;
+                break;
+            case 5: // xox oxo xox
+                result += balanceCheck(2, matrix[0], matrix[4], matrix[1], matrix[5]) ? 0 : 1;
+                result += balanceCheck(2, matrix[8], matrix[12], matrix[9], matrix[13]) ? 0 : 2;
+                result += balanceCheck(4, matrix) ? 0 : 4;
+                result += balanceCheck(2, matrix[2], matrix[6], matrix[3], matrix[7]) ? 0 : 8;
+                result += balanceCheck(2, matrix[10], matrix[14], matrix[11], matrix[15]) ? 0 : 16;
+                break;
+        }
+        return status = (byte) result;
+    }
+
+    private void shift() {
+        int i = TecTech.RANDOM.nextInt(16), j = TecTech.RANDOM.nextInt(128);
+        matrix[i] += ((matrix[i] & 1) == 0 ? 2 : -2) * j >> 5;
+        matrix[i] += j == 0 ? 1 : 0;
+        if (matrix[i] < 0) {
+            matrix[i] = 0;
+        } else if (matrix[i] > 1000) {
+            matrix[i] = 999;
+        }
+    }
+
+    public byte update(int newMode) {
+        if (newMode == mode) {
+            return status;
+        }
+        if (newMode < 0 || newMode > 5) {
+            newMode = 0;
+        }
+        mode = (byte) newMode;
+        regenerate();
+        compute();
+        return status;
+    }
+
+    @Override
+    public void addGregTechLogo(ModularWindow.Builder builder) {
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_TECTECH_LOGO_DARK)
+                .setSize(18, 18)
+                .setPos(112, 55));
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        final boolean isAdvanced = mTier > 7;
+
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.BACKGROUND_SCREEN_BLUE)
+                .setPos(43, 4)
+                .setSize(90, 72))
+            .widget(
+                new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_UNCERTAINTY_MONITOR)
+                    .setPos(46, 27)
+                    .setSize(46, 46));
+
+        int[] xPositions = new int[] { 7, 25, 133, 151 };
+        for (int i = 0; i < 4; i++) {
+            for (int j = 0; j < 4; j++) {
+                final int index = i * 4 + j;
+                builder.widget(new ButtonWidget().setOnClick((clickData, widget) -> {
+                    TecTech.proxy.playSound(getBaseMetaTileEntity(), "fx_click");
+                    if (selection == -1) {
+                        selection = (byte) index;
+                    } else {
+                        short temp = matrix[selection];
+                        matrix[selection] = matrix[index];
+                        matrix[index] = temp;
+                        selection = -1;
+                    }
+                    compute();
+                })
+                    .setPlayClickSound(false)
+                    .setBackground(GTUITextures.BUTTON_STANDARD, TecTechUITextures.OVERLAY_BUTTON_UNCERTAINTY[index])
+                    .setPos(xPositions[i], 4 + j * 18)
+                    .setSize(18, 18))
+                    .widget(new FakeSyncWidget.ShortSyncer(() -> matrix[index], val -> matrix[index] = val));
+            }
+        }
+        builder.widget(new FakeSyncWidget.ByteSyncer(() -> selection, val -> selection = val))
+            .widget(new FakeSyncWidget.ByteSyncer(() -> mode, val -> mode = val))
+            .widget(new FakeSyncWidget.ByteSyncer(() -> status, val -> status = val));
+
+        builder.widget(
+            new TextWidget().setStringSupplier(() -> "Status: " + (status == 0 ? "OK" : "NG"))
+                .setDefaultColor(COLOR_TEXT_WHITE.get())
+                .setPos(46, 7));
+
+        for (int i = 0; i < 9; i++) {
+            final int index = i;
+            builder.widget(new DrawableWidget().setDrawable(() -> {
+                UITexture valid = TecTechUITextures.PICTURE_UNCERTAINTY_VALID[index];
+                UITexture invalid = TecTechUITextures.PICTURE_UNCERTAINTY_INVALID[index];
+                switch (mode) {
+                    case 1: // ooo oxo ooo
+                        if (index == 4) return status == 0 ? valid : invalid;
+                        break;
+                    case 2: // ooo xox ooo
+                        if (index == 3) return (status & 1) == 0 ? valid : invalid;
+                        if (index == 5) return (status & 2) == 0 ? valid : invalid;
+                        break;
+                    case 3: // oxo xox oxo
+                        if (index == 1) return (status & 1) == 0 ? valid : invalid;
+                        if (index == 3) return (status & 2) == 0 ? valid : invalid;
+                        if (index == 5) return (status & 4) == 0 ? valid : invalid;
+                        if (index == 7) return (status & 8) == 0 ? valid : invalid;
+                        break;
+                    case 4: // xox ooo xox
+                        if (index == 0) return (status & 1) == 0 ? valid : invalid;
+                        if (index == 2) return (status & 2) == 0 ? valid : invalid;
+                        if (index == 6) return (status & 4) == 0 ? valid : invalid;
+                        if (index == 8) return (status & 8) == 0 ? valid : invalid;
+                        break;
+                    case 5: // xox oxo xox
+                        if (index == 0) return (status & 1) == 0 ? valid : invalid;
+                        if (index == 2) return (status & 2) == 0 ? valid : invalid;
+                        if (index == 4) return (status & 4) == 0 ? valid : invalid;
+                        if (index == 6) return (status & 8) == 0 ? valid : invalid;
+                        if (index == 8) return (status & 16) == 0 ? valid : invalid;
+                        break;
+                }
+                return null;
+            })
+                .setPos(55 + (index % 3) * 12, 36 + (index / 3) * 12)
+                .setSize(4, 4));
+        }
+
+        for (int i = 0; i < 16; i++) {
+            final int index = i;
+            builder.widget(new DrawableWidget() {
+
+                @Override
+                public void draw(float partialTicks) {
+                    if (isAdvanced) {
+                        glEnable(GL_BLEND);
+                        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+                        glColor4f(1f, 1f, 1f, (float) matrix[index] / 1000f);
+
+                        // super.draw but without disabling blend
+                        GlStateManager.pushMatrix();
+                        getDrawable().draw(Pos2d.ZERO, getSize(), partialTicks);
+                        GlStateManager.popMatrix();
+
+                        glDisable(GL_BLEND);
+                        glColor4f(1f, 1f, 1f, 1f);
+                    } else {
+                        if (TecTech.RANDOM.nextInt(1000) < matrix[index]) {
+                            super.draw(partialTicks);
+                        }
+                    }
+                }
+            }.setDrawable(TecTechUITextures.PICTURE_UNCERTAINTY_INDICATOR)
+                .setPos(47 + (i / 4) * 12, 28 + (i % 4) * 12)
+                .setSize(8, 8))
+                .widget(
+                    new DrawableWidget()
+                        .setDrawable(() -> selection == index ? TecTechUITextures.PICTURE_UNCERTAINTY_SELECTED : null)
+                        .setPos(46 + (i / 4) * 12, 27 + (i % 4) * 12)
+                        .setSize(10, 10));
+        }
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessComputationInput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessComputationInput.java
new file mode 100644
index 0000000000..94f8181566
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessComputationInput.java
@@ -0,0 +1,132 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.DrawableWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget;
+
+import gregtech.api.gui.modularui.GTUIInfos;
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.modularui.IAddGregtechLogo;
+import gregtech.api.interfaces.modularui.IAddUIWidgets;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.common.WirelessComputationPacket;
+import tectech.thing.gui.TecTechUITextures;
+
+public class MTEHatchWirelessComputationInput extends MTEHatchDataInput implements IAddGregtechLogo, IAddUIWidgets {
+
+    public long requiredComputation = 10000;
+
+    private String clientLocale = "en_US";
+
+    public MTEHatchWirelessComputationInput(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier);
+    }
+
+    public MTEHatchWirelessComputationInput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchWirelessComputationInput(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        try {
+            EntityPlayerMP player = (EntityPlayerMP) aPlayer;
+            clientLocale = (String) FieldUtils.readField(player, "translator", true);
+        } catch (Exception e) {
+            clientLocale = "en_US";
+        }
+        if (!aPlayer.isUsingItem()) {
+            GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
+        }
+        return super.onRightclick(aBaseMetaTileEntity, aPlayer);
+    }
+
+    @Override
+    public boolean isDataInputFacing(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean canConnectData(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPreTick(aBaseMetaTileEntity, aTick);
+        if (aBaseMetaTileEntity.isServerSide() && q == null) {
+            q = WirelessComputationPacket.downloadData(aBaseMetaTileEntity.getOwnerUuid(), requiredComputation, aTick);
+        }
+
+    }
+
+    @Override
+    public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {
+        super.onFirstTick(aBaseMetaTileEntity);
+    }
+
+    @Override
+    public void addGregTechLogo(ModularWindow.Builder builder) {
+        builder.widget(
+            new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_TECTECH_LOGO)
+                .setSize(18, 18)
+                .setPos(151, 63));
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        requiredComputation = aNBT.getLong("requiredComputation");
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setLong("requiredComputation", requiredComputation);
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        builder.widget(
+            TextWidget.localised("tt.wirelessInputData.config.text")
+                .setPos(20, 12)
+                .setSize(140, 14))
+            .widget(
+                new TextFieldWidget().setSetterInt(val -> requiredComputation = val)
+                    .setGetterLong(() -> requiredComputation)
+                    .setNumbers(1, Integer.MAX_VALUE)
+                    .setOnScrollNumbers(1, 4, 64)
+                    .setTextAlignment(Alignment.Center)
+                    .setTextColor(Color.WHITE.normal)
+                    .setSize(70, 18)
+                    .setPos(54, 36)
+                    .setBackground(GTUITextures.BACKGROUND_TEXT_FIELD));
+    }
+
+    private static String[] tooltips;
+
+    @Override
+    public String[] getDescription() {
+        if (tooltips == null) {
+            tooltips = new String[] { "Wireless Computation Data Input for Multiblocks" };
+        }
+        return tooltips;
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessComputationOutput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessComputationOutput.java
new file mode 100644
index 0000000000..8495f95e6f
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessComputationOutput.java
@@ -0,0 +1,60 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.common.WirelessComputationPacket;
+
+public class MTEHatchWirelessComputationOutput extends MTEHatchDataOutput {
+
+    public MTEHatchWirelessComputationOutput(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier);
+
+    }
+
+    public MTEHatchWirelessComputationOutput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchWirelessComputationOutput(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean isDataInputFacing(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean canConnectData(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPreTick(aBaseMetaTileEntity, aTick);
+        if (aBaseMetaTileEntity.isServerSide() && q != null) {
+            WirelessComputationPacket.uploadData(aBaseMetaTileEntity.getOwnerUuid(), q.getContent(), aTick);
+            q = null;
+        }
+    }
+
+    private static String[] tooltips;
+
+    @Override
+    public String[] getDescription() {
+        if (tooltips == null) {
+            tooltips = new String[] { "Wireless Computation Output for Multiblocks" };
+        }
+        return tooltips;
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessDataItemsInput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessDataItemsInput.java
new file mode 100644
index 0000000000..e7d604328a
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessDataItemsInput.java
@@ -0,0 +1,139 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static gregtech.api.enums.Dyes.MACHINE_METAL;
+import static net.minecraft.util.StatCollector.translateToLocal;
+import static net.minecraft.util.StatCollector.translateToLocalFormatted;
+import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_ACTIVE;
+import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_CONN;
+import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_SIDES;
+
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import gregtech.api.enums.Dyes;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatchDataAccess;
+import gregtech.api.objects.GTRenderedTexture;
+import gregtech.common.WirelessDataStore;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+public class MTEHatchWirelessDataItemsInput extends MTEHatchDataAccess {
+
+    private String clientLocale = "en_US";
+
+    public MTEHatchWirelessDataItemsInput(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier);
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchWirelessDataItemsInput(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    public MTEHatchWirelessDataItemsInput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchWirelessDataItemsInput(this.mName, this.mTier, mDescriptionArray, this.mTextures);
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture,
+            new GTRenderedTexture(
+                EM_D_ACTIVE,
+                Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())),
+            new GTRenderedTexture(EM_D_CONN) };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture,
+            new GTRenderedTexture(
+                EM_D_SIDES,
+                Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())),
+            new GTRenderedTexture(EM_D_CONN) };
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) {
+            return true;
+        }
+        try {
+            EntityPlayerMP player = (EntityPlayerMP) aPlayer;
+            clientLocale = (String) FieldUtils.readField(player, "translator", true);
+        } catch (Exception e) {
+            clientLocale = "en_US";
+        }
+        return true;
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 1;
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public boolean isInputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { CommonValues.TEC_MARK_EM,
+            translateToLocal("gt.blockmachines.hatch.datainasswireless.desc.0"),
+            translateToLocal("gt.blockmachines.hatch.datainasswireless.desc.1"), };
+    }
+
+    @Override
+    public List<ItemStack> getInventoryItems(Predicate<ItemStack> filter) {
+        WirelessDataStore wirelessData = WirelessDataStore
+            .getWirelessDataSticks(getBaseMetaTileEntity().getOwnerUuid());
+        return wirelessData.downloadData()
+            .stream()
+            .filter(stack -> stack != null && filter.test(stack))
+            .collect(Collectors.toList());
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        return new String[] { translateToLocalFormatted("tt.keyphrase.Content_Stack_Count", clientLocale) + ": "
+            + getInventoryItems(_stack -> true).size() };
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessDataItemsOutput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessDataItemsOutput.java
new file mode 100644
index 0000000000..2765598475
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessDataItemsOutput.java
@@ -0,0 +1,142 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static gregtech.api.enums.Dyes.MACHINE_METAL;
+import static net.minecraft.util.StatCollector.translateToLocal;
+import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_ACTIVE;
+import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_CONN;
+import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_SIDES;
+
+import java.util.Arrays;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.enums.Dyes;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import gregtech.api.objects.GTRenderedTexture;
+import gregtech.common.WirelessDataStore;
+import tectech.mechanics.dataTransport.InventoryDataPacket;
+import tectech.util.CommonValues;
+import tectech.util.TTUtility;
+
+public class MTEHatchWirelessDataItemsOutput extends MTEHatch {
+
+    public InventoryDataPacket dataPacket = null;
+
+    public boolean uploadedSinceReset = false;
+
+    public MTEHatchWirelessDataItemsOutput(int aID, String aName, String aNameRegional, int aTier) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            0,
+            new String[] { CommonValues.TEC_MARK_EM,
+                translateToLocal("gt.blockmachines.hatch.wirelessdataoutass.desc.0"),
+                translateToLocal("gt.blockmachines.hatch.wirelessdataoutass.desc.1"), });
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchWirelessDataItemsOutput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchWirelessDataItemsOutput(this.mName, this.mTier, this.mDescriptionArray, this.mTextures);
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 1;
+    }
+
+    @Override
+    public boolean isOutputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isInputFacing(ForgeDirection side) {
+        return false;
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        if (dataPacket != null) {
+            aNBT.setTag("eDATA", dataPacket.toNbt());
+        }
+        aNBT.setBoolean("uploadedSinceReset", uploadedSinceReset);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        if (aNBT.hasKey("eDATA")) {
+            dataPacket = new InventoryDataPacket(aNBT.getCompoundTag("eDATA"));
+        }
+        if (aNBT.hasKey("uploadedSinceReset")) {
+            uploadedSinceReset = aNBT.getBoolean("uploadedSinceReset");
+        }
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            // Upload data packet and mark it as uploaded, so it will not be uploaded again
+            // until the data bank resets the wireless network
+            if (dataPacket != null && !uploadedSinceReset) {
+                WirelessDataStore wirelessDataStore = WirelessDataStore
+                    .getWirelessDataSticks(getBaseMetaTileEntity().getOwnerUuid());
+                wirelessDataStore.uploadData(Arrays.asList(dataPacket.getContent()));
+                uploadedSinceReset = true;
+            }
+        }
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture,
+            new GTRenderedTexture(
+                EM_D_ACTIVE,
+                Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())),
+            new GTRenderedTexture(EM_D_CONN) };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture,
+            new GTRenderedTexture(
+                EM_D_SIDES,
+                Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())),
+            new GTRenderedTexture(EM_D_CONN) };
+    }
+}
diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessMulti.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessMulti.java
new file mode 100644
index 0000000000..09d76c29a1
--- /dev/null
+++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessMulti.java
@@ -0,0 +1,209 @@
+package tectech.thing.metaTileEntity.hatch;
+
+import static com.gtnewhorizon.gtnhlib.util.AnimatedTooltipHandler.BLUE;
+import static com.gtnewhorizon.gtnhlib.util.AnimatedTooltipHandler.BOLD;
+import static com.gtnewhorizon.gtnhlib.util.AnimatedTooltipHandler.GRAY;
+import static gregtech.api.enums.GTValues.AuthorColen;
+import static gregtech.api.enums.GTValues.V;
+import static gregtech.common.misc.WirelessNetworkManager.addEUToGlobalEnergyMap;
+import static gregtech.common.misc.WirelessNetworkManager.strongCheckOrAddUser;
+import static java.lang.Long.min;
+
+import java.math.BigInteger;
+import java.util.UUID;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.interfaces.tileentity.IWirelessEnergyHatchInformation;
+import gregtech.api.metatileentity.MetaTileEntity;
+import tectech.thing.metaTileEntity.Textures;
+import tectech.util.TTUtility;
+
+public class MTEHatchWirelessMulti extends MTEHatchEnergyMulti implements IWirelessEnergyHatchInformation {
+
+    private final BigInteger eu_transferred_per_operation = BigInteger
+        .valueOf(Amperes * V[mTier] * ticks_between_energy_addition);
+    private final long eu_transferred_per_operation_long = eu_transferred_per_operation.longValue();
+
+    private UUID owner_uuid;
+
+    public MTEHatchWirelessMulti(int aID, String aName, String aNameRegional, int aTier, int aAmp) {
+        super(
+            aID,
+            aName,
+            aNameRegional,
+            aTier,
+            0,
+            new String[] { GRAY + "Stores energy globally in a network, up to 2^(2^31) EU.",
+                GRAY + "Does not connect to wires. This block withdraws EU from the network.",
+                AuthorColen + GRAY + BOLD + " & " + BLUE + BOLD + "Cloud" },
+            aAmp);
+        TTUtility.setTier(aTier, this);
+    }
+
+    public MTEHatchWirelessMulti(String aName, int aTier, int aAmp, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aAmp, aDescription, aTextures);
+    }
+
+    private ITexture[] TEXTURE_OVERLAY;
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        switch (Amperes) {
+            case 4:
+                TEXTURE_OVERLAY = Textures.OVERLAYS_ENERGY_IN_WIRELESS_MULTI_4A;
+                break;
+            case 16:
+                TEXTURE_OVERLAY = Textures.OVERLAYS_ENERGY_IN_WIRELESS_MULTI_16A;
+                break;
+            case 64:
+                TEXTURE_OVERLAY = Textures.OVERLAYS_ENERGY_IN_WIRELESS_MULTI_64A;
+                break;
+            default:
+                TEXTURE_OVERLAY = Textures.OVERLAYS_ENERGY_IN_WIRELESS_LASER;
+                break;
+        }
+        return new ITexture[] { aBaseTexture, TEXTURE_OVERLAY[mTier] };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        switch (Amperes) {
+            case 4:
+                TEXTURE_OVERLAY = Textures.OVERLAYS_ENERGY_IN_WIRELESS_MULTI_4A;
+                break;
+            case 16:
+                TEXTURE_OVERLAY = Textures.OVERLAYS_ENERGY_IN_WIRELESS_MULTI_16A;
+                break;
+            case 64:
+                TEXTURE_OVERLAY = Textures.OVERLAYS_ENERGY_IN_WIRELESS_MULTI_64A;
+                break;
+            default:
+                TEXTURE_OVERLAY = Textures.OVERLAYS_ENERGY_IN_WIRELESS_LASER;
+                break;
+        }
+        return new ITexture[] { aBaseTexture, TEXTURE_OVERLAY[mTier] };
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean isEnetInput() {
+        return false;
+    }
+
+    @Override
+    public boolean isInputFacing(ForgeDirection side) {
+        return side == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public long getMinimumStoredEU() {
+        return Amperes * V[mTier];
+    }
+
+    @Override
+    public long maxEUInput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxEUStore() {
+        return totalStorage(V[mTier]) * Amperes / 2;
+    }
+
+    @Override
+    public long maxAmperesIn() {
+        return Amperes;
+    }
+
+    @Override
+    public long maxWorkingAmperesIn() {
+        return Amperes;
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEHatchWirelessMulti(mName, mTier, Amperes, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public ConnectionType getConnectionType() {
+        return ConnectionType.WIRELESS;
+    }
+
+    @Override
+    public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            // On first tick find the player name and attempt to add them to the map.
+
+            // UUID and username of the owner.
+            owner_uuid = aBaseMetaTileEntity.getOwnerUuid();
+
+            strongCheckOrAddUser(owner_uuid);
+
+            tryFetchingEnergy();
+        }
+    }
+
+    @Override
+    public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+
+        super.onPreTick(aBaseMetaTileEntity, aTick);
+
+        if (aBaseMetaTileEntity.isServerSide()) {
+
+            // This is set up in a way to be as optimised as possible. If a user has a relatively plentiful energy
+            // network
+            // it should make no difference to them. Minimising the number of operations on BigInteger is essential.
+
+            // Every ticks_between_energy_addition add eu_transferred_per_operation to internal EU storage from network.
+            if (aTick % ticks_between_energy_addition == 0L) {
+                tryFetchingEnergy();
+            }
+        }
+    }
+
+    private void tryFetchingEnergy() {
+        long currentEU = getBaseMetaTileEntity().getStoredEU();
+        long maxEU = maxEUStore();
+        long euToTransfer = min(maxEU - currentEU, eu_transferred_per_operation_long);
+        if (euToTransfer <= 0) return; // nothing to transfer
+        if (!addEUToGlobalEnergyMap(owner_uuid, -euToTransfer)) return;
+        setEUVar(currentEU + euToTransfer);
+    }
+}