Merge branch 'advanced_redstone_covers'

# Conflicts:
#	src/main/java/gregtech/api/util/GT_Utility.java

50 files changed, 2073 insertions, 136 deletions

diff --git a/src/main/java/gregtech/api/GregTech_API.java b/src/main/java/gregtech/api/GregTech_API.java
index 7a52021eea..9b039409dc 100644
--- a/src/main/java/gregtech/api/GregTech_API.java
+++ b/src/main/java/gregtech/api/GregTech_API.java
@@ -173,6 +173,12 @@ public class GregTech_API {
      */
     public static final Map<Integer, Byte> sWirelessRedstone = new ConcurrentHashMap<>();
     /**
+     * The Advanced Redstone Frequencies
+     */
+    public static final Map<String, Map<Integer, Map<Long, Byte>>> sAdvancedWirelessRedstone =
+            new ConcurrentHashMap<>();
+
+    /**
      * The IDSU Frequencies
      */
     public static final Map<Integer, Integer> sIDSUList = new ConcurrentHashMap<>();
diff --git a/src/main/java/gregtech/api/enums/ItemList.java b/src/main/java/gregtech/api/enums/ItemList.java
index 279233d101..a6d93af7a3 100644
--- a/src/main/java/gregtech/api/enums/ItemList.java
+++ b/src/main/java/gregtech/api/enums/ItemList.java
@@ -1529,6 +1529,15 @@ public enum ItemList implements IItemContainer {
     Hatch_Output_Bus_ME,
 
     NULL,
+    Cover_AdvancedRedstoneTransmitterExternal,
+    Cover_AdvancedRedstoneTransmitterInternal,
+    Cover_AdvancedRedstoneReceiverExternal,
+    Cover_AdvancedRedstoneReceiverInternal,
+
+    Cover_WirelessFluidDetector,
+    Cover_WirelessItemDetector,
+    Cover_WirelessNeedsMaintainance,
+
     Cover_RedstoneTransmitterExternal,
     Cover_RedstoneTransmitterInternal,
     Cover_RedstoneReceiverExternal,
diff --git a/src/main/java/gregtech/api/enums/Textures.java b/src/main/java/gregtech/api/enums/Textures.java
index ee335c749e..77e28482ce 100644
--- a/src/main/java/gregtech/api/enums/Textures.java
+++ b/src/main/java/gregtech/api/enums/Textures.java
@@ -491,6 +491,16 @@ public class Textures {
         OVERLAY_FLUIDDETECTOR,
         OVERLAY_ITEMDETECTOR,
 
+        OVERLAY_REDSTONE_TRANSMITTER,
+        OVERLAY_REDSTONE_RECEIVER,
+        OVERLAY_MAINTENANCE_DETECTOR,
+
+        OVERLAY_ADVANCED_REDSTONE_TRANSMITTER,
+        OVERLAY_ADVANCED_REDSTONE_RECEIVER,
+        OVERLAY_WIRELESS_ITEM_DETECTOR,
+        OVERLAY_WIRELESS_FLUID_DETECTOR,
+        OVERLAY_WIRELESS_MAINTENANCE_DETECTOR,
+
         OVERLAY_FLUID_STORAGE_MONITOR0,
         OVERLAY_FLUID_STORAGE_MONITOR1,
         OVERLAY_FLUID_STORAGE_MONITOR2,
diff --git a/src/main/java/gregtech/api/gui/GT_GUIScreen.java b/src/main/java/gregtech/api/gui/GT_GUIScreen.java
index 281be1e55d..d39a6b738e 100644
--- a/src/main/java/gregtech/api/gui/GT_GUIScreen.java
+++ b/src/main/java/gregtech/api/gui/GT_GUIScreen.java
@@ -28,8 +28,8 @@ public abstract class GT_GUIScreen extends GuiScreen implements GT_IToolTipRende
     protected int gui_height = 107;
     protected int guiTop, guiLeft;
     protected boolean drawButtons = true;
+    protected ResourceLocation mGUIbackgroundLocation;
 
-    private ResourceLocation mGUIbackgroundLocation;
     private GuiButton selectedButton;
     private GT_GUIColorOverride colorOverride;
     private final int textColor;
diff --git a/src/main/java/gregtech/api/gui/widgets/GT_GuiIcon.java b/src/main/java/gregtech/api/gui/widgets/GT_GuiIcon.java
index 37e1a6d960..43fbe0711c 100644
--- a/src/main/java/gregtech/api/gui/widgets/GT_GuiIcon.java
+++ b/src/main/java/gregtech/api/gui/widgets/GT_GuiIcon.java
@@ -30,6 +30,12 @@ public enum GT_GuiIcon implements IGuiIcon {
     GREEN_ARROW_DOWN(0, 32 * 5, 32 * 2),
     CYCLIC(0, 32 * 6, 32 * 2),
 
+    AND_GATE(0, 0, 32 * 3),
+    NAND_GATE(0, 32, 32 * 3),
+    OR_GATE(0, 32 * 2, 32 * 3),
+    NOR_GATE(0, 32 * 3, 32 * 3),
+    ANALOG_MODE(0, 32 * 4, 32 * 3),
+
     SLOT_DARKGRAY(1, 176, 0, 18, 18),
     SLOT_GRAY(1, 176, 18, 18, 18),
 
diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java
index 0fdaa90c1a..7c75bb97d4 100644
--- a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java
+++ b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java
@@ -776,6 +776,8 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity
         if (hasCover) tNBT.setIntArray("mCoverSides", mCoverSides);
         if (hasValidMetaTileEntity()) mMetaTileEntity.setItemNBT(tNBT);
         if (!tNBT.hasNoTags()) rStack.setTagCompound(tNBT);
+
+        onBaseTEDestroyed();
         return new ArrayList<>(Collections.singletonList(rStack));
     }
 
diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java
index cdc81220e6..08ead9a946 100644
--- a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java
+++ b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java
@@ -1423,6 +1423,8 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity
 
         if (hasValidMetaTileEntity()) mMetaTileEntity.setItemNBT(tNBT);
         if (!tNBT.hasNoTags()) rStack.setTagCompound(tNBT);
+
+        onBaseTEDestroyed();
         return new ArrayList<>(Collections.singletonList(rStack));
     }
 
diff --git a/src/main/java/gregtech/api/metatileentity/CoverableTileEntity.java b/src/main/java/gregtech/api/metatileentity/CoverableTileEntity.java
index caf3c1b15f..9df38b2725 100644
--- a/src/main/java/gregtech/api/metatileentity/CoverableTileEntity.java
+++ b/src/main/java/gregtech/api/metatileentity/CoverableTileEntity.java
@@ -320,6 +320,14 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov
         return false;
     }
 
+    protected void onBaseTEDestroyed() {
+        for (byte side = 0; side < 6; ++side) {
+            GT_CoverBehaviorBase<?> behavior = getCoverBehaviorAtSideNew(side);
+            if (behavior != GregTech_API.sNoBehavior)
+                behavior.onBaseTEDestroyed(side, getCoverIDAtSide(side), mCoverData[side], this);
+        }
+    }
+
     @Override
     public void setOutputRedstoneSignal(byte aSide, byte aStrength) {
         aStrength = (byte) Math.min(Math.max(0, aStrength), 15);
@@ -414,10 +422,19 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov
     public void receiveCoverData(
             byte aCoverSide, int aCoverID, ISerializableObject aCoverData, EntityPlayerMP aPlayer) {
         if ((aCoverSide >= 0 && aCoverSide < 6)) {
+            GT_CoverBehaviorBase<?> behaviorBase = getCoverBehaviorAtSideNew(aCoverSide);
+            behaviorBase.preDataChanged(
+                    aCoverSide,
+                    getCoverIDAtSide(aCoverSide),
+                    aCoverID,
+                    getComplexCoverDataAtSide(aCoverSide),
+                    aCoverData,
+                    this);
+
             setCoverIDAtSideNoUpdate(aCoverSide, aCoverID);
             setCoverDataAtSide(aCoverSide, aCoverData);
             if (isClientSide()) {
-                getCoverBehaviorAtSideNew(aCoverSide).onDataChanged(aCoverSide, aCoverID, aCoverData, this);
+                behaviorBase.onDataChanged(aCoverSide, aCoverID, aCoverData, this);
             }
         }
     }
diff --git a/src/main/java/gregtech/api/multitileentity/base/BaseMultiTileEntity.java b/src/main/java/gregtech/api/multitileentity/base/BaseMultiTileEntity.java
index 18dc310bb7..385ae310f1 100644
--- a/src/main/java/gregtech/api/multitileentity/base/BaseMultiTileEntity.java
+++ b/src/main/java/gregtech/api/multitileentity/base/BaseMultiTileEntity.java
@@ -906,6 +906,8 @@ public abstract class BaseMultiTileEntity extends CoverableTileEntity
         final ArrayList<ItemStack> rList = new ArrayList<>();
         final MultiTileEntityRegistry tRegistry = MultiTileEntityRegistry.getRegistry(getMultiTileEntityRegistryID());
         if (tRegistry != null) rList.add(tRegistry.getItem(getMultiTileEntityID(), writeItemNBT(new NBTTagCompound())));
+
+        onBaseTEDestroyed();
         return rList;
     }
 
diff --git a/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java b/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java
index efbff79957..1092a24307 100644
--- a/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java
+++ b/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java
@@ -131,6 +131,20 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> {
     }
 
     /**
+     * Called before receiving data from network. Use {@link ICoverable#isClientSide()} to determine the side.
+     */
+    public final void preDataChanged(
+            byte aSide,
+            int aCoverID,
+            int aNewCoverId,
+            ISerializableObject aCoverVariable,
+            ISerializableObject aNewCoverVariable,
+            ICoverable aTileEntity) {
+        preDataChangedImpl(
+                aSide, aCoverID, aNewCoverId, forceCast(aCoverVariable), forceCast(aNewCoverVariable), aTileEntity);
+    }
+
+    /**
      * Called upon cover being removed. Called on both server and client.
      */
     public final void onDropped(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
@@ -222,6 +236,15 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> {
     }
 
     /**
+     * Called upon Base TE being destroyed (once getDrops is called),
+     * thus getting called only when destroyed in survival.
+     */
+    public final void onBaseTEDestroyed(
+            byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) {
+        onBaseTEDestroyedImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity);
+    }
+
+    /**
      * Gives a small Text for the status of the Cover.
      */
     public final String getDescription(
@@ -410,8 +433,13 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> {
 
     protected void onDataChangedImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {}
 
+    protected void preDataChangedImpl(
+            byte aSide, int aCoverID, int aNewCoverId, T aCoverVariable, T aNewCoverVariable, ICoverable aTileEntity) {}
+
     protected void onDroppedImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {}
 
+    protected void onBaseTEDestroyedImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {}
+
     protected boolean isRedstoneSensitiveImpl(
             byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, long aTimer) {
         return true;
diff --git a/src/main/java/gregtech/api/util/GT_Utility.java b/src/main/java/gregtech/api/util/GT_Utility.java
index 270619363f..c9aa55d291 100644
--- a/src/main/java/gregtech/api/util/GT_Utility.java
+++ b/src/main/java/gregtech/api/util/GT_Utility.java
@@ -4276,6 +4276,30 @@ public class GT_Utility {
         for (int i = 0; i < 25; i++) if (itemStack.isItemEqual(GT_Utility.getIntegratedCircuit(i))) return true;
         return false;
     }
+public static byte convertRatioToRedstone(long used, long max, int threshold, boolean inverted) {
+        byte signal;
+        if (used <= 0) { // Empty
+            signal = 0;
+        } else if (used >= max) { // Full
+            signal = 15;
+        } else { // Range 1-14
+            signal = (byte) (1 + (14 * used) / max);
+        }
+
+        if (inverted) {
+            signal = (byte) (15 - signal);
+        }
+
+        if (threshold > 0) {
+            if (inverted && used >= threshold) {
+                return 0;
+            } else if (!inverted && used < threshold) {
+                return 0;
+            }
+        }
+
+        return signal;
+    }
 
     @AutoValue
     public abstract static class ItemId {
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java b/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java
index 82dffaf7a8..c894857b32 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java
@@ -74,66 +74,47 @@ public class GT_Cover_ItemMeter extends GT_CoverBehaviorBase<GT_Cover_ItemMeter.
         return false;
     }
 
-    @Override
-    protected ItemMeterData doCoverThingsImpl(
-            byte aSide,
-            byte aInputRedstone,
-            int aCoverID,
-            ItemMeterData aCoverVariable,
-            ICoverable aTileEntity,
-            long aTimer) {
-        long tMax = 0;
-        long tUsed = 0;
-        IMetaTileEntity mte = ((IGregTechTileEntity) aTileEntity).getMetaTileEntity();
+    public static byte computeSignalBasedOnItems(
+            ICoverable tileEntity, boolean inverted, int threshold, int slot, int side) {
+        long max = 0;
+        long used = 0;
+        IMetaTileEntity mte = ((IGregTechTileEntity) tileEntity).getMetaTileEntity();
         if (mte instanceof GT_MetaTileEntity_DigitalChestBase) {
             GT_MetaTileEntity_DigitalChestBase dc = (GT_MetaTileEntity_DigitalChestBase) mte;
-            tMax = dc.getMaxItemCount(); // currently it is limited by int, but there is not much reason for that
-            ItemStack[] inv = dc.getStoredItemData();
-            if (inv != null && inv.length > 1 && inv[1] != null) tUsed = inv[1].stackSize;
+            max = dc.getMaxItemCount();
+            used = dc.getProgresstime();
         } else if (GregTech_API.mAE2 && mte instanceof GT_MetaTileEntity_Hatch_OutputBus_ME) {
             if (((GT_MetaTileEntity_Hatch_OutputBus_ME) mte).isLastOutputFailed()) {
-                tMax = 64;
-                tUsed = 64;
+                max = 64;
+                used = 64;
             }
         } else {
-            int[] tSlots = aCoverVariable.slot >= 0
-                    ? new int[] {aCoverVariable.slot}
-                    : aTileEntity.getAccessibleSlotsFromSide(aSide);
-
-            for (int i : tSlots) {
-                if (i >= 0 && i < aTileEntity.getSizeInventory()) {
-                    tMax += 64;
-                    ItemStack tStack = aTileEntity.getStackInSlot(i);
-                    if (tStack != null) tUsed += (tStack.stackSize << 6) / tStack.getMaxStackSize();
+            int[] slots = slot >= 0 ? new int[] {slot} : tileEntity.getAccessibleSlotsFromSide(side);
+
+            for (int i : slots) {
+                if (i >= 0 && i < tileEntity.getSizeInventory()) {
+                    max += 64;
+                    ItemStack stack = tileEntity.getStackInSlot(i);
+                    if (stack != null) used += ((long) stack.stackSize << 6) / stack.getMaxStackSize();
                 }
             }
         }
 
-        long redstoneSignal;
-        if (tUsed == 0L) {
-            // nothing
-            redstoneSignal = 0;
-        } else if (tUsed >= tMax) {
-            // full
-            redstoneSignal = 15;
-        } else {
-            // 1-14 range
-            redstoneSignal = 1 + (14 * tUsed) / tMax;
-        }
-
-        if (aCoverVariable.inverted) {
-            redstoneSignal = 15 - redstoneSignal;
-        }
+        return GT_Utility.convertRatioToRedstone(used, max, threshold, inverted);
+    }
 
-        if (aCoverVariable.threshold > 0) {
-            if (aCoverVariable.inverted && tUsed >= aCoverVariable.threshold) {
-                redstoneSignal = 0;
-            } else if (!aCoverVariable.inverted && tUsed < aCoverVariable.threshold) {
-                redstoneSignal = 0;
-            }
-        }
+    @Override
+    protected ItemMeterData doCoverThingsImpl(
+            byte aSide,
+            byte aInputRedstone,
+            int aCoverID,
+            ItemMeterData aCoverVariable,
+            ICoverable aTileEntity,
+            long aTimer) {
+        byte signal = computeSignalBasedOnItems(
+                aTileEntity, aCoverVariable.inverted, aCoverVariable.threshold, aCoverVariable.slot, aSide);
+        aTileEntity.setOutputRedstoneSignal(aSide, signal);
 
-        aTileEntity.setOutputRedstoneSignal(aSide, (byte) redstoneSignal);
         return aCoverVariable;
     }
 
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java b/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java
index ce795bdd09..48304d3fed 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java
@@ -53,6 +53,29 @@ public class GT_Cover_LiquidMeter extends GT_CoverBehaviorBase<GT_Cover_LiquidMe
         return false;
     }
 
+    public static byte computeSignalBasedOnFluid(ICoverable tileEntity, boolean inverted, int threshold) {
+        if (tileEntity instanceof IFluidHandler) {
+            FluidTankInfo[] tanks = ((IFluidHandler) tileEntity).getTankInfo(ForgeDirection.UNKNOWN);
+            long max = 0;
+            long used = 0;
+            if (tanks != null) {
+                for (FluidTankInfo tank : tanks) {
+                    if (tank != null) {
+                        max += tank.capacity;
+                        FluidStack tLiquid = tank.fluid;
+                        if (tLiquid != null) {
+                            used += tLiquid.amount;
+                        }
+                    }
+                }
+            }
+
+            return GT_Utility.convertRatioToRedstone(used, max, threshold, inverted);
+        } else {
+            return 0;
+        }
+    }
+
     @Override
     protected LiquidMeterData doCoverThingsImpl(
             byte aSide,
@@ -61,50 +84,9 @@ public class GT_Cover_LiquidMeter extends GT_CoverBehaviorBase<GT_Cover_LiquidMe
             LiquidMeterData aCoverVariable,
             ICoverable aTileEntity,
             long aTimer) {
-        if ((aTileEntity instanceof IFluidHandler)) {
-            FluidTankInfo[] tTanks = ((IFluidHandler) aTileEntity).getTankInfo(ForgeDirection.UNKNOWN);
-            long tMax = 0;
-            long tUsed = 0;
-            if (tTanks != null) {
-                for (FluidTankInfo tTank : tTanks) {
-                    if (tTank != null) {
-                        tMax += tTank.capacity;
-                        FluidStack tLiquid = tTank.fluid;
-                        if (tLiquid != null) {
-                            tUsed += tLiquid.amount;
-                        }
-                    }
-                }
-            }
-
-            long redstoneSignal;
-            if (tUsed == 0L) {
-                // nothing
-                redstoneSignal = 0;
-            } else if (tUsed >= tMax) {
-                // full
-                redstoneSignal = 15;
-            } else {
-                // 1-14 range
-                redstoneSignal = 1 + (14 * tUsed) / tMax;
-            }
-
-            if (aCoverVariable.inverted) {
-                redstoneSignal = 15 - redstoneSignal;
-            }
-
-            if (aCoverVariable.threshold > 0) {
-                if (aCoverVariable.inverted && tUsed >= aCoverVariable.threshold) {
-                    redstoneSignal = 0;
-                } else if (!aCoverVariable.inverted && tUsed < aCoverVariable.threshold) {
-                    redstoneSignal = 0;
-                }
-            }
+        byte signal = computeSignalBasedOnFluid(aTileEntity, aCoverVariable.inverted, aCoverVariable.threshold);
+        aTileEntity.setOutputRedstoneSignal(aSide, signal);
 
-            aTileEntity.setOutputRedstoneSignal(aSide, (byte) redstoneSignal);
-        } else {
-            aTileEntity.setOutputRedstoneSignal(aSide, (byte) 0);
-        }
         return aCoverVariable;
     }
 
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java b/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java
index 369778ef12..2ea5a2c951 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java
@@ -32,11 +32,11 @@ public class GT_Cover_NeedMaintainance extends GT_CoverBehavior {
         super(coverTexture);
     }
 
-    private boolean isRotor(ItemStack aRotor) {
-        return !(aRotor == null
-                || !(aRotor.getItem() instanceof GT_MetaGenerated_Tool)
-                || aRotor.getItemDamage() < 170
-                || aRotor.getItemDamage() > 176);
+    public static boolean isRotor(ItemStack rotor) {
+        return (rotor != null
+                && rotor.getItem() instanceof GT_MetaGenerated_Tool
+                && rotor.getItemDamage() >= 170
+                && rotor.getItemDamage() <= 176);
     }
 
     @Override
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java b/src/main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java
index a942d39b57..a024400094 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java
@@ -15,6 +15,7 @@ import gregtech.api.util.GT_Utility;
 import gregtech.api.util.ISerializableObject;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.fluids.Fluid;
 
 public abstract class GT_Cover_RedstoneWirelessBase extends GT_CoverBehavior {
@@ -198,10 +199,13 @@ public abstract class GT_Cover_RedstoneWirelessBase extends GT_CoverBehavior {
         private static final int spaceX = 18;
         private static final int spaceY = 18;
 
+        private static final String guiTexturePath = "gregtech:textures/gui/GuiCoverLong.png";
+
         private final int textColor = this.getTextColorOrDefault("text", 0xFF555555);
 
         public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
-            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            super(aTileEntity, 250, 107, GT_Utility.intToStack(aCoverID));
+            this.mGUIbackgroundLocation = new ResourceLocation(guiTexturePath);
             this.side = aSide;
             this.coverID = aCoverID;
             this.coverVariable = aCoverVariable;
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java
new file mode 100644
index 0000000000..233be511a3
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java
@@ -0,0 +1,193 @@
+package gregtech.common.covers.redstone;
+
+import com.google.common.io.ByteArrayDataInput;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconButton;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.ISerializableObject;
+import io.netty.buffer.ByteBuf;
+import java.util.UUID;
+import javax.annotation.Nonnull;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+
+public abstract class GT_Cover_AdvancedRedstoneReceiverBase
+        extends GT_Cover_AdvancedWirelessRedstoneBase<GT_Cover_AdvancedRedstoneReceiverBase.ReceiverData> {
+
+    public GT_Cover_AdvancedRedstoneReceiverBase(ITexture coverTexture) {
+        super(ReceiverData.class, coverTexture);
+    }
+
+    @Override
+    public ReceiverData createDataObject() {
+        return new ReceiverData();
+    }
+
+    @Override
+    public ReceiverData createDataObject(int aLegacyData) {
+        return createDataObject();
+    }
+
+    /**
+     * GUI Stuff
+     */
+    @Override
+    public Object getClientGUIImpl(
+            byte aSide,
+            int aCoverID,
+            ReceiverData aCoverVariable,
+            ICoverable aTileEntity,
+            EntityPlayer aPlayer,
+            World aWorld) {
+        return new ReceiverGUI(aSide, aCoverID, aCoverVariable, aTileEntity);
+    }
+
+    public enum GateMode {
+        AND,
+        NAND,
+        OR,
+        NOR,
+        SINGLE_SOURCE
+    }
+
+    public static class ReceiverData extends GT_Cover_AdvancedWirelessRedstoneBase.WirelessData {
+        private GateMode mode;
+
+        public ReceiverData(int frequency, UUID uuid, GateMode mode) {
+            super(frequency, uuid);
+            this.mode = mode;
+        }
+
+        public ReceiverData() {
+            this(0, null, GateMode.AND);
+        }
+
+        public GateMode getGateMode() {
+            return mode;
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject copy() {
+            return new ReceiverData(frequency, uuid, mode);
+        }
+
+        @Nonnull
+        @Override
+        public NBTBase saveDataToNBT() {
+            NBTTagCompound tag = (NBTTagCompound) super.saveDataToNBT();
+            tag.setByte("mode", (byte) mode.ordinal());
+
+            return tag;
+        }
+
+        @Override
+        public void writeToByteBuf(ByteBuf aBuf) {
+            super.writeToByteBuf(aBuf);
+            aBuf.writeByte(mode.ordinal());
+        }
+
+        @Override
+        public void loadDataFromNBT(NBTBase aNBT) {
+            super.loadDataFromNBT(aNBT);
+
+            NBTTagCompound tag = (NBTTagCompound) aNBT;
+            mode = GateMode.values()[tag.getByte("mode")];
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) {
+            super.readFromPacket(aBuf, aPlayer);
+            mode = GateMode.values()[aBuf.readByte()];
+
+            return this;
+        }
+    }
+
+    private static class ReceiverGUI extends WirelessGUI<ReceiverData> {
+
+        private static final int gateModeButtonIdStart = 1;
+
+        public ReceiverGUI(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) {
+            super(aSide, aCoverID, aCoverVariable, aTileEntity);
+
+            new GT_GuiIconButton(
+                            this,
+                            gateModeButtonIdStart + 0,
+                            startX + spaceX * 0,
+                            startY + spaceY * 2,
+                            GT_GuiIcon.AND_GATE)
+                    .setTooltipText(GT_Utility.trans("006", "AND Gate"));
+            new GT_GuiIconButton(
+                            this,
+                            gateModeButtonIdStart + 1,
+                            startX + spaceX * 1,
+                            startY + spaceY * 2,
+                            GT_GuiIcon.NAND_GATE)
+                    .setTooltipText(GT_Utility.trans("006", "NAND Gate"));
+            new GT_GuiIconButton(
+                            this,
+                            gateModeButtonIdStart + 2,
+                            startX + spaceX * 2,
+                            startY + spaceY * 2,
+                            GT_GuiIcon.OR_GATE)
+                    .setTooltipText(GT_Utility.trans("006", "OR Gate"));
+            new GT_GuiIconButton(
+                            this,
+                            gateModeButtonIdStart + 3,
+                            startX + spaceX * 3,
+                            startY + spaceY * 2,
+                            GT_GuiIcon.NOR_GATE)
+                    .setTooltipText(GT_Utility.trans("006", "NOR Gate"));
+            new GT_GuiIconButton(
+                            this,
+                            gateModeButtonIdStart + 4,
+                            startX + spaceX * 4,
+                            startY + spaceY * 2,
+                            GT_GuiIcon.ANALOG_MODE)
+                    .setTooltipText(
+                            "ANALOG Mode", "Only use this mode with ONE transmitter in total,", "no logic involved");
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            this.getFontRenderer()
+                    .drawString(
+                            GT_Utility.trans("601", "Gate Mode"),
+                            startX + spaceX * 5,
+                            4 + startY + spaceY * 2,
+                            textColor);
+        }
+
+        @Override
+        protected void update() {
+            super.update();
+            updateButtons();
+        }
+
+        private void updateButtons() {
+            GuiButton button;
+            for (int i = gateModeButtonIdStart; i < gateModeButtonIdStart + 5; ++i) {
+                button = (GuiButton) this.buttonList.get(i);
+                button.enabled = (button.id - gateModeButtonIdStart) != coverVariable.mode.ordinal();
+            }
+        }
+
+        @Override
+        public void buttonClicked(GuiButton btn) {
+            if (btn.id >= gateModeButtonIdStart && btn.enabled) {
+                coverVariable.mode = GateMode.values()[btn.id - gateModeButtonIdStart];
+            }
+
+            super.buttonClicked(btn);
+        }
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverExternal.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverExternal.java
new file mode 100644
index 0000000000..56b7fadd24
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverExternal.java
@@ -0,0 +1,38 @@
+package gregtech.common.covers.redstone;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ICoverable;
+
+public class GT_Cover_AdvancedRedstoneReceiverExternal extends GT_Cover_AdvancedRedstoneReceiverBase {
+
+    public GT_Cover_AdvancedRedstoneReceiverExternal(ITexture coverTexture) {
+        super(coverTexture);
+    }
+
+    @Override
+    public ReceiverData doCoverThingsImpl(
+            byte aSide,
+            byte aInputRedstone,
+            int aCoverID,
+            ReceiverData aCoverVariable,
+            ICoverable aTileEntity,
+            long aTimer) {
+        aTileEntity.setOutputRedstoneSignal(
+                aSide,
+                getSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), aCoverVariable.getGateMode()));
+
+        return aCoverVariable;
+    }
+
+    @Override
+    protected boolean isRedstoneSensitiveImpl(
+            byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity, long aTimer) {
+        return false;
+    }
+
+    @Override
+    protected boolean manipulatesSidedRedstoneOutputImpl(
+            byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverInternal.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverInternal.java
new file mode 100644
index 0000000000..c3537350a6
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverInternal.java
@@ -0,0 +1,40 @@
+package gregtech.common.covers.redstone;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.interfaces.tileentity.IMachineProgress;
+
+public class GT_Cover_AdvancedRedstoneReceiverInternal extends GT_Cover_AdvancedRedstoneReceiverBase {
+
+    public GT_Cover_AdvancedRedstoneReceiverInternal(ITexture coverTexture) {
+        super(coverTexture);
+    }
+
+    @Override
+    public ReceiverData doCoverThingsImpl(
+            byte aSide,
+            byte aInputRedstone,
+            int aCoverID,
+            ReceiverData aCoverVariable,
+            ICoverable aTileEntity,
+            long aTimer) {
+        if (aTileEntity instanceof IMachineProgress) {
+            IMachineProgress machine = ((IMachineProgress) aTileEntity);
+            if (getRedstoneInput(aSide, aInputRedstone, aCoverID, aCoverVariable, aTileEntity) > 0) {
+                machine.enableWorking();
+            } else {
+                machine.disableWorking();
+            }
+
+            machine.setWorkDataValue(aInputRedstone);
+        }
+
+        return aCoverVariable;
+    }
+
+    @Override
+    protected byte getRedstoneInputImpl(
+            byte aSide, byte aInputRedstone, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) {
+        return getSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), aCoverVariable.getGateMode());
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java
new file mode 100644
index 0000000000..07592a00dc
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java
@@ -0,0 +1,192 @@
+package gregtech.common.covers.redstone;
+
+import com.google.common.io.ByteArrayDataInput;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconCheckButton;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.ISerializableObject;
+import io.netty.buffer.ByteBuf;
+import java.util.Objects;
+import java.util.UUID;
+import javax.annotation.Nonnull;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+
+public abstract class GT_Cover_AdvancedRedstoneTransmitterBase<
+                T extends GT_Cover_AdvancedRedstoneTransmitterBase.TransmitterData>
+        extends GT_Cover_AdvancedWirelessRedstoneBase<T> {
+
+    public GT_Cover_AdvancedRedstoneTransmitterBase(Class<T> typeToken, ITexture coverTexture) {
+        super(typeToken, coverTexture);
+    }
+
+    private static void unregisterSignal(byte aSide, TransmitterData aCoverVariable, ICoverable aTileEntity) {
+        long hash = hashCoverCoords(aTileEntity, aSide);
+        removeSignalAt(aCoverVariable.uuid, aCoverVariable.frequency, hash);
+    }
+
+    @Override
+    public boolean onCoverRemovalImpl(
+            byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity, boolean aForced) {
+        unregisterSignal(aSide, aCoverVariable, aTileEntity);
+        return true;
+    }
+
+    @Override
+    protected void onBaseTEDestroyedImpl(
+            byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) {
+        unregisterSignal(aSide, aCoverVariable, aTileEntity);
+    }
+
+    @Override
+    protected T onCoverScrewdriverClickImpl(
+            byte aSide,
+            int aCoverID,
+            T aCoverVariable,
+            ICoverable aTileEntity,
+            EntityPlayer aPlayer,
+            float aX,
+            float aY,
+            float aZ) {
+        aCoverVariable.invert = !aCoverVariable.invert;
+        GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("055", aCoverVariable.invert ? "Inverted" : "Normal"));
+
+        return aCoverVariable;
+    }
+
+    @Override
+    protected void preDataChangedImpl(
+            byte aSide, int aCoverID, int aNewCoverId, T aCoverVariable, T aNewCoverVariable, ICoverable aTileEntity) {
+        if (aCoverVariable.frequency != aNewCoverVariable.frequency
+                || !Objects.equals(aCoverVariable.uuid, aNewCoverVariable.uuid)) {
+            unregisterSignal(aSide, aCoverVariable, aTileEntity);
+        }
+    }
+
+    public static class TransmitterData extends GT_Cover_AdvancedWirelessRedstoneBase.WirelessData {
+        protected boolean invert;
+
+        public TransmitterData(int frequency, UUID uuid, boolean invert) {
+            super(frequency, uuid);
+            this.invert = invert;
+        }
+
+        public TransmitterData() {
+            this(0, null, false);
+        }
+
+        public boolean isInvert() {
+            return invert;
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject copy() {
+            return new TransmitterData(frequency, uuid, invert);
+        }
+
+        @Nonnull
+        @Override
+        public NBTBase saveDataToNBT() {
+            NBTTagCompound tag = (NBTTagCompound) super.saveDataToNBT();
+            tag.setBoolean("invert", invert);
+
+            return tag;
+        }
+
+        @Override
+        public void writeToByteBuf(ByteBuf aBuf) {
+            super.writeToByteBuf(aBuf);
+            aBuf.writeBoolean(invert);
+        }
+
+        @Override
+        public void loadDataFromNBT(NBTBase aNBT) {
+            super.loadDataFromNBT(aNBT);
+
+            NBTTagCompound tag = (NBTTagCompound) aNBT;
+            invert = tag.getBoolean("invert");
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) {
+            super.readFromPacket(aBuf, aPlayer);
+            invert = aBuf.readBoolean();
+
+            return this;
+        }
+    }
+
+    /**
+     * GUI Stuff
+     */
+    @Override
+    public Object getClientGUIImpl(
+            byte aSide,
+            int aCoverID,
+            TransmitterData aCoverVariable,
+            ICoverable aTileEntity,
+            EntityPlayer aPlayer,
+            World aWorld) {
+        return new TransmitterGUI<>(aSide, aCoverID, aCoverVariable, aTileEntity);
+    }
+
+    protected class TransmitterGUI<X extends TransmitterData> extends WirelessGUI<X> {
+
+        private final GT_GuiIconCheckButton invertButton;
+
+        private final String INVERTED = GT_Utility.trans("INVERTED", "Inverted");
+        private final String NORMAL = GT_Utility.trans("NORMAL", "Normal");
+
+        public TransmitterGUI(
+                byte aSide, int aCoverID, X aCoverVariable, ICoverable aTileEntity, int frequencyRow, int buttonRow) {
+            super(aSide, aCoverID, aCoverVariable, aTileEntity, frequencyRow, buttonRow, true);
+            invertButton = new GT_GuiIconCheckButton(
+                    this,
+                    1,
+                    startX + spaceX * 9,
+                    startY + spaceY * buttonRow,
+                    GT_GuiIcon.REDSTONE_ON,
+                    GT_GuiIcon.REDSTONE_OFF,
+                    INVERTED,
+                    NORMAL);
+        }
+
+        public TransmitterGUI(byte aSide, int aCoverID, X aCoverVariable, ICoverable aTileEntity) {
+            this(aSide, aCoverID, aCoverVariable, aTileEntity, 0, 1);
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            this.getFontRenderer()
+                    .drawString(
+                            coverVariable.invert ? INVERTED : NORMAL,
+                            startX + spaceX * 10,
+                            4 + startY + spaceY * buttonRow,
+                            textColor);
+        }
+
+        @Override
+        protected void update() {
+            super.update();
+            invertButton.setChecked(coverVariable.invert);
+        }
+
+        @Override
+        public void buttonClicked(GuiButton btn) {
+            if (btn == invertButton) {
+                coverVariable.invert = !coverVariable.invert;
+            }
+
+            super.buttonClicked(btn);
+        }
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java
new file mode 100644
index 0000000000..aaa526e565
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java
@@ -0,0 +1,48 @@
+package gregtech.common.covers.redstone;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ICoverable;
+
+public class GT_Cover_AdvancedRedstoneTransmitterExternal
+        extends GT_Cover_AdvancedRedstoneTransmitterBase<GT_Cover_AdvancedRedstoneTransmitterBase.TransmitterData> {
+
+    public GT_Cover_AdvancedRedstoneTransmitterExternal(ITexture coverTexture) {
+        super(TransmitterData.class, coverTexture);
+    }
+
+    @Override
+    public TransmitterData createDataObject() {
+        return new TransmitterData();
+    }
+
+    @Override
+    public TransmitterData createDataObject(int aLegacyData) {
+        return createDataObject();
+    }
+
+    @Override
+    public TransmitterData doCoverThingsImpl(
+            byte aSide,
+            byte aInputRedstone,
+            int aCoverID,
+            TransmitterData aCoverVariable,
+            ICoverable aTileEntity,
+            long aTimer) {
+        byte outputRedstone = aInputRedstone;
+        if (aCoverVariable.isInvert()) {
+            if (outputRedstone > 0) outputRedstone = 0;
+            else outputRedstone = 15;
+        }
+
+        long hash = hashCoverCoords(aTileEntity, aSide);
+        setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, outputRedstone);
+
+        return aCoverVariable;
+    }
+
+    @Override
+    public boolean letsRedstoneGoInImpl(
+            byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java
new file mode 100644
index 0000000000..1d21b7060f
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java
@@ -0,0 +1,53 @@
+package gregtech.common.covers.redstone;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ICoverable;
+
+public class GT_Cover_AdvancedRedstoneTransmitterInternal
+        extends GT_Cover_AdvancedRedstoneTransmitterBase<GT_Cover_AdvancedRedstoneTransmitterBase.TransmitterData> {
+
+    public GT_Cover_AdvancedRedstoneTransmitterInternal(ITexture coverTexture) {
+        super(TransmitterData.class, coverTexture);
+    }
+
+    @Override
+    public TransmitterData createDataObject() {
+        return new TransmitterData();
+    }
+
+    @Override
+    public TransmitterData createDataObject(int aLegacyData) {
+        return createDataObject();
+    }
+
+    @Override
+    public TransmitterData doCoverThingsImpl(
+            byte aSide,
+            byte aInputRedstone,
+            int aCoverID,
+            TransmitterData aCoverVariable,
+            ICoverable aTileEntity,
+            long aTimer) {
+        byte outputRedstone = aTileEntity.getOutputRedstoneSignal(aSide);
+        if (aCoverVariable.isInvert()) {
+            if (outputRedstone > 0) outputRedstone = 0;
+            else outputRedstone = 15;
+        }
+
+        long hash = hashCoverCoords(aTileEntity, aSide);
+        setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, outputRedstone);
+        return aCoverVariable;
+    }
+
+    @Override
+    public boolean letsRedstoneGoOutImpl(
+            byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected boolean manipulatesSidedRedstoneOutputImpl(
+            byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedWirelessRedstoneBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedWirelessRedstoneBase.java
new file mode 100644
index 0000000000..a3f37e5f28
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedWirelessRedstoneBase.java
@@ -0,0 +1,443 @@
+package gregtech.common.covers.redstone;
+
+import com.google.common.io.ByteArrayDataInput;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconCheckButton;
+import gregtech.api.gui.widgets.GT_GuiIntegerTextBox;
+import gregtech.api.interfaces.IGuiScreen;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.net.GT_Packet_TileEntityCoverNew;
+import gregtech.api.util.GT_CoverBehaviorBase;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.ISerializableObject;
+import io.netty.buffer.ByteBuf;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fluids.Fluid;
+
+public abstract class GT_Cover_AdvancedWirelessRedstoneBase<
+                T extends GT_Cover_AdvancedWirelessRedstoneBase.WirelessData>
+        extends GT_CoverBehaviorBase<T> {
+
+    public GT_Cover_AdvancedWirelessRedstoneBase(Class<T> typeToken, ITexture coverTexture) {
+        super(typeToken, coverTexture);
+    }
+
+    public static Byte getSignalAt(UUID uuid, int frequency, GT_Cover_AdvancedRedstoneReceiverBase.GateMode mode) {
+        Map<Integer, Map<Long, Byte>> frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid));
+        if (frequencies == null) return 0;
+
+        Map<Long, Byte> signals = frequencies.get(frequency);
+        if (signals == null) signals = new ConcurrentHashMap<>();
+
+        switch (mode) {
+            case AND:
+                return (byte)
+                        (signals.values().stream()
+                                        .map(signal -> signal > 0)
+                                        .reduce(true, (signalA, signalB) -> signalA && signalB)
+                                ? 15
+                                : 0);
+            case NAND:
+                return (byte)
+                        (signals.values().stream()
+                                        .map(signal -> signal > 0)
+                                        .reduce(true, (signalA, signalB) -> signalA && signalB)
+                                ? 0
+                                : 15);
+            case OR:
+                return (byte)
+                        (signals.values().stream()
+                                        .map(signal -> signal > 0)
+                                        .reduce(false, (signalA, signalB) -> signalA || signalB)
+                                ? 15
+                                : 0);
+            case NOR:
+                return (byte)
+                        (signals.values().stream()
+                                        .map(signal -> signal > 0)
+                                        .reduce(false, (signalA, signalB) -> signalA || signalB)
+                                ? 0
+                                : 15);
+            case SINGLE_SOURCE:
+                if (signals.values().isEmpty()) {
+                    return 0;
+                }
+
+                return (Byte) signals.values().toArray()[0];
+            default:
+                return 0;
+        }
+    }
+
+    public static void removeSignalAt(UUID uuid, int frequency, long hash) {
+        Map<Integer, Map<Long, Byte>> frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid));
+        if (frequencies == null) return;
+        frequencies.computeIfPresent(frequency, (freq, longByteMap) -> {
+            longByteMap.remove(hash);
+            return longByteMap.isEmpty() ? null : longByteMap;
+        });
+    }
+
+    public static void setSignalAt(UUID uuid, int frequency, long hash, byte value) {
+        Map<Integer, Map<Long, Byte>> frequencies = GregTech_API.sAdvancedWirelessRedstone.computeIfAbsent(
+                String.valueOf(uuid), k -> new ConcurrentHashMap<>());
+        Map<Long, Byte> signals = frequencies.computeIfAbsent(frequency, k -> new ConcurrentHashMap<>());
+        signals.put(hash, value);
+    }
+
+    /**
+     *  x    hashed into first 20 bytes
+     *  y    hashed into second 20 bytes
+     *  z    hashed into fifth 10 bytes
+     *  dim  hashed into sixth 10 bytes
+     *  side hashed into last 4 bytes
+     */
+    public static long hashCoverCoords(ICoverable tile, byte side) {
+        return (((((long) tile.getXCoord() << 20) + tile.getZCoord() << 10) + tile.getYCoord() << 10)
+                                + tile.getWorld().provider.dimensionId
+                        << 4)
+                + side;
+    }
+
+    @Override
+    public boolean letsEnergyInImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public boolean letsEnergyOutImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public boolean letsFluidInImpl(byte aSide, int aCoverID, T aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public boolean letsFluidOutImpl(byte aSide, int aCoverID, T aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public boolean letsItemsInImpl(byte aSide, int aCoverID, T aCoverVariable, int aSlot, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public boolean letsItemsOutImpl(byte aSide, int aCoverID, T aCoverVariable, int aSlot, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public String getDescriptionImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return GT_Utility.trans("081", "Frequency: ") + aCoverVariable.frequency + ", Transmission: "
+                + (aCoverVariable.uuid == null ? "Public" : "Private");
+    }
+
+    @Override
+    public int getTickRateImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {
+        return 5;
+    }
+
+    public abstract static class WirelessData implements ISerializableObject {
+        protected int frequency;
+
+        /**
+         * If UUID is set to null, the cover frequency is public, rather than private
+         **/
+        protected UUID uuid;
+
+        public WirelessData(int frequency, UUID uuid) {
+            this.frequency = frequency;
+            this.uuid = uuid;
+        }
+
+        public UUID getUuid() {
+            return uuid;
+        }
+
+        public int getFrequency() {
+            return frequency;
+        }
+
+        @Nonnull
+        @Override
+        public NBTBase saveDataToNBT() {
+            NBTTagCompound tag = new NBTTagCompound();
+            tag.setInteger("frequency", frequency);
+            if (uuid != null) {
+                tag.setString("uuid", uuid.toString());
+            }
+
+            return tag;
+        }
+
+        @Override
+        public void writeToByteBuf(ByteBuf aBuf) {
+            aBuf.writeInt(frequency);
+            aBuf.writeBoolean(uuid != null);
+            if (uuid != null) {
+                aBuf.writeLong(uuid.getLeastSignificantBits());
+                aBuf.writeLong(uuid.getMostSignificantBits());
+            }
+        }
+
+        @Override
+        public void loadDataFromNBT(NBTBase aNBT) {
+            NBTTagCompound tag = (NBTTagCompound) aNBT;
+            frequency = tag.getInteger("frequency");
+            if (tag.hasKey("uuid")) {
+                uuid = UUID.fromString(tag.getString("uuid"));
+            }
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) {
+            frequency = aBuf.readInt();
+            if (aBuf.readBoolean()) {
+                uuid = new UUID(aBuf.readLong(), aBuf.readLong());
+            }
+
+            return this;
+        }
+    }
+
+    /**
+     * GUI Stuff
+     */
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    protected abstract static class WirelessGUI<X extends WirelessData> extends GT_GUICover {
+
+        protected final byte side;
+        protected final int coverID;
+        protected final GT_GuiIntegerTextBox frequencyBox;
+        protected final GT_GuiIconCheckButton privateButton;
+        protected final X coverVariable;
+
+        protected static final int startX = 10;
+        protected static final int startY = 25;
+        protected static final int spaceX = 18;
+        protected static final int spaceY = 18;
+
+        protected final int frequencyRow;
+        protected final int buttonRow;
+        private final int privateExtraColumn;
+
+        protected final int textColor = this.getTextColorOrDefault("text", 0xFF555555);
+
+        private static final String guiTexturePath = "gregtech:textures/gui/GuiCoverLong.png";
+
+        public WirelessGUI(
+                byte aSide,
+                int aCoverID,
+                X aCoverVariable,
+                ICoverable aTileEntity,
+                int frequencyRow,
+                int buttonRow,
+                boolean shiftPrivateLeft) {
+            super(aTileEntity, 250, 107, GT_Utility.intToStack(aCoverID));
+            this.mGUIbackgroundLocation = new ResourceLocation(guiTexturePath);
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+            this.frequencyRow = frequencyRow;
+            this.buttonRow = buttonRow;
+            this.privateExtraColumn = shiftPrivateLeft ? 1 : 5;
+
+            frequencyBox =
+                    new GT_GuiShortTextBox(this, 0, 1 + startX, 2 + startY + spaceY * frequencyRow, spaceX * 5 - 4, 12);
+            privateButton =
+                    new GT_GuiIconCheckButton(this, 0, startX, startY + spaceY * buttonRow, GT_GuiIcon.CHECKMARK, null);
+        }
+
+        public WirelessGUI(byte aSide, int aCoverID, X aCoverVariable, ICoverable aTileEntity) {
+            this(aSide, aCoverID, aCoverVariable, aTileEntity, 0, 1, false);
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            this.getFontRenderer()
+                    .drawString(
+                            GT_Utility.trans("246", "Frequency"),
+                            startX + spaceX * 5,
+                            4 + startY + spaceY * frequencyRow,
+                            textColor);
+            this.getFontRenderer()
+                    .drawString(
+                            GT_Utility.trans("601", "Use Private Frequency"),
+                            startX + spaceX * privateExtraColumn,
+                            4 + startY + spaceY * buttonRow,
+                            textColor);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            update();
+            frequencyBox.setFocused(true);
+        }
+
+        protected void genericMouseWheel(
+                GT_GuiIntegerTextBox box,
+                int delta,
+                int minValue,
+                int maxValue,
+                int baseStep,
+                int ctrlStep,
+                int shiftStep) {
+            long step = Math.max(1, Math.abs(delta / 120));
+            step = (isShiftKeyDown() ? shiftStep : isCtrlKeyDown() ? ctrlStep : baseStep) * (delta > 0 ? step : -step);
+
+            long value = parseTextBox(box, minValue, maxValue) + step;
+            if (value > maxValue) value = maxValue;
+            else if (value < minValue) value = minValue;
+
+            box.setText(Long.toString(value));
+        }
+
+        protected void genericMouseWheel(GT_GuiIntegerTextBox box, int delta, int minValue, int maxValue) {
+            genericMouseWheel(box, delta, minValue, maxValue, 1, 50, 1000);
+        }
+
+        @Override
+        public void onMouseWheel(int x, int y, int delta) {
+            if (frequencyBox.isFocused()) {
+                genericMouseWheel(frequencyBox, delta, 0, Integer.MAX_VALUE);
+            }
+        }
+
+        @Override
+        public void applyTextBox(GT_GuiIntegerTextBox box) {
+            if (box == frequencyBox) {
+                coverVariable.frequency = parseTextBox(frequencyBox);
+            }
+
+            GT_Values.NW.sendToServer(new GT_Packet_TileEntityCoverNew(side, coverID, coverVariable, tile));
+            update();
+        }
+
+        @Override
+        public void resetTextBox(GT_GuiIntegerTextBox box) {
+            if (box == frequencyBox) {
+                frequencyBox.setText(Integer.toString(coverVariable.frequency));
+            }
+        }
+
+        protected void update() {
+            privateButton.setChecked(coverVariable.uuid != null);
+            resetTextBox(frequencyBox);
+        }
+
+        @Override
+        public void buttonClicked(GuiButton btn) {
+            if (btn == privateButton) {
+                coverVariable.uuid = coverVariable.uuid == null
+                        ? Minecraft.getMinecraft().thePlayer.getUniqueID()
+                        : null;
+            }
+
+            GT_Values.NW.sendToServer(new GT_Packet_TileEntityCoverNew(side, coverID, coverVariable, tile));
+            update();
+        }
+
+        protected int parseTextBox(GT_GuiIntegerTextBox box, int min, int max) {
+            String text = box.getText();
+            if (text == null) {
+                return 0;
+            }
+
+            long value;
+            try {
+                value = Long.parseLong(text.trim());
+            } catch (NumberFormatException e) {
+                return 0;
+            }
+
+            if (value >= max) return max;
+            else if (value < min) return min;
+            return (int) value;
+        }
+
+        protected int parseTextBox(GT_GuiIntegerTextBox box) {
+            return parseTextBox(box, 0, Integer.MAX_VALUE);
+        }
+
+        protected class GT_GuiShortTextBox extends GT_GuiIntegerTextBox {
+
+            private final int min;
+            private final int max;
+            private final Map<String, String> translation;
+            private final Map<String, String> inverseTranslation;
+
+            public GT_GuiShortTextBox(
+                    IGuiScreen gui,
+                    int id,
+                    int x,
+                    int y,
+                    int width,
+                    int height,
+                    int min,
+                    int max,
+                    Map<String, String> translate) {
+                super(gui, id, x, y, width, height);
+                this.min = min;
+                this.max = max;
+                this.translation = translate;
+                this.inverseTranslation =
+                        translate.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
+            }
+
+            public GT_GuiShortTextBox(IGuiScreen gui, int id, int x, int y, int width, int height, int min, int max) {
+                this(gui, id, x, y, width, height, min, max, new HashMap<>());
+            }
+
+            public GT_GuiShortTextBox(IGuiScreen gui, int id, int x, int y, int width, int height) {
+                this(gui, id, x, y, width, height, 0, Integer.MAX_VALUE);
+            }
+
+            @Override
+            public boolean textboxKeyTyped(char c, int key) {
+                if (!super.textboxKeyTyped(c, key)) return false;
+
+                String text = getText().trim();
+                if (text.length() > 0) {
+                    setText(String.valueOf(parseTextBox(this, min, max)));
+                }
+
+                return true;
+            }
+
+            @Override
+            public String getText() {
+                String text = super.getText();
+                return inverseTranslation.getOrDefault(text, text);
+            }
+
+            @Override
+            public void setText(String text) {
+                super.setText(translation.getOrDefault(text, text));
+            }
+        }
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessFluidDetector.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessFluidDetector.java
new file mode 100644
index 0000000000..2f4e57647d
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessFluidDetector.java
@@ -0,0 +1,185 @@
+package gregtech.common.covers.redstone;
+
+import com.google.common.io.ByteArrayDataInput;
+import gregtech.api.gui.widgets.GT_GuiIntegerTextBox;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.ISerializableObject;
+import gregtech.common.covers.GT_Cover_LiquidMeter;
+import io.netty.buffer.ByteBuf;
+import java.util.UUID;
+import javax.annotation.Nonnull;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+
+public class GT_Cover_WirelessFluidDetector
+        extends GT_Cover_AdvancedRedstoneTransmitterBase<GT_Cover_WirelessFluidDetector.FluidTransmitterData> {
+
+    public GT_Cover_WirelessFluidDetector(ITexture coverTexture) {
+        super(FluidTransmitterData.class, coverTexture);
+    }
+
+    @Override
+    public FluidTransmitterData createDataObject() {
+        return new FluidTransmitterData();
+    }
+
+    @Override
+    public FluidTransmitterData createDataObject(int aLegacyData) {
+        return createDataObject();
+    }
+
+    @Override
+    public FluidTransmitterData doCoverThingsImpl(
+            byte aSide,
+            byte aInputRedstone,
+            int aCoverID,
+            FluidTransmitterData aCoverVariable,
+            ICoverable aTileEntity,
+            long aTimer) {
+        byte signal = GT_Cover_LiquidMeter.computeSignalBasedOnFluid(
+                aTileEntity, aCoverVariable.invert, aCoverVariable.threshold);
+        long hash = hashCoverCoords(aTileEntity, aSide);
+        setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, signal);
+
+        return aCoverVariable;
+    }
+
+    @Override
+    public boolean letsRedstoneGoOutImpl(
+            byte aSide, int aCoverID, FluidTransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected boolean manipulatesSidedRedstoneOutputImpl(
+            byte aSide, int aCoverID, FluidTransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    public static class FluidTransmitterData extends GT_Cover_AdvancedRedstoneTransmitterBase.TransmitterData {
+        /** The special value {@code 0} means threshold check is disabled. */
+        private int threshold;
+
+        public FluidTransmitterData(int frequency, UUID uuid, boolean invert, int threshold) {
+            super(frequency, uuid, invert);
+            this.threshold = threshold;
+        }
+
+        public FluidTransmitterData() {
+            super();
+            this.threshold = 0;
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject copy() {
+            return new FluidTransmitterData(frequency, uuid, invert, threshold);
+        }
+
+        @Nonnull
+        @Override
+        public NBTBase saveDataToNBT() {
+            NBTTagCompound tag = (NBTTagCompound) super.saveDataToNBT();
+            tag.setInteger("threshold", threshold);
+
+            return tag;
+        }
+
+        @Override
+        public void writeToByteBuf(ByteBuf aBuf) {
+            super.writeToByteBuf(aBuf);
+            aBuf.writeInt(threshold);
+        }
+
+        @Override
+        public void loadDataFromNBT(NBTBase aNBT) {
+            super.loadDataFromNBT(aNBT);
+
+            NBTTagCompound tag = (NBTTagCompound) aNBT;
+            threshold = tag.getInteger("threshold");
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) {
+            super.readFromPacket(aBuf, aPlayer);
+            threshold = aBuf.readInt();
+
+            return this;
+        }
+    }
+
+    /**
+     * GUI Stuff
+     */
+    @Override
+    public Object getClientGUIImpl(
+            byte aSide,
+            int aCoverID,
+            FluidTransmitterData aCoverVariable,
+            ICoverable aTileEntity,
+            EntityPlayer aPlayer,
+            World aWorld) {
+        return new FluidTransmitterGUI(aSide, aCoverID, aCoverVariable, aTileEntity);
+    }
+
+    private class FluidTransmitterGUI extends TransmitterGUI<FluidTransmitterData> {
+        private final GT_GuiIntegerTextBox thresholdBox;
+
+        public FluidTransmitterGUI(
+                byte aSide, int aCoverID, FluidTransmitterData aCoverVariable, ICoverable aTileEntity) {
+            super(aSide, aCoverID, aCoverVariable, aTileEntity, 1, 2);
+
+            thresholdBox = new GT_GuiShortTextBox(this, 1, 1 + startX, 2 + startY, spaceX * 5 - 4, 12);
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            this.getFontRenderer()
+                    .drawString(GT_Utility.trans("222", "Fluid Threshold"), startX + spaceX * 5, 4 + startY, textColor);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            update();
+            thresholdBox.setFocused(true);
+        }
+
+        @Override
+        public void onMouseWheel(int x, int y, int delta) {
+            super.onMouseWheel(x, y, delta);
+            if (thresholdBox.isFocused()) {
+                genericMouseWheel(thresholdBox, delta, 0, Integer.MAX_VALUE);
+            }
+        }
+
+        @Override
+        public void applyTextBox(GT_GuiIntegerTextBox box) {
+            if (box == thresholdBox) {
+                coverVariable.threshold = parseTextBox(thresholdBox);
+            }
+
+            super.applyTextBox(box);
+        }
+
+        @Override
+        public void resetTextBox(GT_GuiIntegerTextBox box) {
+            super.resetTextBox(box);
+            if (box == thresholdBox) {
+                thresholdBox.setText(Integer.toString(coverVariable.threshold));
+            }
+        }
+
+        @Override
+        protected void update() {
+            super.update();
+            resetTextBox(thresholdBox);
+        }
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessItemDetector.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessItemDetector.java
new file mode 100644
index 0000000000..2e632f5dd2
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessItemDetector.java
@@ -0,0 +1,260 @@
+package gregtech.common.covers.redstone;
+
+import com.google.common.io.ByteArrayDataInput;
+import gregtech.api.gui.widgets.GT_GuiFakeItemButton;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIntegerTextBox;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.ISerializableObject;
+import gregtech.common.covers.GT_Cover_ItemMeter;
+import gregtech.common.tileentities.storage.GT_MetaTileEntity_DigitalChestBase;
+import io.netty.buffer.ByteBuf;
+import java.util.Collections;
+import java.util.UUID;
+import javax.annotation.Nonnull;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+
+public class GT_Cover_WirelessItemDetector
+        extends GT_Cover_AdvancedRedstoneTransmitterBase<GT_Cover_WirelessItemDetector.ItemTransmitterData> {
+
+    public GT_Cover_WirelessItemDetector(ITexture coverTexture) {
+        super(ItemTransmitterData.class, coverTexture);
+    }
+
+    @Override
+    public ItemTransmitterData createDataObject() {
+        return new ItemTransmitterData();
+    }
+
+    @Override
+    public ItemTransmitterData createDataObject(int aLegacyData) {
+        return createDataObject();
+    }
+
+    @Override
+    public ItemTransmitterData doCoverThingsImpl(
+            byte aSide,
+            byte aInputRedstone,
+            int aCoverID,
+            ItemTransmitterData aCoverVariable,
+            ICoverable aTileEntity,
+            long aTimer) {
+        byte signal = GT_Cover_ItemMeter.computeSignalBasedOnItems(
+                aTileEntity, aCoverVariable.invert, aCoverVariable.threshold, aCoverVariable.slot, aSide);
+        long hash = hashCoverCoords(aTileEntity, aSide);
+        setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, signal);
+
+        return aCoverVariable;
+    }
+
+    @Override
+    public boolean letsRedstoneGoOutImpl(
+            byte aSide, int aCoverID, ItemTransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected boolean manipulatesSidedRedstoneOutputImpl(
+            byte aSide, int aCoverID, ItemTransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    public static class ItemTransmitterData extends GT_Cover_AdvancedRedstoneTransmitterBase.TransmitterData {
+        /**
+         * The special value {@code -1} means all slots.
+         */
+        private int slot;
+        /**
+         * The special value {@code 0} means threshold check is disabled.
+         */
+        private int threshold;
+
+        public ItemTransmitterData(int frequency, UUID uuid, boolean invert, int threshold, int slot) {
+            super(frequency, uuid, invert);
+            this.threshold = threshold;
+            this.slot = slot;
+        }
+
+        public ItemTransmitterData() {
+            super();
+            this.threshold = 0;
+            this.slot = -1;
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject copy() {
+            return new ItemTransmitterData(frequency, uuid, invert, threshold, slot);
+        }
+
+        @Nonnull
+        @Override
+        public NBTBase saveDataToNBT() {
+            NBTTagCompound tag = (NBTTagCompound) super.saveDataToNBT();
+            tag.setInteger("threshold", threshold);
+            tag.setInteger("slot", slot);
+
+            return tag;
+        }
+
+        @Override
+        public void writeToByteBuf(ByteBuf aBuf) {
+            super.writeToByteBuf(aBuf);
+            aBuf.writeInt(threshold);
+            aBuf.writeInt(slot);
+        }
+
+        @Override
+        public void loadDataFromNBT(NBTBase aNBT) {
+            super.loadDataFromNBT(aNBT);
+
+            NBTTagCompound tag = (NBTTagCompound) aNBT;
+            threshold = tag.getInteger("threshold");
+            slot = tag.getInteger("slot");
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) {
+            super.readFromPacket(aBuf, aPlayer);
+            threshold = aBuf.readInt();
+            slot = aBuf.readInt();
+
+            return this;
+        }
+    }
+
+    /**
+     * GUI Stuff
+     */
+    @Override
+    public Object getClientGUIImpl(
+            byte aSide,
+            int aCoverID,
+            ItemTransmitterData aCoverVariable,
+            ICoverable aTileEntity,
+            EntityPlayer aPlayer,
+            World aWorld) {
+        return new ItemTransmitterGUI(aSide, aCoverID, aCoverVariable, aTileEntity);
+    }
+
+    private class ItemTransmitterGUI extends TransmitterGUI<ItemTransmitterData> {
+        private final GT_GuiIntegerTextBox thresholdBox;
+        private final GT_GuiIntegerTextBox slotBox;
+
+        private final GT_GuiFakeItemButton fakeItemSlot;
+
+        private final int maxSlot;
+
+        public ItemTransmitterGUI(
+                byte aSide, int aCoverID, ItemTransmitterData aCoverVariable, ICoverable aTileEntity) {
+            super(aSide, aCoverID, aCoverVariable, aTileEntity, 0, 1);
+
+            if (tile instanceof TileEntity
+                    && !super.tile.isDead()
+                    && tile instanceof IGregTechTileEntity
+                    && !(((IGregTechTileEntity) tile).getMetaTileEntity()
+                            instanceof GT_MetaTileEntity_DigitalChestBase)) {
+                maxSlot = tile.getSizeInventory() - 1;
+            } else {
+                maxSlot = -1;
+            }
+
+            thresholdBox = new GT_GuiShortTextBox(
+                    this, 1, 1 + startX, 2 + startY + spaceY * 2, spaceX * 5 - 4, 12, 0, getMaxCount());
+            slotBox = new GT_GuiShortTextBox(
+                    this,
+                    2,
+                    1 + startX,
+                    2 + startY + spaceY * 3,
+                    spaceX * 4 - 8,
+                    12,
+                    -1,
+                    maxSlot,
+                    Collections.singletonMap("-1", "All"));
+            fakeItemSlot =
+                    new GT_GuiFakeItemButton(this, startX + spaceX * 4 - 1, startY + spaceY * 3, GT_GuiIcon.SLOT_GRAY);
+
+            slotBox.setEnabled(maxSlot >= 0);
+            fakeItemSlot.setMimicSlot(true);
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            this.getFontRenderer()
+                    .drawString(
+                            GT_Utility.trans("221", "Item Threshold"),
+                            startX + spaceX * 5,
+                            4 + startY + spaceY * 2,
+                            textColor);
+            this.getFontRenderer()
+                    .drawString(
+                            GT_Utility.trans("254", "Detect Slot"),
+                            startX + spaceX * 5,
+                            4 + startY + spaceY * 3,
+                            textColor);
+        }
+
+        @Override
+        public void onMouseWheel(int x, int y, int delta) {
+            super.onMouseWheel(x, y, delta);
+            if (thresholdBox.isFocused()) {
+                genericMouseWheel(thresholdBox, delta, 0, getMaxCount(), 1, 10, 64);
+            } else if (slotBox.isFocused()) {
+                genericMouseWheel(slotBox, delta, -1, maxSlot, 1, 5, 50);
+            }
+        }
+
+        @Override
+        public void applyTextBox(GT_GuiIntegerTextBox box) {
+            if (box == thresholdBox) {
+                coverVariable.threshold = parseTextBox(thresholdBox, 0, getMaxCount());
+            } else if (box == slotBox) {
+                coverVariable.slot = parseTextBox(slotBox, -1, maxSlot);
+            }
+
+            super.applyTextBox(box);
+        }
+
+        @Override
+        public void resetTextBox(GT_GuiIntegerTextBox box) {
+            super.resetTextBox(box);
+            if (box == thresholdBox) {
+                thresholdBox.setText(Integer.toString(coverVariable.threshold));
+            } else if (box == slotBox) {
+                slotBox.setText(Integer.toString(coverVariable.slot));
+            }
+        }
+
+        @Override
+        protected void update() {
+            super.update();
+            resetTextBox(thresholdBox);
+            resetTextBox(slotBox);
+
+            if (coverVariable.slot >= 0
+                    && tile instanceof TileEntity
+                    && !tile.isDead()
+                    && tile.getSizeInventory() >= coverVariable.slot) {
+                ItemStack itemStack = tile.getStackInSlot(coverVariable.slot);
+                fakeItemSlot.setItem(itemStack);
+            } else {
+                fakeItemSlot.setItem(null);
+            }
+        }
+
+        private int getMaxCount() {
+            return maxSlot > 0 ? maxSlot * 64 : Integer.MAX_VALUE;
+        }
+    }
+}
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessMaintenanceDetector.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessMaintenanceDetector.java
new file mode 100644
index 0000000000..2505ce8d80
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessMaintenanceDetector.java
@@ -0,0 +1,269 @@
+package gregtech.common.covers.redstone;
+
+import com.google.common.io.ByteArrayDataInput;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconCheckButton;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.items.GT_MetaGenerated_Tool;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.util.ISerializableObject;
+import gregtech.common.covers.GT_Cover_NeedMaintainance;
+import io.netty.buffer.ByteBuf;
+import java.util.UUID;
+import javax.annotation.Nonnull;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.World;
+
+public class GT_Cover_WirelessMaintenanceDetector
+        extends GT_Cover_AdvancedRedstoneTransmitterBase<
+                GT_Cover_WirelessMaintenanceDetector.MaintenanceTransmitterData> {
+
+    public GT_Cover_WirelessMaintenanceDetector(ITexture coverTexture) {
+        super(MaintenanceTransmitterData.class, coverTexture);
+    }
+
+    @Override
+    public MaintenanceTransmitterData createDataObject() {
+        return new MaintenanceTransmitterData();
+    }
+
+    @Override
+    public MaintenanceTransmitterData createDataObject(int aLegacyData) {
+        return createDataObject();
+    }
+
+    private static byte computeSignalBasedOnMaintenance(
+            MaintenanceTransmitterData coverVariable, ICoverable tileEntity) {
+        boolean signal = false;
+
+        if (tileEntity instanceof IGregTechTileEntity) {
+            IMetaTileEntity metaTE = ((IGregTechTileEntity) tileEntity).getMetaTileEntity();
+            if (metaTE instanceof GT_MetaTileEntity_MultiBlockBase) {
+                GT_MetaTileEntity_MultiBlockBase multiTE = (GT_MetaTileEntity_MultiBlockBase) metaTE;
+                int ideal = multiTE.getIdealStatus();
+                int real = multiTE.getRepairStatus();
+
+                switch (coverVariable.mode) {
+                    case NO_ISSUE:
+                        signal = ideal == real;
+                        break;
+                    case ONE_ISSUE:
+                    case TWO_ISSUES:
+                    case THREE_ISSUES:
+                    case FOUR_ISSUES:
+                    case FIVE_ISSUES:
+                        signal = ideal - real >= coverVariable.mode.ordinal();
+                        break;
+                    case ROTOR_80:
+                    case ROTOR_100:
+                        ItemStack rotor = multiTE.getRealInventory()[1];
+                        if (GT_Cover_NeedMaintainance.isRotor(rotor)) {
+                            long max = GT_MetaGenerated_Tool.getToolMaxDamage(rotor);
+                            long current = GT_MetaGenerated_Tool.getToolDamage(rotor);
+
+                            if (coverVariable.mode == MaintenanceMode.ROTOR_80) {
+                                signal = current >= max * 8 / 10;
+                            } else {
+                                long expectedDamage = Math.round(Math.min(
+                                        (double) multiTE.mEUt / multiTE.damageFactorLow,
+                                        Math.pow(multiTE.mEUt, multiTE.damageFactorHigh)));
+                                signal = current + expectedDamage * 2 >= max;
+                            }
+                        } else {
+                            signal = true;
+                        }
+                }
+            }
+        }
+
+        if (coverVariable.invert) {
+            signal = !signal;
+        }
+
+        return (byte) (signal ? 15 : 0);
+    }
+
+    @Override
+    public MaintenanceTransmitterData doCoverThingsImpl(
+            byte aSide,
+            byte aInputRedstone,
+            int aCoverID,
+            MaintenanceTransmitterData aCoverVariable,
+            ICoverable aTileEntity,
+            long aTimer) {
+        byte signal = computeSignalBasedOnMaintenance(aCoverVariable, aTileEntity);
+        long hash = hashCoverCoords(aTileEntity, aSide);
+        setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, signal);
+
+        return aCoverVariable;
+    }
+
+    @Override
+    public boolean letsRedstoneGoOutImpl(
+            byte aSide, int aCoverID, MaintenanceTransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected boolean manipulatesSidedRedstoneOutputImpl(
+            byte aSide, int aCoverID, MaintenanceTransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public int getTickRateImpl(
+            byte aSide, int aCoverID, MaintenanceTransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return 60;
+    }
+
+    public enum MaintenanceMode {
+        NO_ISSUE,
+        ONE_ISSUE,
+        TWO_ISSUES,
+        THREE_ISSUES,
+        FOUR_ISSUES,
+        FIVE_ISSUES,
+        ROTOR_80,
+        ROTOR_100
+    }
+
+    public static class MaintenanceTransmitterData extends GT_Cover_AdvancedRedstoneTransmitterBase.TransmitterData {
+        private MaintenanceMode mode;
+
+        public MaintenanceTransmitterData(int frequency, UUID uuid, boolean invert, MaintenanceMode mode) {
+            super(frequency, uuid, invert);
+            this.mode = mode;
+        }
+
+        public MaintenanceTransmitterData() {
+            super();
+            this.mode = MaintenanceMode.ONE_ISSUE;
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject copy() {
+            return new MaintenanceTransmitterData(frequency, uuid, invert, mode);
+        }
+
+        @Nonnull
+        @Override
+        public NBTBase saveDataToNBT() {
+            NBTTagCompound tag = (NBTTagCompound) super.saveDataToNBT();
+            tag.setInteger("mode", mode.ordinal());
+
+            return tag;
+        }
+
+        @Override
+        public void writeToByteBuf(ByteBuf aBuf) {
+            super.writeToByteBuf(aBuf);
+            aBuf.writeInt(mode.ordinal());
+        }
+
+        @Override
+        public void loadDataFromNBT(NBTBase aNBT) {
+            super.loadDataFromNBT(aNBT);
+
+            NBTTagCompound tag = (NBTTagCompound) aNBT;
+            mode = MaintenanceMode.values()[tag.getInteger("mode")];
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) {
+            super.readFromPacket(aBuf, aPlayer);
+            mode = MaintenanceMode.values()[aBuf.readInt()];
+
+            return this;
+        }
+    }
+
+    /**
+     * GUI Stuff
+     */
+    private static final String[] extraTexts = new String[] {
+        "No Issues", ">= 1 Issue", ">= 2 Issues", ">= 3 Issues",
+        ">= 4 Issues", ">= 5 Issues", "Rotor < 80%", "Rotor < 100%"
+    };
+
+    @Override
+    public Object getClientGUIImpl(
+            byte aSide,
+            int aCoverID,
+            MaintenanceTransmitterData aCoverVariable,
+            ICoverable aTileEntity,
+            EntityPlayer aPlayer,
+            World aWorld) {
+        return new MaintenanceTransmitterGUI(aSide, aCoverID, aCoverVariable, aTileEntity);
+    }
+
+    private class MaintenanceTransmitterGUI extends TransmitterGUI<MaintenanceTransmitterData> {
+
+        private static final String guiTexturePath = "gregtech:textures/gui/GuiCoverBig.png";
+        private static final int maintenanceButtonIdStart = 2;
+
+        public MaintenanceTransmitterGUI(
+                byte aSide, int aCoverID, MaintenanceTransmitterData aCoverVariable, ICoverable aTileEntity) {
+            super(aSide, aCoverID, aCoverVariable, aTileEntity);
+            this.mGUIbackgroundLocation = new ResourceLocation(guiTexturePath);
+            this.gui_height = 143;
+
+            for (int i = 0; i < 8; ++i) {
+                new GT_GuiIconCheckButton(
+                        this,
+                        maintenanceButtonIdStart + i,
+                        startX + spaceX * (i % 2 == 0 ? 0 : 6),
+                        startY + spaceY * (2 + i / 2),
+                        GT_GuiIcon.CHECKMARK,
+                        null);
+            }
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            for (int i = 0; i < 8; ++i) {
+                this.getFontRenderer()
+                        .drawString(
+                                extraTexts[i],
+                                startX + spaceX * (i % 2 == 0 ? 1 : 7),
+                                4 + startY + spaceY * (2 + i / 2),
+                                textColor);
+            }
+        }
+
+        @Override
+        protected void update() {
+            super.update();
+            updateButtons();
+        }
+
+        private void updateButtons() {
+            GT_GuiIconCheckButton button;
+            for (int i = maintenanceButtonIdStart; i < maintenanceButtonIdStart + 8; ++i) {
+                button = (GT_GuiIconCheckButton) this.buttonList.get(i);
+                button.enabled = (button.id - maintenanceButtonIdStart) != coverVariable.mode.ordinal();
+                button.setChecked(!button.enabled);
+            }
+        }
+
+        @Override
+        public void buttonClicked(GuiButton btn) {
+            if (btn.id >= maintenanceButtonIdStart && btn.enabled) {
+                coverVariable.mode = MaintenanceMode.values()[btn.id - maintenanceButtonIdStart];
+            }
+
+            super.buttonClicked(btn);
+        }
+    }
+}
diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java
index aa54520d02..5ec670aea5 100644
--- a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java
+++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java
@@ -4636,58 +4636,45 @@ public class GT_MetaGenerated_Item_01 extends GT_MetaGenerated_Item_X32 {
 
         ItemList.Cover_RedstoneTransmitterExternal.set(addItem(
                 tLastID = 741,
-                "Redstone Transmitter (Out)",
-                "Transfers Redstonesignals wireless",
+                "Redstone Transmitter (External)",
+                "Transfers Redstone signals wireless",
                 new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
                 new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L)));
         ItemList.Cover_RedstoneTransmitterInternal.set(addItem(
                 tLastID = 742,
-                "Redstone Transmitter (In)",
-                "Transfers Redstonesignals wireless",
+                "Redstone Transmitter (Internal)",
+                "Transfers Redstone signals wireless",
                 new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
                 new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L)));
         ItemList.Cover_RedstoneReceiverExternal.set(addItem(
                 tLastID = 746,
-                "Redstone Receiver (Out)",
-                "Transfers Redstonesignals wireless",
+                "Redstone Receiver (External)",
+                "Transfers Redstone signals wireless",
                 new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
                 new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L)));
         ItemList.Cover_RedstoneReceiverInternal.set(addItem(
                 tLastID = 747,
-                "Redstone Receiver (In)",
-                "Transfers Redstonesignals wireless",
+                "Redstone Receiver (Internal)",
+                "Transfers Redstone signals wireless",
                 new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
                 new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L)));
 
-        final ITexture redstoneTransmitterExternalCoverTexture = TextureFactory.of(
-                TextureFactory.of(OVERLAY_ACTIVITYDETECTOR),
-                TextureFactory.builder()
-                        .addIcon(OVERLAY_ACTIVITYDETECTOR_GLOW)
-                        .glow()
-                        .build());
         GregTech_API.registerCover(
                 ItemList.Cover_RedstoneTransmitterExternal.get(1L),
-                TextureFactory.of(MACHINE_CASINGS[2][0], redstoneTransmitterExternalCoverTexture),
-                new GT_Cover_RedstoneTransmitterExternal(redstoneTransmitterExternalCoverTexture));
-
-        final ITexture redstoneTransmitterInternalCoverTexture = TextureFactory.of(
-                TextureFactory.of(OVERLAY_ACTIVITYDETECTOR),
-                TextureFactory.builder()
-                        .addIcon(OVERLAY_ACTIVITYDETECTOR_GLOW)
-                        .glow()
-                        .build());
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_REDSTONE_TRANSMITTER)),
+                new GT_Cover_RedstoneTransmitterExternal(TextureFactory.of(OVERLAY_REDSTONE_TRANSMITTER)));
         GregTech_API.registerCover(
                 ItemList.Cover_RedstoneTransmitterInternal.get(1L),
-                TextureFactory.of(MACHINE_CASINGS[2][0], redstoneTransmitterInternalCoverTexture),
-                new GT_Cover_RedstoneTransmitterInternal(redstoneTransmitterInternalCoverTexture));
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_REDSTONE_TRANSMITTER)),
+                new GT_Cover_RedstoneTransmitterInternal(TextureFactory.of(OVERLAY_REDSTONE_TRANSMITTER)));
         GregTech_API.registerCover(
                 ItemList.Cover_RedstoneReceiverExternal.get(1L),
-                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_FLUIDDETECTOR)),
-                new GT_Cover_RedstoneReceiverExternal(TextureFactory.of(OVERLAY_FLUIDDETECTOR)));
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_REDSTONE_RECEIVER)),
+                new GT_Cover_RedstoneReceiverExternal(TextureFactory.of(OVERLAY_REDSTONE_RECEIVER)));
         GregTech_API.registerCover(
                 ItemList.Cover_RedstoneReceiverInternal.get(1L),
-                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_FLUIDDETECTOR)),
-                new GT_Cover_RedstoneReceiverInternal(TextureFactory.of(OVERLAY_FLUIDDETECTOR)));
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_REDSTONE_RECEIVER)),
+                new GT_Cover_RedstoneReceiverInternal(TextureFactory.of(OVERLAY_REDSTONE_RECEIVER)));
 
         GT_Values.RA.addAssemblerRecipe(
                 new ItemStack[] {
@@ -4728,16 +4715,11 @@ public class GT_MetaGenerated_Item_01 extends GT_MetaGenerated_Item_X32 {
                 "Attach to Multiblock Controller. Emits Redstone Signal if needs Maintenance",
                 new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
                 new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L)));
-        final ITexture needMaintenanceCoverTexture = TextureFactory.of(
-                TextureFactory.of(OVERLAY_ACTIVITYDETECTOR),
-                TextureFactory.builder()
-                        .addIcon(OVERLAY_ACTIVITYDETECTOR_GLOW)
-                        .glow()
-                        .build());
         GregTech_API.registerCover(
                 ItemList.Cover_NeedsMaintainance.get(1L),
-                TextureFactory.of(MACHINE_CASINGS[2][0], needMaintenanceCoverTexture),
-                new GT_Cover_NeedMaintainance(needMaintenanceCoverTexture));
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_MAINTENANCE_DETECTOR)),
+                new GT_Cover_NeedMaintainance(TextureFactory.of(OVERLAY_MAINTENANCE_DETECTOR)));
+
         GT_Values.RA.addAssemblerRecipe(
                 new ItemStack[] {
                     ItemList.Emitter_MV.get(1L),
diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java
index af5c1dc457..a5d8469f8b 100644
--- a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java
+++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java
@@ -1,5 +1,7 @@
 package gregtech.common.items;
 
+import static gregtech.api.enums.Textures.BlockIcons.*;
+
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.Dyes;
 import gregtech.api.enums.GT_Values;
@@ -16,6 +18,13 @@ import gregtech.api.util.GT_Log;
 import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_OreDictUnificator;
 import gregtech.api.util.GT_Utility;
+import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneReceiverExternal;
+import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneReceiverInternal;
+import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneTransmitterExternal;
+import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneTransmitterInternal;
+import gregtech.common.covers.redstone.GT_Cover_WirelessFluidDetector;
+import gregtech.common.covers.redstone.GT_Cover_WirelessItemDetector;
+import gregtech.common.covers.redstone.GT_Cover_WirelessMaintenanceDetector;
 import gregtech.common.items.behaviors.Behaviour_Arrow;
 import net.minecraft.dispenser.IBlockSource;
 import net.minecraft.enchantment.Enchantment;
@@ -2297,6 +2306,158 @@ public class GT_MetaGenerated_Item_02 extends GT_MetaGenerated_Item_X32 {
                 new GT_FoodStat(1, 0.1F, EnumAction.eat, null, false, true, false),
                 new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L)));
 
+        ItemList.Cover_AdvancedRedstoneTransmitterExternal.set(addItem(
+                tLastID = 577,
+                "Advanced Redstone Transmitter (External)",
+                "Transfers Redstone signals wirelessly",
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L)));
+        ItemList.Cover_AdvancedRedstoneTransmitterInternal.set(addItem(
+                tLastID = 578,
+                "Advanced Redstone Transmitter (Internal)",
+                "Transfers Redstone signals wirelessly",
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L)));
+        ItemList.Cover_AdvancedRedstoneReceiverExternal.set(addItem(
+                tLastID = 579,
+                "Advanced Redstone Receiver (External)",
+                "Transfers Redstone signals wirelessly",
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L)));
+        ItemList.Cover_AdvancedRedstoneReceiverInternal.set(addItem(
+                tLastID = 580,
+                "Advanced Redstone Receiver (Internal)",
+                "Transfers Redstone signals wirelessly",
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L)));
+
+        ItemList.Cover_WirelessFluidDetector.set(addItem(
+                tLastID = 581,
+                "Wireless Fluid Detector Cover",
+                "Transfers Fluid Amount as Redstone wirelessly",
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L)));
+        ItemList.Cover_WirelessItemDetector.set(addItem(
+                tLastID = 582,
+                "Wireless Item Detector Cover",
+                "Transfers Item Amount as Redstone wirelessly",
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.TERRA, 1L)));
+
+        ItemList.Cover_WirelessNeedsMaintainance.set(addItem(
+                tLastID = 583,
+                "Wireless Needs Maintenance Cover",
+                "Transfers Maintenance Issues as Redstone wirelessly",
+                new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 4L),
+                new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 3L)));
+
+        GregTech_API.registerCover(
+                ItemList.Cover_AdvancedRedstoneTransmitterExternal.get(1L),
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_TRANSMITTER)),
+                new GT_Cover_AdvancedRedstoneTransmitterExternal(
+                        TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_TRANSMITTER)));
+
+        GregTech_API.registerCover(
+                ItemList.Cover_AdvancedRedstoneTransmitterInternal.get(1L),
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_TRANSMITTER)),
+                new GT_Cover_AdvancedRedstoneTransmitterInternal(
+                        TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_TRANSMITTER)));
+
+        GregTech_API.registerCover(
+                ItemList.Cover_AdvancedRedstoneReceiverExternal.get(1L),
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_RECEIVER)),
+                new GT_Cover_AdvancedRedstoneReceiverExternal(TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_RECEIVER)));
+
+        GregTech_API.registerCover(
+                ItemList.Cover_AdvancedRedstoneReceiverInternal.get(1L),
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_RECEIVER)),
+                new GT_Cover_AdvancedRedstoneReceiverInternal(TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_RECEIVER)));
+
+        GregTech_API.registerCover(
+                ItemList.Cover_WirelessFluidDetector.get(1L),
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_WIRELESS_FLUID_DETECTOR)),
+                new GT_Cover_WirelessFluidDetector(TextureFactory.of(OVERLAY_WIRELESS_FLUID_DETECTOR)));
+
+        GregTech_API.registerCover(
+                ItemList.Cover_WirelessItemDetector.get(1L),
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_WIRELESS_ITEM_DETECTOR)),
+                new GT_Cover_WirelessItemDetector(TextureFactory.of(OVERLAY_WIRELESS_ITEM_DETECTOR)));
+
+        GregTech_API.registerCover(
+                ItemList.Cover_WirelessNeedsMaintainance.get(1L),
+                TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_WIRELESS_MAINTENANCE_DETECTOR)),
+                new GT_Cover_WirelessMaintenanceDetector(TextureFactory.of(OVERLAY_WIRELESS_MAINTENANCE_DETECTOR)));
+
+        GT_Values.RA.addAssemblerRecipe(
+                new ItemStack[] {
+                    ItemList.Cover_RedstoneTransmitterExternal.get(1L),
+                    GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Data, 1L),
+                    GT_Utility.getIntegratedCircuit(1)
+                },
+                GT_Values.NF,
+                ItemList.Cover_AdvancedRedstoneTransmitterExternal.get(1L),
+                3200,
+                128);
+
+        GT_Values.RA.addAssemblerRecipe(
+                new ItemStack[] {
+                    ItemList.Cover_RedstoneReceiverExternal.get(1L),
+                    GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Data, 1L),
+                    GT_Utility.getIntegratedCircuit(1)
+                },
+                GT_Values.NF,
+                ItemList.Cover_AdvancedRedstoneReceiverExternal.get(1L),
+                3200,
+                128);
+
+        GT_Values.RA.addAssemblerRecipe(
+                new ItemStack[] {
+                    ItemList.Cover_FluidDetector.get(1L),
+                    ItemList.Emitter_EV.get(1L),
+                    GT_Utility.getIntegratedCircuit(1)
+                },
+                GT_Values.NF,
+                ItemList.Cover_WirelessFluidDetector.get(1L),
+                3200,
+                128);
+
+        GT_Values.RA.addAssemblerRecipe(
+                new ItemStack[] {
+                    ItemList.Cover_ItemDetector.get(1L), ItemList.Emitter_EV.get(1L), GT_Utility.getIntegratedCircuit(1)
+                },
+                GT_Values.NF,
+                ItemList.Cover_WirelessItemDetector.get(1L),
+                3200,
+                128);
+
+        GT_Values.RA.addAssemblerRecipe(
+                new ItemStack[] {
+                    ItemList.Cover_NeedsMaintainance.get(1L),
+                    ItemList.Emitter_EV.get(1L),
+                    GT_Utility.getIntegratedCircuit(1)
+                },
+                GT_Values.NF,
+                ItemList.Cover_WirelessNeedsMaintainance.get(1L),
+                3200,
+                128);
+
+        GT_ModHandler.addShapelessCraftingRecipe(
+                ItemList.Cover_AdvancedRedstoneReceiverExternal.get(1L),
+                new Object[] {ItemList.Cover_AdvancedRedstoneReceiverInternal.get(1L)});
+        GT_ModHandler.addShapelessCraftingRecipe(
+                ItemList.Cover_AdvancedRedstoneReceiverInternal.get(1L),
+                new Object[] {ItemList.Cover_AdvancedRedstoneReceiverExternal.get(1L)});
+        GT_ModHandler.addShapelessCraftingRecipe(
+                ItemList.Cover_AdvancedRedstoneTransmitterExternal.get(1L),
+                new Object[] {ItemList.Cover_AdvancedRedstoneTransmitterInternal.get(1L)});
+        GT_ModHandler.addShapelessCraftingRecipe(
+                ItemList.Cover_AdvancedRedstoneTransmitterInternal.get(1L),
+                new Object[] {ItemList.Cover_AdvancedRedstoneTransmitterExternal.get(1L)});
+
         GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 0), new ItemStack(Items.dye, 2, 1));
         GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 1), new ItemStack(Items.dye, 2, 12));
         GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 2), new ItemStack(Items.dye, 2, 13));
diff --git a/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_ADVANCED_REDSTONE_RECEIVER.png b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_ADVANCED_REDSTONE_RECEIVER.png
new file mode 100644
index 0000000000..206047ad36
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_ADVANCED_REDSTONE_RECEIVER.png
diff --git a/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_ADVANCED_REDSTONE_TRANSMITTER.png b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_ADVANCED_REDSTONE_TRANSMITTER.png
new file mode 100644
index 0000000000..2d2ec5fe79
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_ADVANCED_REDSTONE_TRANSMITTER.png
diff --git a/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_MAINTENANCE_DETECTOR.png b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_MAINTENANCE_DETECTOR.png
new file mode 100644
index 0000000000..7ed1d9178e
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_MAINTENANCE_DETECTOR.png
diff --git a/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_REDSTONE_RECEIVER.png b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_REDSTONE_RECEIVER.png
new file mode 100644
index 0000000000..e6ddc3002e
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_REDSTONE_RECEIVER.png
diff --git a/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_REDSTONE_TRANSMITTER.png b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_REDSTONE_TRANSMITTER.png
new file mode 100644
index 0000000000..d7d1c8a4b5
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_REDSTONE_TRANSMITTER.png
diff --git a/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_WIRELESS_FLUID_DETECTOR.png b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_WIRELESS_FLUID_DETECTOR.png
new file mode 100644
index 0000000000..766671d5bf
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_WIRELESS_FLUID_DETECTOR.png
diff --git a/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_WIRELESS_ITEM_DETECTOR.png b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_WIRELESS_ITEM_DETECTOR.png
new file mode 100644
index 0000000000..0fe7a164d6
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_WIRELESS_ITEM_DETECTOR.png
diff --git a/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_WIRELESS_MAINTENANCE_DETECTOR.png b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_WIRELESS_MAINTENANCE_DETECTOR.png
new file mode 100644
index 0000000000..4cc9679888
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_WIRELESS_MAINTENANCE_DETECTOR.png
diff --git a/src/main/resources/assets/gregtech/textures/gui/GuiButtons.png b/src/main/resources/assets/gregtech/textures/gui/GuiButtons.png
index ce0652d14a..d621e199c3 100644
--- a/src/main/resources/assets/gregtech/textures/gui/GuiButtons.png
+++ b/src/main/resources/assets/gregtech/textures/gui/GuiButtons.png
diff --git a/src/main/resources/assets/gregtech/textures/gui/GuiCoverBig.png b/src/main/resources/assets/gregtech/textures/gui/GuiCoverBig.png
new file mode 100644
index 0000000000..e835ea7e12
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/gui/GuiCoverBig.png
diff --git a/src/main/resources/assets/gregtech/textures/gui/GuiCoverLong.png b/src/main/resources/assets/gregtech/textures/gui/GuiCoverLong.png
new file mode 100644
index 0000000000..1b9a18f691
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/gui/GuiCoverLong.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/741.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/741.png
index c986ab738c..d5d8f25f35 100644
--- a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/741.png
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/741.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/742.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/742.png
index c7b141b32b..d5d8f25f35 100644
--- a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/742.png
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/742.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/746.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/746.png
index 14feeb8947..b49d621131 100644
--- a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/746.png
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/746.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/747.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/747.png
index 7f8b3fcb37..b49d621131 100644
--- a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/747.png
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/747.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/748.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/748.png
index c986ab738c..dbd57d68e3 100644
--- a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/748.png
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.01/748.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/577.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/577.png
new file mode 100644
index 0000000000..09df66bdeb
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/577.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/578.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/578.png
new file mode 100644
index 0000000000..09df66bdeb
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/578.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/579.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/579.png
new file mode 100644
index 0000000000..1d6d781628
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/579.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/580.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/580.png
new file mode 100644
index 0000000000..1d6d781628
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/580.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/581.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/581.png
new file mode 100644
index 0000000000..8f79c8f74a
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/581.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/582.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/582.png
new file mode 100644
index 0000000000..13d6380747
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/582.png
diff --git a/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/583.png b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/583.png
new file mode 100644
index 0000000000..5326a6ed66
--- /dev/null
+++ b/src/main/resources/assets/gregtech/textures/items/gt.metaitem.02/583.png