Wireless Activity Detector; Power On/Off Activity Detector (#2490)

* Wireless Activity Detector; Power On/Off Activity Detector

* Wireless Gui Redesign

---------

Co-authored-by: slprime <history-21@yandex.ru>

3 files changed, 337 insertions, 32 deletions

diff --git a/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java b/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java
index 37c791b024..4e32a69330 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java
@@ -20,6 +20,10 @@ import gregtech.common.gui.modularui.widget.CoverDataFollower_ToggleButtonWidget
 
 public class GT_Cover_DoesWork extends GT_CoverBehavior {
 
+    private static int FLAG_INVERTED = 0x1;
+    private static int FLAG_PROGRESS = 0x2;
+    private static int FLAG_ENABLED = 0x4;
+
     public GT_Cover_DoesWork(ITexture coverTexture) {
         super(coverTexture);
     }
@@ -34,22 +38,25 @@ public class GT_Cover_DoesWork extends GT_CoverBehavior {
     public int doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable,
         ICoverable aTileEntity, long aTimer) {
         if ((aTileEntity instanceof IMachineProgress)) {
-            if (aCoverVariable < 2) {
-                int tScale = ((IMachineProgress) aTileEntity).getMaxProgress() / 15;
-                if ((tScale > 0) && (((IMachineProgress) aTileEntity).hasThingsToDo())) {
-                    aTileEntity.setOutputRedstoneSignal(
-                        side,
-                        aCoverVariable % 2 == 0 ? (byte) (((IMachineProgress) aTileEntity).getProgress() / tScale)
-                            : (byte) (15 - ((IMachineProgress) aTileEntity).getProgress() / tScale));
+            IMachineProgress mProgress = (IMachineProgress) aTileEntity;
+            boolean inverted = isFlagSet(aCoverVariable, FLAG_INVERTED);
+            int signal = 0;
+
+            if (isFlagSet(aCoverVariable, FLAG_ENABLED)) {
+                signal = inverted == mProgress.isAllowedToWork() ? 0 : 15;
+            } else if (isFlagSet(aCoverVariable, FLAG_PROGRESS)) {
+                signal = inverted == (mProgress.getMaxProgress() == 0) ? 0 : 15;
+            } else {
+                int tScale = mProgress.getMaxProgress() / 15;
+
+                if (tScale > 0 && mProgress.hasThingsToDo()) {
+                    signal = inverted ? (15 - mProgress.getProgress() / tScale) : (mProgress.getProgress() / tScale);
                 } else {
-                    aTileEntity.setOutputRedstoneSignal(side, (byte) (aCoverVariable % 2 == 0 ? 0 : 15));
+                    signal = inverted ? 15 : 0;
                 }
-            } else {
-                aTileEntity.setOutputRedstoneSignal(
-                    side,
-                    (byte) ((aCoverVariable % 2 == 0 ? 1 : 0)
-                        != (((IMachineProgress) aTileEntity).getMaxProgress() == 0 ? 1 : 0) ? 0 : 15));
             }
+
+            aTileEntity.setOutputRedstoneSignal(side, (byte) signal);
         } else {
             aTileEntity.setOutputRedstoneSignal(side, (byte) 0);
         }
@@ -59,9 +66,9 @@ public class GT_Cover_DoesWork extends GT_CoverBehavior {
     @Override
     public int onCoverScrewdriverclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity,
         EntityPlayer aPlayer, float aX, float aY, float aZ) {
-        aCoverVariable = (aCoverVariable + (aPlayer.isSneaking() ? -1 : 1)) % 4;
+        aCoverVariable = (aCoverVariable + (aPlayer.isSneaking() ? -1 : 1)) % 6;
         if (aCoverVariable < 0) {
-            aCoverVariable = 3;
+            aCoverVariable = 5;
         }
         switch (aCoverVariable) {
             case 0 -> GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("018", "Normal"));
@@ -72,6 +79,10 @@ public class GT_Cover_DoesWork extends GT_CoverBehavior {
             // Not Running
             case 3 -> GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("021", "Not ready to work"));
             // Running
+            case 4 -> GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("028", "Machine Enabled"));
+            // Enabled
+            case 5 -> GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("029", "Machine Disabled"));
+            // Disabled
         }
         return aCoverVariable;
     }
@@ -138,6 +149,10 @@ public class GT_Cover_DoesWork extends GT_CoverBehavior {
         return new DoesWorkUIFactory(buildContext).createWindow();
     }
 
+    private static boolean isFlagSet(int coverVariable, int flag) {
+        return (coverVariable & flag) == flag;
+    }
+
     private class DoesWorkUIFactory extends UIFactory {
 
         private static final int startX = 10;
@@ -173,21 +188,34 @@ public class GT_Cover_DoesWork extends GT_CoverBehavior {
                                         .setPos(spaceX * 1, spaceY * 0))
                                 .addToggleButton(
                                     2,
+                                    CoverDataFollower_ToggleButtonWidget.ofDisableable(),
+                                    widget -> widget.setStaticTexture(GT_UITextures.OVERLAY_BUTTON_POWER_SWITCH_ON)
+                                        .setPos(spaceX * 2, spaceY * 0))
+                                .addToggleButton(
+                                    3,
                                     CoverDataFollower_ToggleButtonWidget.ofRedstone(),
                                     widget -> widget.setPos(spaceX * 0, spaceY * 1))
                                 .setPos(startX, startY))
+                .widget(TextWidget.dynamicString(() -> {
+                    int coverVariable = convert(getCoverData());
+
+                    if (isFlagSet(coverVariable, FLAG_ENABLED)) {
+                        return GT_Utility.trans("271", "Machine enabled");
+                    } else if (isFlagSet(coverVariable, FLAG_PROGRESS)) {
+                        return GT_Utility.trans("242", "Machine idle");
+                    } else {
+                        return GT_Utility.trans("241", "Recipe progress");
+                    }
+
+                })
+                    .setSynced(false)
+                    .setDefaultColor(COLOR_TEXT_GRAY.get())
+                    .setPos(startX + spaceX * 3, 4 + startY + spaceY * 0))
                 .widget(
                     TextWidget
                         .dynamicString(
-                            () -> ((convert(getCoverData()) & 0x2) > 0) ? GT_Utility.trans("242", "Machine idle")
-                                : GT_Utility.trans("241", "Recipe progress"))
-                        .setSynced(false)
-                        .setDefaultColor(COLOR_TEXT_GRAY.get())
-                        .setPos(startX + spaceX * 3, 4 + startY + spaceY * 0))
-                .widget(
-                    TextWidget
-                        .dynamicString(
-                            () -> ((convert(getCoverData()) & 0x1) > 0) ? GT_Utility.trans("INVERTED", "Inverted")
+                            () -> isFlagSet(convert(getCoverData()), FLAG_INVERTED)
+                                ? GT_Utility.trans("INVERTED", "Inverted")
                                 : GT_Utility.trans("NORMAL", "Normal"))
                         .setSynced(false)
                         .setDefaultColor(COLOR_TEXT_GRAY.get())
@@ -197,14 +225,20 @@ public class GT_Cover_DoesWork extends GT_CoverBehavior {
         private int getNewCoverVariable(int id, int coverVariable) {
             switch (id) {
                 case 0 -> {
-                    return coverVariable & ~0x2;
+                    return (coverVariable & ~FLAG_ENABLED) & ~FLAG_PROGRESS;
                 }
                 case 1 -> {
-                    return coverVariable | 0x2;
+                    return (coverVariable & ~FLAG_ENABLED) | FLAG_PROGRESS;
                 }
                 case 2 -> {
-                    if ((coverVariable & 0x1) > 0) return coverVariable & ~0x1;
-                    return coverVariable | 0x1;
+                    return (coverVariable & ~FLAG_PROGRESS) | FLAG_ENABLED;
+                }
+                case 3 -> {
+                    if (isFlagSet(coverVariable, FLAG_INVERTED)) {
+                        return coverVariable & ~FLAG_INVERTED;
+                    } else {
+                        return coverVariable | FLAG_INVERTED;
+                    }
                 }
             }
             return coverVariable;
@@ -212,9 +246,10 @@ public class GT_Cover_DoesWork extends GT_CoverBehavior {
 
         private boolean isEnabled(int id, int coverVariable) {
             return switch (id) {
-                case 0 -> (coverVariable & 0x2) == 0;
-                case 1 -> (coverVariable & 0x2) > 0;
-                case 2 -> (coverVariable & 0x1) > 0;
+                case 0 -> !isFlagSet(coverVariable, FLAG_PROGRESS) && !isFlagSet(coverVariable, FLAG_ENABLED);
+                case 1 -> isFlagSet(coverVariable, FLAG_PROGRESS);
+                case 2 -> isFlagSet(coverVariable, FLAG_ENABLED);
+                case 3 -> isFlagSet(coverVariable, FLAG_INVERTED);
                 default -> true;
             };
         }
diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessDoesWorkDetector.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessDoesWorkDetector.java
new file mode 100644
index 0000000000..724f12b8f8
--- /dev/null
+++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessDoesWorkDetector.java
@@ -0,0 +1,245 @@
+package gregtech.common.covers.redstone;
+
+import java.util.UUID;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.google.common.io.ByteArrayDataInput;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import gregtech.api.gui.modularui.GT_CoverUIBuildContext;
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.interfaces.tileentity.IMachineProgress;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.ISerializableObject;
+import gregtech.common.covers.redstone.GT_Cover_WirelessDoesWorkDetector.ActivityMode;
+import gregtech.common.gui.modularui.widget.CoverDataControllerWidget;
+import gregtech.common.gui.modularui.widget.CoverDataFollower_ToggleButtonWidget;
+import io.netty.buffer.ByteBuf;
+
+public class GT_Cover_WirelessDoesWorkDetector
+    extends GT_Cover_AdvancedRedstoneTransmitterBase<GT_Cover_WirelessDoesWorkDetector.ActivityTransmitterData> {
+
+    public GT_Cover_WirelessDoesWorkDetector(ITexture coverTexture) {
+        super(ActivityTransmitterData.class, coverTexture);
+    }
+
+    @Override
+    public ActivityTransmitterData createDataObject() {
+        return new ActivityTransmitterData();
+    }
+
+    @Override
+    public ActivityTransmitterData createDataObject(int aLegacyData) {
+        return createDataObject();
+    }
+
+    private static byte computeSignalBasedOnActivity(ActivityTransmitterData coverVariable, ICoverable tileEntity) {
+
+        if (tileEntity instanceof IMachineProgress) {
+            IMachineProgress mProgress = (IMachineProgress) tileEntity;
+            boolean inverted = coverVariable.invert;
+            int signal = 0;
+
+            switch (coverVariable.mode) {
+                case MACHINE_ENABLED -> signal = inverted == mProgress.isAllowedToWork() ? 0 : 15;
+                case MACHINE_IDLE -> signal = inverted == (mProgress.getMaxProgress() == 0) ? 0 : 15;
+                case RECIPE_PROGRESS -> {
+                    int tScale = mProgress.getMaxProgress() / 15;
+
+                    if (tScale > 0 && mProgress.hasThingsToDo()) {
+                        signal = inverted ? (15 - mProgress.getProgress() / tScale)
+                            : (mProgress.getProgress() / tScale);
+                    } else {
+                        signal = inverted ? 15 : 0;
+                    }
+                }
+            }
+
+            return (byte) signal;
+        } else {
+            return (byte) 0;
+        }
+
+    }
+
+    @Override
+    public ActivityTransmitterData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID,
+        ActivityTransmitterData aCoverVariable, ICoverable aTileEntity, long aTimer) {
+        final byte signal = computeSignalBasedOnActivity(aCoverVariable, aTileEntity);
+        final long hash = hashCoverCoords(aTileEntity, side);
+        setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, signal);
+
+        return aCoverVariable;
+    }
+
+    @Override
+    public boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, ActivityTransmitterData aCoverVariable,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected boolean manipulatesSidedRedstoneOutputImpl(ForgeDirection side, int aCoverID,
+        ActivityTransmitterData aCoverVariable, ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    public int getTickRateImpl(ForgeDirection side, int aCoverID, ActivityTransmitterData aCoverVariable,
+        ICoverable aTileEntity) {
+        return 5;
+    }
+
+    public enum ActivityMode {
+        RECIPE_PROGRESS,
+        MACHINE_IDLE,
+        MACHINE_ENABLED,
+    }
+
+    public static class ActivityTransmitterData extends GT_Cover_AdvancedRedstoneTransmitterBase.TransmitterData {
+
+        private ActivityMode mode;
+
+        public ActivityTransmitterData(int frequency, UUID uuid, boolean invert, ActivityMode mode) {
+            super(frequency, uuid, invert);
+            this.mode = mode;
+        }
+
+        public ActivityTransmitterData() {
+            super();
+            this.mode = ActivityMode.MACHINE_IDLE;
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject copy() {
+            return new ActivityTransmitterData(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 = ActivityMode.values()[tag.getInteger("mode")];
+        }
+
+        @Nonnull
+        @Override
+        public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) {
+            super.readFromPacket(aBuf, aPlayer);
+            mode = ActivityMode.values()[aBuf.readInt()];
+
+            return this;
+        }
+    }
+
+    @Override
+    public ModularWindow createWindow(GT_CoverUIBuildContext buildContext) {
+        return new WirelessActivityDetectorUIFactory(buildContext).createWindow();
+    }
+
+    private class WirelessActivityDetectorUIFactory extends AdvancedRedstoneTransmitterBaseUIFactory {
+
+        public WirelessActivityDetectorUIFactory(GT_CoverUIBuildContext buildContext) {
+            super(buildContext);
+        }
+
+        @Override
+        protected int getGUIHeight() {
+            return 107;
+        }
+
+        @Override
+        protected int getFrequencyRow() {
+            return 0;
+        }
+
+        @Override
+        protected int getButtonRow() {
+            return 1;
+        }
+
+        @Override
+        protected void addUIWidgets(ModularWindow.Builder builder) {
+            super.addUIWidgets(builder);
+            builder.widget(TextWidget.dynamicString(() -> {
+
+                ActivityMode mode = getCoverData().mode;
+
+                if (mode == ActivityMode.MACHINE_ENABLED) {
+                    return GT_Utility.trans("271", "Machine enabled");
+                } else if (mode == ActivityMode.MACHINE_IDLE) {
+                    return GT_Utility.trans("242", "Machine idle");
+                } else {
+                    return GT_Utility.trans("241", "Recipe progress");
+                }
+
+            })
+                .setSynced(false)
+                .setDefaultColor(COLOR_TEXT_GRAY.get())
+                .setPos(startX + spaceX * 3, 4 + startY + spaceY * 2));
+        }
+
+        @Override
+        protected void addUIForDataController(CoverDataControllerWidget<ActivityTransmitterData> controller) {
+            super.addUIForDataController(controller);
+
+            controller.addFollower(
+                CoverDataFollower_ToggleButtonWidget.ofDisableable(),
+                coverData -> coverData.mode == ActivityMode.RECIPE_PROGRESS,
+                (coverData, state) -> {
+                    coverData.mode = ActivityMode.RECIPE_PROGRESS;
+                    return coverData;
+                },
+                widget -> widget.setStaticTexture(GT_UITextures.OVERLAY_BUTTON_PROGRESS)
+                    .addTooltip(GT_Utility.trans("241", "Recipe progress"))
+                    .setPos(spaceX * 0, spaceY * 2))
+                .addFollower(
+                    CoverDataFollower_ToggleButtonWidget.ofDisableable(),
+                    coverData -> coverData.mode == ActivityMode.MACHINE_IDLE,
+                    (coverData, state) -> {
+                        coverData.mode = ActivityMode.MACHINE_IDLE;
+                        return coverData;
+                    },
+                    widget -> widget.setStaticTexture(GT_UITextures.OVERLAY_BUTTON_CHECKMARK)
+                        .addTooltip(GT_Utility.trans("242", "Machine idle"))
+                        .setPos(spaceX * 1, spaceY * 2))
+                .addFollower(
+                    CoverDataFollower_ToggleButtonWidget.ofDisableable(),
+                    coverData -> coverData.mode == ActivityMode.MACHINE_ENABLED,
+                    (coverData, state) -> {
+                        coverData.mode = ActivityMode.MACHINE_ENABLED;
+                        return coverData;
+                    },
+                    widget -> widget.setStaticTexture(GT_UITextures.OVERLAY_BUTTON_POWER_SWITCH_ON)
+                        .addTooltip(GT_Utility.trans("271", "Machine enabled"))
+                        .setPos(spaceX * 2, spaceY * 2));
+        }
+    }
+
+}
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 1c4556b5a3..da1fc2ee1c 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
@@ -4,6 +4,7 @@ import static gregtech.api.enums.Mods.Forestry;
 import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASINGS;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ADVANCED_REDSTONE_RECEIVER;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ADVANCED_REDSTONE_TRANSMITTER;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_WIRELESS_ACTIVITYDETECTOR;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_WIRELESS_FLUID_DETECTOR;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_WIRELESS_ITEM_DETECTOR;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_WIRELESS_MAINTENANCE_DETECTOR;
@@ -51,6 +52,7 @@ 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_WirelessDoesWorkDetector;
 import gregtech.common.covers.redstone.GT_Cover_WirelessFluidDetector;
 import gregtech.common.covers.redstone.GT_Cover_WirelessItemDetector;
 import gregtech.common.covers.redstone.GT_Cover_WirelessMaintenanceDetector;
@@ -2424,6 +2426,16 @@ public class GT_MetaGenerated_Item_02 extends GT_MetaGenerated_Item_X32 {
                 new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 4L),
                 new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 3L)));
 
+        ItemList.Cover_WirelessActivityDetector.set(
+            addItem(
+                tLastID = 584,
+                "Wireless Activity Detector Cover",
+                "Transfers Activity as Redstone wirelessly/n Can only connect with advanced wireless covers",
+                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)));
+
         GregTech_API.registerCover(
             ItemList.Cover_AdvancedRedstoneTransmitterExternal.get(1L),
             TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_TRANSMITTER)),
@@ -2455,6 +2467,11 @@ public class GT_MetaGenerated_Item_02 extends GT_MetaGenerated_Item_X32 {
             new GT_Cover_WirelessItemDetector(TextureFactory.of(OVERLAY_WIRELESS_ITEM_DETECTOR)));
 
         GregTech_API.registerCover(
+            ItemList.Cover_WirelessActivityDetector.get(1L),
+            TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_WIRELESS_ACTIVITYDETECTOR)),
+            new GT_Cover_WirelessDoesWorkDetector(TextureFactory.of(OVERLAY_WIRELESS_ACTIVITYDETECTOR)));
+
+        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)));
@@ -2504,7 +2521,15 @@ public class GT_MetaGenerated_Item_02 extends GT_MetaGenerated_Item_X32 {
             .duration(2 * MINUTES + 40 * SECONDS)
             .eut(TierEU.RECIPE_MV)
             .addTo(assemblerRecipes);
-
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Cover_ActivityDetector.get(1L),
+                ItemList.Emitter_EV.get(1L),
+                GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(ItemList.Cover_WirelessActivityDetector.get(1L))
+            .duration(2 * MINUTES + 40 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(assemblerRecipes);
         GT_ModHandler.addShapelessCraftingRecipe(
             ItemList.Cover_AdvancedRedstoneReceiverExternal.get(1L),
             new Object[] { ItemList.Cover_AdvancedRedstoneReceiverInternal.get(1L) });