Add magnet and restock to Universal terminal (#275)

Co-authored-by: Maya <10861407+serenibyss@users.noreply.github.com>
Co-authored-by: Caedis <Caedis@users.noreply.github.com>
Co-authored-by: Ruling-0 <47913168+Ruling-0@users.noreply.github.com>

src/main/java/com/glodblock/github/client/gui/FCGuiBaseButton.java

@@ -0,0 +1,87 @@
+
+package com.glodblock.github.client.gui;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+// copy from WirelessCraftingTerminal WCTGuiButton
+public class FCGuiBaseButton extends GuiButton {
+
+    protected static final ResourceLocation buttonTextures = new ResourceLocation(
+            "minecraft",
+            "textures/gui/widgets.png");
+
+    public FCGuiBaseButton(int id, int xPosition, int yPosition, int width, int height, String displayString) {
+        super(id, xPosition, yPosition, width, height, displayString);
+        this.enabled = true;
+        this.visible = true;
+        this.id = id;
+        this.xPosition = xPosition;
+        this.yPosition = yPosition;
+        this.width = width;
+        this.height = height;
+        this.displayString = displayString;
+    }
+
+    @Override
+    public void drawButton(Minecraft mc, int mouseX, int mouseY) {
+        if (this.visible) {
+            FontRenderer fontrenderer = mc.fontRenderer;
+            mc.getTextureManager().bindTexture(buttonTextures);
+            GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+            this.field_146123_n = mouseX >= this.xPosition && mouseY >= this.yPosition
+                    && mouseX < this.xPosition + this.width
+                    && mouseY < this.yPosition + this.height;
+            int k = this.getHoverState(this.field_146123_n);
+            GL11.glEnable(GL11.GL_BLEND);
+            OpenGlHelper.glBlendFunc(770, 771, 1, 0);
+            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+            this.drawTexturedModalRect(this.xPosition, this.yPosition, 0, 46 + k * 20, this.width / 2, this.height);
+            this.drawTexturedModalRect(
+                    this.xPosition + this.width / 2,
+                    this.yPosition,
+                    200 - this.width / 2,
+                    46 + k * 20,
+                    this.width / 2,
+                    this.height - 2);
+            this.drawTexturedModalRect(
+                    this.xPosition + 2,
+                    this.yPosition + (this.height - 2),
+                    200 - (this.width - 2),
+                    64 + k * 20,
+                    this.width - 2,
+                    2);
+            this.drawTexturedModalRect(
+                    this.xPosition,
+                    this.yPosition + (this.height - 1),
+                    200 - this.width,
+                    65 + k * 20,
+                    this.width,
+                    1);
+            this.mouseDragged(mc, mouseX, mouseY);
+
+            int l = 14737632;
+
+            if (packedFGColour != 0) {
+                l = packedFGColour;
+            } else if (!this.enabled) {
+                l = 10526880;
+            } else if (this.field_146123_n) {
+                l = 16777120;
+            }
+
+            this.drawCenteredString(
+                    fontrenderer,
+                    this.displayString,
+                    this.xPosition + this.width / 2,
+                    this.yPosition + (this.height - 8) / 2,
+                    l);
+        }
+    }
+}

src/main/java/com/glodblock/github/client/gui/GuiFCImgButton.java

@@ -22,6 +22,7 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
     private static Map<EnumPair, ButtonAppearance> appearances;
     private final String buttonSetting;
     private boolean halfSize = false;
+    private boolean threeFourths = false;
     private String fillVar;
     private String currentValue;
     private final boolean background;
@@ -66,6 +67,14 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
             this.registerApp(22, "SWITCH", "DISABLE", "disable");
             this.registerApp(23, "CONFIG", "YES", "open_configuration");
             this.registerApp(24, "HIGHLIGHT", "YES", "block_highlight");
+            this.registerApp(30, "MAGNET_CARD", "INV", "magnet_card.inv");
+            this.registerApp(30, "MAGNET_CARD", "ME", "magnet_card.me");
+            this.registerApp(30, "MAGNET_CARD", "FILTER", "magnet_card.filter");
+            this.registerApp(31, "MAGNET_CARD", "OFF", "magnet_card.off");
+            this.registerApp(32, "ENABLE_12x", "ENABLE", "enable");
+            this.registerApp(33, "DISABLE_12x", "DISABLE", "disable");
+            this.registerApp(34, "RESTOCK", "ENABLE", "restock.on");
+            this.registerApp(35, "RESTOCK", "DISABLE", "restock.off");
         }
     }
 
@@ -135,6 +144,14 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
         this.halfSize = halfSize;
     }
 
+    public boolean isThreeFourths() {
+        return threeFourths;
+    }
+
+    public void setThreeFourths(boolean threeFourths) {
+        this.threeFourths = threeFourths;
+    }
+
     public String getFillVar() {
         return this.fillVar;
     }
@@ -155,12 +172,12 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
 
     @Override
     public int getWidth() {
-        return this.halfSize ? 8 : 16;
+        return this.halfSize ? 8 : threeFourths ? 12 : 16;
     }
 
     @Override
     public int getHeight() {
-        return this.halfSize ? 8 : 16;
+        return this.halfSize ? 8 : threeFourths ? 12 : 16;
     }
 
     @Override
@@ -217,79 +234,44 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
         if (this.visible) {
             final int iconIndex = this.getIconIndex();
             final int iconPage = this.getIconPage();
+            this.width = getWidth();
+            this.height = getHeight();
+            float scaleFactor = halfSize ? 3 : threeFourths ? 4.5f : 6;
 
-            if (this.halfSize) {
-                this.width = 8;
-                this.height = 8;
-
-                GL11.glPushMatrix();
-                GL11.glTranslatef(this.xPosition, this.yPosition, 0.0F);
-                GL11.glScalef(0.5f / 16 * 3, 0.5f / 16 * 3, 0.5f / 16 * 3);
-
-                if (this.enabled) {
-                    GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-                } else {
-                    GL11.glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
-                }
-
-                par1Minecraft.renderEngine.bindTexture(FluidCraft.resource("textures/gui/states" + iconPage + ".png"));
-                this.field_146123_n = par2 >= this.xPosition && par3 >= this.yPosition
-                        && par2 < this.xPosition + this.width
-                        && par3 < this.yPosition + this.height;
-
-                final int uv_y = (int) Math.floor(iconIndex / 3.0);
-                final int uv_x = iconIndex - uv_y * 3;
-                if (this.background) {
-                    this.drawTexturedModalRect(
-                            0,
-                            0,
-                            Math.round(32F * 16F / 3F),
-                            Math.round(32F * 16F / 3F),
-                            Math.round(16F * 16F / 3F),
-                            Math.round(16F * 16F / 3F));
-                }
-                this.drawTexturedModalRect(
-                        0,
-                        0,
-                        Math.round(uv_x * 16F * 16F / 3F),
-                        Math.round(uv_y * 16F * 16F / 3F),
-                        Math.round(16F * 16F / 3F),
-                        Math.round(16F * 16F / 3F));
+            GL11.glPushMatrix();
+            GL11.glTranslatef(this.xPosition, this.yPosition, 0.0F);
+            GL11.glScalef(0.5f / 16 * scaleFactor, 0.5f / 16 * scaleFactor, 0.5f / 16 * scaleFactor);
 
+            if (this.enabled) {
+                GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
             } else {
-                GL11.glPushMatrix();
-                GL11.glTranslatef(this.xPosition, this.yPosition, 0.0F);
-                GL11.glScalef(0.5f / 16 * 6, 0.5f / 16 * 6, 0.5f / 16 * 6);
-                if (this.enabled) {
-                    GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-                } else {
-                    GL11.glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
-                }
+                GL11.glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
+            }
 
-                par1Minecraft.renderEngine.bindTexture(FluidCraft.resource("textures/gui/states" + iconPage + ".png"));
-                this.field_146123_n = par2 >= this.xPosition && par3 >= this.yPosition
-                        && par2 < this.xPosition + this.width
-                        && par3 < this.yPosition + this.height;
+            par1Minecraft.renderEngine.bindTexture(FluidCraft.resource("textures/gui/states" + iconPage + ".png"));
+            this.field_146123_n = par2 >= this.xPosition && par3 >= this.yPosition
+                    && par2 < this.xPosition + this.width
+                    && par3 < this.yPosition + this.height;
 
-                final int uv_y = (int) Math.floor(iconIndex / 3.0);
-                final int uv_x = iconIndex - uv_y * 3;
-                if (this.background) {
-                    this.drawTexturedModalRect(
-                            0,
-                            0,
-                            Math.round(32F * 16F / 3F),
-                            Math.round(32F * 16F / 3F),
-                            Math.round(16F * 16F / 3F),
-                            Math.round(16F * 16F / 3F));
-                }
+            final int uv_y = (int) Math.floor(iconIndex / 3.0);
+            final int uv_x = iconIndex - uv_y * 3;
+            if (this.background) {
                 this.drawTexturedModalRect(
                         0,
                         0,
-                        Math.round(uv_x * 16F * 16F / 3F),
-                        Math.round(uv_y * 16F * 16F / 3F),
+                        Math.round(32F * 16F / 3F),
+                        Math.round(32F * 16F / 3F),
                         Math.round(16F * 16F / 3F),
                         Math.round(16F * 16F / 3F));
             }
+            this.drawTexturedModalRect(
+                    0,
+                    0,
+                    Math.round(uv_x * 16F * 16F / 3F),
+                    Math.round(uv_y * 16F * 16F / 3F),
+                    Math.round(16F * 16F / 3F),
+                    Math.round(16F * 16F / 3F));
+
             this.mouseDragged(par1Minecraft, par2, par3);
             GL11.glPopMatrix();
         }

src/main/java/com/glodblock/github/client/gui/GuiFluidMonitor.java

@@ -44,6 +44,7 @@ public class GuiFluidMonitor extends FCGuiMonitor<IAEFluidStack> {
     public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
         this.fontRendererObj.drawString(this.getGuiDisplayName(GuiText.Terminal.getLocal()), 8, 6, 4210752);
         this.fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, this.ySize - 96 + 3, 4210752);
+        super.drawFG(offsetX, offsetY, mouseX, mouseY);
     }
 
     @Override

src/main/java/com/glodblock/github/client/gui/GuiFluidPortableCell.java

@@ -27,4 +27,9 @@ public class GuiFluidPortableCell extends GuiFluidTerminal {
             return 3;
         }
     }
+
+    @Override
+    protected boolean isPortableCell() {
+        return true;
+    }
 }

src/main/java/com/glodblock/github/client/gui/GuiItemMonitor.java

@@ -37,6 +37,7 @@ public class GuiItemMonitor extends FCGuiMonitor<IAEItemStack> {
     public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
         this.fontRendererObj.drawString(this.getGuiDisplayName(GuiText.Terminal.getLocal()), 8, 6, 4210752);
         this.fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, this.ySize - 96 + 3, 4210752);
+        super.drawFG(offsetX, offsetY, mouseX, mouseY);
     }
 
     @Override

src/main/java/com/glodblock/github/client/gui/GuiMagnetFilter.java

@@ -0,0 +1,212 @@
+package com.glodblock.github.client.gui;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.input.Keyboard;
+
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.container.ContainerMagnetFilter;
+import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
+import com.glodblock.github.inventory.InventoryHandler;
+import com.glodblock.github.inventory.item.WirelessMagnet;
+import com.glodblock.github.network.CPacketFluidPatternTermBtns;
+import com.glodblock.github.util.NameConst;
+
+import appeng.api.config.ActionItems;
+import appeng.api.config.Settings;
+import appeng.api.storage.ITerminalHost;
+import appeng.client.gui.AEBaseMEGui;
+import appeng.client.gui.widgets.GuiImgButton;
+import appeng.client.gui.widgets.GuiTabButton;
+import appeng.client.gui.widgets.MEGuiTextField;
+
+public class GuiMagnetFilter extends AEBaseMEGui {
+
+    protected FCGuiBaseButton listModeBtn;
+    protected ContainerMagnetFilter cont;
+    private static final ResourceLocation TEX_BG = FluidCraft.resource("textures/gui/magnet_filter.png");
+
+    protected Component[] components = new Component[4];
+    protected MEGuiTextField oreDict;
+    protected GuiTabButton originalGuiBtn;
+    protected GuiImgButton clearBtn;
+
+    public GuiMagnetFilter(InventoryPlayer ip, ITerminalHost container) {
+        super(new ContainerMagnetFilter(ip, container));
+        this.xSize = 195;
+        this.ySize = 214;
+        this.cont = (ContainerMagnetFilter) this.inventorySlots;
+        oreDict = new MEGuiTextField(149, 12, NameConst.i18n(NameConst.TT_MAGNET_CARD_OREDICT));
+    }
+
+    private class Component {
+
+        private final GuiFCImgButton enable;
+        private final GuiFCImgButton disable;
+        private final String action;
+        private boolean var;
+
+        public Component(int x, int y, boolean var, String action) {
+            this.enable = new GuiFCImgButton(x, y, "ENABLE_12x", "ENABLE", false);
+            this.disable = new GuiFCImgButton(x, y, "DISABLE_12x", "DISABLE", false);
+            this.var = var;
+            this.action = action;
+            enable.setThreeFourths(true);
+            disable.setThreeFourths(true);
+            buttonList.add(this.enable);
+            buttonList.add(this.disable);
+        }
+
+        public boolean sameBtn(GuiButton btn) {
+            return btn == this.enable || btn == this.disable;
+        }
+
+        public boolean getVar() {
+            return this.var;
+        }
+
+        public void setVar(boolean var) {
+            this.var = var;
+        }
+
+        public void send() {
+            FluidCraft.proxy.netHandler.sendToServer(new CPacketFluidPatternTermBtns(this.action, !this.getVar()));
+        }
+
+        public void draw() {
+            if (var) {
+                this.enable.visible = true;
+                this.disable.visible = false;
+            } else {
+                this.enable.visible = false;
+                this.disable.visible = true;
+            }
+        }
+    }
+
+    @Override
+    public void initGui() {
+        super.initGui();
+        this.buttonList.clear();
+
+        this.buttonList.add(
+                this.listModeBtn = new FCGuiBaseButton(
+                        0,
+                        this.guiLeft + 86,
+                        this.guiTop + 4,
+                        64,
+                        14,
+                        NameConst.i18n(
+                                this.cont.listMode == WirelessMagnet.ListMode.WhiteList
+                                        ? NameConst.GUI_MAGNET_CARD_WhiteList
+                                        : NameConst.GUI_MAGNET_CARD_BlackList)));
+        this.components[0] = new Component(
+                this.guiLeft + 157,
+                this.guiTop + 18,
+                this.cont.nbt,
+                "WirelessTerminal.magnet.NBT");
+        this.components[1] = new Component(
+                this.guiLeft + 157,
+                this.guiTop + 31,
+                this.cont.meta,
+                "WirelessTerminal.magnet.Meta");
+        this.components[2] = new Component(
+                this.guiLeft + 157,
+                this.guiTop + 44,
+                this.cont.ore,
+                "WirelessTerminal.magnet.Ore");
+        this.components[3] = new Component(
+                this.guiLeft + 157,
+                this.guiTop + 112,
+                this.cont.oreDict,
+                "WirelessTerminal.magnet.OreDictState");
+
+        oreDict.x = this.guiLeft + 7;
+        oreDict.y = this.guiTop + 112;
+        oreDict.setText(this.cont.oreDictFilter);
+
+        this.buttonList.add(
+                this.originalGuiBtn = new GuiTabButton(
+                        this.guiLeft + this.xSize - 44,
+                        this.guiTop - 4,
+                        this.cont.getPortableCell().getItemStack(),
+                        this.cont.getPortableCell().getItemStack().getDisplayName(),
+                        itemRender));
+        this.originalGuiBtn.setHideEdge(13); // GuiTabButton implementation //
+
+        this.clearBtn = new GuiImgButton(this.guiLeft + 7, this.guiTop + 48, Settings.ACTIONS, ActionItems.CLOSE);
+        this.clearBtn.setHalfSize(true);
+        this.buttonList.add(this.clearBtn);
+    }
+
+    @Override
+    public void drawScreen(int mouseX, int mouseY, float btn) {
+        handleTooltip(mouseX, mouseY, oreDict);
+        super.drawScreen(mouseX, mouseY, btn);
+    }
+
+    @Override
+    public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        this.fontRendererObj.drawString(NameConst.i18n(NameConst.GUI_MAGNET_CARD), 8, 6, 0x404040);
+        this.fontRendererObj.drawString(NameConst.i18n(NameConst.GUI_MAGNET_CARD_NBT), 61, 22, 0x404040);
+        this.fontRendererObj.drawString(NameConst.i18n(NameConst.GUI_MAGNET_CARD_META), 61, 34, 0x404040);
+        this.fontRendererObj.drawString(NameConst.i18n(NameConst.GUI_MAGNET_CARD_ORE), 61, 46, 0x404040);
+        this.components[0].setVar(this.cont.nbt);
+        this.components[1].setVar(this.cont.meta);
+        this.components[2].setVar(this.cont.ore);
+        this.components[3].setVar(this.cont.oreDict);
+        for (Component c : components) {
+            c.draw();
+        }
+        this.listModeBtn.displayString = NameConst.i18n(
+                this.cont.listMode == WirelessMagnet.ListMode.WhiteList ? NameConst.GUI_MAGNET_CARD_WhiteList
+                        : NameConst.GUI_MAGNET_CARD_BlackList);
+    }
+
+    @Override
+    public void drawBG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        bindTexture(TEX_BG);
+        drawTexturedModalRect(offsetX, offsetY, 0, 0, xSize, ySize);
+        oreDict.drawTextBox();
+    }
+
+    @Override
+    protected void keyTyped(char typedChar, int keyCode) {
+        if (oreDict.isFocused() && (Keyboard.KEY_NUMPADENTER == keyCode || Keyboard.KEY_RETURN == keyCode)) {
+            FluidCraft.proxy.netHandler.sendToServer(
+                    new CPacketFluidPatternTermBtns("WirelessTerminal.magnet.OreDictFilter", oreDict.getText()));
+        }
+
+        if (!oreDict.textboxKeyTyped(typedChar, keyCode)) super.keyTyped(typedChar, keyCode);
+    }
+
+    @Override
+    protected void mouseClicked(int xCoord, int yCoord, int btn) {
+        oreDict.mouseClicked(xCoord, yCoord, btn);
+        super.mouseClicked(xCoord, yCoord, btn);
+    }
+
+    @Override
+    protected void actionPerformed(GuiButton btn) {
+        for (Component c : components) {
+            if (c.sameBtn(btn)) {
+                c.send();
+                break;
+            }
+        }
+        if (btn == this.listModeBtn) {
+            FluidCraft.proxy.netHandler.sendToServer(
+                    new CPacketFluidPatternTermBtns(
+                            "WirelessTerminal.magnet.FilterMode",
+                            this.cont.listMode != WirelessMagnet.ListMode.WhiteList));
+        } else if (btn == this.originalGuiBtn) {
+            InventoryHandler.switchGui(ItemWirelessUltraTerminal.readMode(this.cont.getPortableCell().getItemStack()));
+        } else if (btn == this.clearBtn) {
+            FluidCraft.proxy.netHandler
+                    .sendToServer(new CPacketFluidPatternTermBtns("WirelessTerminal.magnet.clear", 1));
+        }
+        super.actionPerformed(btn);
+    }
+}

src/main/java/com/glodblock/github/client/gui/base/FCBaseMEGui.java

@@ -7,6 +7,7 @@ import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.inventory.Container;
 
+import com.glodblock.github.FluidCraft;
 import com.glodblock.github.client.gui.GuiEssentiaTerminal;
 import com.glodblock.github.client.gui.GuiFCImgButton;
 import com.glodblock.github.client.gui.GuiFluidCraftingWireless;
@@ -18,8 +19,11 @@ import com.glodblock.github.client.gui.container.base.FCBaseContainer;
 import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
 import com.glodblock.github.inventory.gui.GuiType;
 import com.glodblock.github.inventory.item.IWirelessTerminal;
+import com.glodblock.github.inventory.item.WirelessMagnet;
+import com.glodblock.github.network.CPacketFluidPatternTermBtns;
 import com.glodblock.github.util.ModAndClassUtil;
 
+import appeng.api.storage.StorageChannel;
 import appeng.client.gui.AEBaseMEGui;
 
 public abstract class FCBaseMEGui extends AEBaseMEGui {
@@ -31,8 +35,15 @@ public abstract class FCBaseMEGui extends AEBaseMEGui {
     protected GuiFCImgButton InterfaceTerminal;
     protected GuiFCImgButton LevelTerminal;
     protected GuiFCImgButton PatternTerminalEx;
+    protected GuiFCImgButton magnetOff;
+    protected GuiFCImgButton magnetInv;
+    protected GuiFCImgButton magnetME;
+    protected GuiFCImgButton magnetFilter;
+    protected GuiFCImgButton restockEnableBtn;
+    protected GuiFCImgButton restockDisableBtn;
     protected List<GuiFCImgButton> termBtns = new ArrayList<>();
     protected boolean drawSwitchGuiBtn;
+    private StorageChannel channel = null;
 
     public FCBaseMEGui(final InventoryPlayer inventoryPlayer, Container container) {
         super(container);
@@ -41,10 +52,19 @@ public abstract class FCBaseMEGui extends AEBaseMEGui {
             if (target instanceof IWirelessTerminal
                     && ((IWirelessTerminal) target).getItemStack().getItem() instanceof ItemWirelessUltraTerminal) {
                 this.drawSwitchGuiBtn = true;
+                channel = ((IWirelessTerminal) target).getChannel();
             }
         }
     }
 
+    protected WirelessMagnet.Mode getMagnetMode() {
+        return ((FCBaseContainer) this.inventorySlots).mode;
+    }
+
+    protected boolean isRestock() {
+        return ((FCBaseContainer) this.inventorySlots).restock;
+    }
+
     @Override
     public void onGuiClosed() {
         super.onGuiClosed();
@@ -65,6 +85,46 @@ public abstract class FCBaseMEGui extends AEBaseMEGui {
         if (!termBtns.isEmpty()) {
             this.termBtns.clear();
         }
+        if (this.getMagnetMode() != null && this.channel == StorageChannel.ITEMS) {
+            this.buttonList.add(
+                    this.magnetOff = new GuiFCImgButton(
+                            this.guiLeft + this.xSize - 18,
+                            this.guiTop + this.ySize - 124,
+                            "MAGNET_CARD",
+                            "OFF"));
+            this.buttonList.add(
+                    this.magnetInv = new GuiFCImgButton(
+                            this.guiLeft + this.xSize - 18,
+                            this.guiTop + this.ySize - 124,
+                            "MAGNET_CARD",
+                            "INV"));
+            this.buttonList.add(
+                    this.magnetME = new GuiFCImgButton(
+                            this.guiLeft + this.xSize - 18,
+                            this.guiTop + this.ySize - 124,
+                            "MAGNET_CARD",
+                            "ME"));
+            this.buttonList.add(
+                    this.magnetFilter = new GuiFCImgButton(
+                            this.guiLeft + this.xSize - 18,
+                            this.guiTop + this.ySize - 104,
+                            "MAGNET_CARD",
+                            "FILTER"));
+        }
+        if (this.channel == StorageChannel.ITEMS) {
+            this.buttonList.add(
+                    this.restockEnableBtn = new GuiFCImgButton(
+                            this.guiLeft + this.xSize - 18,
+                            this.guiTop + this.ySize - 84,
+                            "RESTOCK",
+                            "ENABLE"));
+            this.buttonList.add(
+                    this.restockDisableBtn = new GuiFCImgButton(
+                            this.guiLeft + this.xSize - 18,
+                            this.guiTop + this.ySize - 84,
+                            "RESTOCK",
+                            "DISABLE"));
+        }
         if (!(this instanceof GuiFluidCraftingWireless)) {
             this.buttonList.add(
                     this.CraftingTerminal = new GuiFCImgButton(
@@ -154,6 +214,21 @@ public abstract class FCBaseMEGui extends AEBaseMEGui {
         scheduleGuiResize = true;
     }
 
+    @Override
+    public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        if (isPortableCell()) return;
+        if (getMagnetMode() != null && this.channel == StorageChannel.ITEMS) {
+            GuiFCImgButton[] magnetButtons = { this.magnetOff, this.magnetInv, this.magnetME };
+            for (int i = 0; i < magnetButtons.length; i++) {
+                magnetButtons[i].visible = getMagnetMode().ordinal() == i;
+            }
+        }
+        if (this.drawSwitchGuiBtn && this.channel == StorageChannel.ITEMS) { // Only ultra terminal
+            this.restockDisableBtn.visible = !this.isRestock();
+            this.restockEnableBtn.visible = this.isRestock();
+        }
+    }
+
     @Override
     protected void actionPerformed(final GuiButton btn) {
         if (btn instanceof GuiFCImgButton) {
@@ -171,8 +246,20 @@ public abstract class FCBaseMEGui extends AEBaseMEGui {
                 ItemWirelessUltraTerminal.switchTerminal(this.mc.thePlayer, GuiType.WIRELESS_LEVEL_TERMINAL);
             } else if (btn == this.PatternTerminalEx) {
                 ItemWirelessUltraTerminal.switchTerminal(this.mc.thePlayer, GuiType.WIRELESS_FLUID_PATTERN_TERMINAL_EX);
+            } else if (btn == this.magnetOff || btn == this.magnetME || btn == this.magnetInv) {
+                FluidCraft.proxy.netHandler.sendToServer(
+                        new CPacketFluidPatternTermBtns("WirelessTerminal.MagnetMode", this.getMagnetMode().ordinal()));
+            } else if (btn == this.magnetFilter) {
+                FluidCraft.proxy.netHandler
+                        .sendToServer(new CPacketFluidPatternTermBtns("WirelessTerminal.OpenMagnet", 0));
+            } else if (btn == this.restockDisableBtn || btn == this.restockEnableBtn) {
+                FluidCraft.proxy.netHandler.sendToServer(new CPacketFluidPatternTermBtns("WirelessTerminal.Stock", 1));
             }
         }
         super.actionPerformed(btn);
     }
+
+    protected boolean isPortableCell() {
+        return false;
+    }
 }

src/main/java/com/glodblock/github/client/gui/container/ContainerMagnetFilter.java

@@ -0,0 +1,106 @@
+package com.glodblock.github.client.gui.container;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+import com.glodblock.github.client.gui.container.base.FCBaseContainer;
+import com.glodblock.github.inventory.item.IItemTerminal;
+import com.glodblock.github.inventory.item.IWirelessMagnetFilter;
+import com.glodblock.github.inventory.item.WirelessMagnet;
+
+import appeng.api.storage.ITerminalHost;
+import appeng.container.guisync.GuiSync;
+import appeng.container.slot.AppEngSlot;
+import appeng.container.slot.IOptionalSlotHost;
+import appeng.container.slot.OptionalSlotFake;
+import appeng.container.slot.SlotFake;
+import appeng.container.slot.SlotPatternOutputs;
+import appeng.util.Platform;
+
+public class ContainerMagnetFilter extends FCBaseContainer implements IOptionalSlotHost {
+
+    @GuiSync(101)
+    public WirelessMagnet.ListMode listMode;
+
+    @GuiSync(102)
+    public boolean nbt;
+
+    @GuiSync(103)
+    public boolean meta;
+
+    @GuiSync(104)
+    public boolean ore;
+
+    @GuiSync(105)
+    public boolean oreDict;
+
+    @GuiSync(106)
+    public String oreDictFilter;
+
+    protected OptionalSlotFake[] filterSlots;
+    protected final IInventory filter;
+
+    public ContainerMagnetFilter(InventoryPlayer ip, ITerminalHost monitorable) {
+        super(ip, monitorable);
+        this.filter = ((IItemTerminal) monitorable).getInventoryByName("config");
+        this.filterSlots = new OptionalSlotFake[27];
+        oreDictFilter = ((IWirelessMagnetFilter) getHost()).getOreDictFilter();
+        for (int y = 0; y < 3; y++) {
+            for (int x = 0; x < 9; x++) {
+                this.addSlotToContainer(
+                        this.filterSlots[x + y * 9] = new SlotPatternOutputs(
+                                this.filter,
+                                this,
+                                x + y * 9,
+                                8 + x * 18,
+                                58 + y * 18,
+                                0,
+                                0,
+                                1));
+                this.filterSlots[x + y * 9].setRenderDisabled(false);
+            }
+        }
+        bindPlayerInventory(ip, 0, 126);
+    }
+
+    @Override
+    protected boolean isWirelessTerminal() {
+        return true;
+    }
+
+    @Override
+    public ItemStack transferStackInSlot(EntityPlayer p, int idx) {
+        AppEngSlot clickSlot = (AppEngSlot) this.inventorySlots.get(idx);
+        if (clickSlot == null || !clickSlot.getHasStack()) return null;
+        ItemStack tis = clickSlot.getStack();
+        for (SlotFake slot : this.filterSlots) {
+            if (!slot.getHasStack()) {
+                slot.putStack(tis);
+                detectAndSendChanges();
+                break;
+            }
+        }
+        return super.transferStackInSlot(p, idx);
+    }
+
+    @Override
+    public void detectAndSendChanges() {
+        if (Platform.isServer() && this.getPortableCell() instanceof IWirelessMagnetFilter) {
+            IWirelessMagnetFilter host = (IWirelessMagnetFilter) this.getHost();
+            this.listMode = host.getListMode();
+            this.meta = host.getMetaMode();
+            this.nbt = host.getNBTMode();
+            this.ore = host.getOreMode();
+            this.oreDict = host.getOreDictMode();
+            this.oreDictFilter = host.getOreDictFilter();
+        }
+        super.detectAndSendChanges();
+    }
+
+    @Override
+    public boolean isSlotEnabled(int idx) {
+        return true;
+    }
+}

src/main/java/com/glodblock/github/client/gui/container/base/FCBaseContainer.java

@@ -3,32 +3,42 @@ package com.glodblock.github.client.gui.container.base;
 import net.minecraft.entity.player.InventoryPlayer;
 
 import com.glodblock.github.inventory.item.IFluidPortableCell;
+import com.glodblock.github.inventory.item.IWirelessExtendCard;
+import com.glodblock.github.inventory.item.WirelessMagnet;
 import com.glodblock.github.util.Util;
 
 import appeng.api.storage.ITerminalHost;
 import appeng.container.AEBaseContainer;
+import appeng.container.guisync.GuiSync;
+import appeng.util.Platform;
 
 public abstract class FCBaseContainer extends AEBaseContainer {
 
     private int ticks;
     private final double powerMultiplier = 0.5;
-    private IFluidPortableCell host;
+    private ITerminalHost host;
     private int slot = -1;
     private final InventoryPlayer ip;
 
+    @GuiSync(105)
+    public boolean restock = false;
+
+    @GuiSync(106)
+    public WirelessMagnet.Mode mode = WirelessMagnet.Mode.Off;
+
     public FCBaseContainer(InventoryPlayer ip, ITerminalHost monitorable) {
         super(ip, monitorable);
         this.ip = ip;
+        this.host = monitorable;
         if (isWirelessTerminal()) {
-            host = (IFluidPortableCell) monitorable;
             this.slot = lockSlot();
         }
     }
 
     private int lockSlot() {
         if (isWirelessTerminal()) {
-            if (this.host != null) {
-                final int slotIndex = this.host.getInventorySlot();
+            if (this.host instanceof IFluidPortableCell) {
+                final int slotIndex = ((IFluidPortableCell) this.host).getInventorySlot();
                 if (Util.GuiHelper.decodeInvType(slotIndex).getLeft() == Util.GuiHelper.InvType.PLAYER_INV) {
                     this.lockPlayerInventorySlot(slotIndex);
                 }
@@ -50,7 +60,14 @@ public abstract class FCBaseContainer extends AEBaseContainer {
                     this.slot,
                     this.ticks,
                     this.getPowerMultiplier(),
-                    this.host);
+                    ((IFluidPortableCell) this.host));
+        }
+
+        if (Platform.isServer()) {
+            if (this.host instanceof IWirelessExtendCard wec) {
+                this.mode = wec.getMagnetCardMode();
+                this.restock = wec.isRestock();
+            }
         }
         super.detectAndSendChanges();
     }
@@ -59,4 +76,14 @@ public abstract class FCBaseContainer extends AEBaseContainer {
         return this.powerMultiplier;
     }
 
+    public ITerminalHost getHost() {
+        return this.host;
+    }
+
+    public IFluidPortableCell getPortableCell() {
+        if (this.host instanceof IFluidPortableCell fpc) {
+            return fpc;
+        }
+        return null;
+    }
 }

src/main/java/com/glodblock/github/client/gui/container/base/FCContainerMonitor.java

@@ -230,8 +230,4 @@ public abstract class FCContainerMonitor<T extends IAEStack<T>> extends FCBaseCo
             this.getGui().updateSetting(manager, settingName, newValue);
         }
     }
-
-    public ITerminalHost getHost() {
-        return this.host;
-    }
 }

src/main/java/com/glodblock/github/common/Config.java

@@ -22,6 +22,8 @@ public class Config {
     public static boolean replaceEC2;
     public static int levelMaintainerMinTicks;
     public static int levelMaintainerMaxTicks;
+    public static int reStockTime;
+    public static int magnetRange;
 
     public static void run() {
         loadCategory();
@@ -74,6 +76,9 @@ public class Config {
         levelMaintainerMaxTicks = Config.get("LevelMaintainer", "maxTick", 120, "Number on ticks for maximal request")
                 .getInt();
 
+        reStockTime = Config.get("UltraWireless", "reStockTime", 1000, "Time between restocks").getInt();
+        magnetRange = Config.get("UltraWireless", "magnetRange", 16, "Magnet pick up radius").getInt();
+
         if (Config.hasChanged()) Config.save();
     }
 

src/main/java/com/glodblock/github/common/item/ItemBaseWirelessTerminal.java

@@ -10,6 +10,7 @@ import java.util.List;
 import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumChatFormatting;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
@@ -36,6 +37,7 @@ public class ItemBaseWirelessTerminal extends ToolWirelessTerminal implements II
     protected GuiType type;
     public static String infinityBoosterCard = "infinityBoosterCard";
     public static String infinityEnergyCard = "InfinityEnergyCard";
+    public static String restockItems = "restock";
 
     public ItemBaseWirelessTerminal(GuiType t) {
         super();
@@ -131,4 +133,8 @@ public class ItemBaseWirelessTerminal extends ToolWirelessTerminal implements II
         return this.type;
     }
 
+    public static void toggleRestockItemsMode(ItemStack is, boolean state) {
+        NBTTagCompound data = Platform.openNbtData(is);
+        data.setBoolean(restockItems, state);
+    }
 }

src/main/java/com/glodblock/github/common/item/ItemWirelessUltraTerminal.java

@@ -7,8 +7,10 @@ import java.util.Arrays;
 import java.util.EnumSet;
 import java.util.List;
 
+import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.StatCollector;
@@ -25,6 +27,8 @@ import com.glodblock.github.inventory.item.WirelessCraftingTerminalInventory;
 import com.glodblock.github.inventory.item.WirelessFluidTerminalInventory;
 import com.glodblock.github.inventory.item.WirelessInterfaceTerminalInventory;
 import com.glodblock.github.inventory.item.WirelessLevelTerminalInventory;
+import com.glodblock.github.inventory.item.WirelessMagnet;
+import com.glodblock.github.inventory.item.WirelessMagnetCardFilterInventory;
 import com.glodblock.github.inventory.item.WirelessPatternTerminalExInventory;
 import com.glodblock.github.inventory.item.WirelessPatternTerminalInventory;
 import com.glodblock.github.loader.IRegister;
@@ -40,6 +44,7 @@ import appeng.core.features.AEFeature;
 import appeng.core.localization.PlayerMessages;
 import appeng.util.Platform;
 import baubles.api.BaubleType;
+import baubles.api.BaublesApi;
 import baubles.api.IBauble;
 import cpw.mods.fml.common.Optional;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -102,7 +107,9 @@ public class ItemWirelessUltraTerminal extends ItemBaseWirelessTerminal
         try {
             IGridNode gridNode = Util.getWirelessGrid(stack);
             final GuiType gui;
-            if (Util.GuiHelper.decodeType(y).getLeft() == Util.GuiHelper.GuiType.ITEM && z > 0) {
+            if (Util.GuiHelper.decodeType(y).getLeft() == Util.GuiHelper.GuiType.ITEM && z == -1) {
+                gui = GuiType.WIRELESS_MAGNET_FILTER;
+            } else if (Util.GuiHelper.decodeType(y).getLeft() == Util.GuiHelper.GuiType.ITEM && z > 0) {
                 gui = getGuis().get(Util.GuiHelper.decodeType(y).getRight());
             } else {
                 gui = readMode(stack);
@@ -121,6 +128,8 @@ public class ItemWirelessUltraTerminal extends ItemBaseWirelessTerminal
                 return new WirelessLevelTerminalInventory(stack, x, gridNode, player);
             } else if (gui == GuiType.WIRELESS_FLUID_PATTERN_TERMINAL_EX) {
                 return new WirelessPatternTerminalExInventory(stack, x, gridNode, player);
+            } else if (gui == GuiType.WIRELESS_MAGNET_FILTER) {
+                return new WirelessMagnetCardFilterInventory(stack, x, gridNode, player);
             } else {
                 this.setMode(GuiType.WIRELESS_FLUID_TERMINAL, stack); // set as default mode
                 return new WirelessFluidTerminalInventory(stack, x, gridNode, player);
@@ -226,7 +235,21 @@ public class ItemWirelessUltraTerminal extends ItemBaseWirelessTerminal
 
     @Override
     public void onWornTick(ItemStack itemStack, EntityLivingBase entityLivingBase) {
-
+        if (Platform.isServer() && entityLivingBase instanceof EntityPlayer player) {
+            IInventory handler = BaublesApi.getBaubles(player);
+            if (handler != null) {
+                for (int i = 0; i < handler.getSizeInventory(); ++i) {
+                    if (handler.getStackInSlot(i) == itemStack) {
+                        onUpdate(
+                                itemStack,
+                                null,
+                                player,
+                                Util.GuiHelper.encodeType(i, Util.GuiHelper.InvType.PLAYER_BAUBLES),
+                                false);
+                    }
+                }
+            }
+        }
     }
 
     @Override
@@ -248,4 +271,13 @@ public class ItemWirelessUltraTerminal extends ItemBaseWirelessTerminal
     public boolean canUnequip(ItemStack itemStack, EntityLivingBase entityLivingBase) {
         return true;
     }
+
+    @Override
+    public void onUpdate(ItemStack stack, World worldIn, Entity entityIn, int slot, boolean p_77663_5_) {
+        if (Platform.isServer() && entityIn instanceof EntityPlayer player) {
+            if (WirelessMagnet.getMode(stack) != WirelessMagnet.Mode.Off) {
+                WirelessMagnet.doMagnet(stack, player.worldObj, player);
+            }
+        }
+    }
 }

src/main/java/com/glodblock/github/crossmod/waila/FCTooltipHandlerWaila.java

@@ -1,14 +1,17 @@
 package com.glodblock.github.crossmod.waila;
 
+import java.util.ArrayList;
 import java.util.List;
 
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.item.ItemPotion;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumChatFormatting;
 import net.minecraftforge.fluids.FluidStack;
 
 import com.glodblock.github.common.item.ItemFluidDrop;
+import com.glodblock.github.util.ModAndClassUtil;
 import com.glodblock.github.util.Util;
 
 import mcp.mobius.waila.handlers.nei.TooltipHandlerWaila;
@@ -36,6 +39,15 @@ public class FCTooltipHandlerWaila extends TooltipHandlerWaila {
             }
             String modName = Util.getFluidModName(fs.getFluid());
             if (modName != null && !modName.equals("")) currenttip.set(currenttip.size() - 1, "§9§o" + modName);
+
+            if (ModAndClassUtil.GT5NH || ModAndClassUtil.GT5) {
+                ItemStack potion = Util.FluidUtil.getPotion(fs);
+                if (potion != null && potion.getItem() instanceof ItemPotion) {
+                    List<String> potionEffects = new ArrayList<>();
+                    potion.getItem().addInformation(potion, Minecraft.getMinecraft().thePlayer, potionEffects, false);
+                    currenttip.addAll(currenttip.size() - 1, potionEffects);
+                }
+            }
         }
         return currenttip;
     }

src/main/java/com/glodblock/github/inventory/gui/GuiType.java

@@ -33,6 +33,7 @@ import com.glodblock.github.client.gui.GuiLargeIngredientBuffer;
 import com.glodblock.github.client.gui.GuiLevelMaintainer;
 import com.glodblock.github.client.gui.GuiLevelTerminal;
 import com.glodblock.github.client.gui.GuiLevelWireless;
+import com.glodblock.github.client.gui.GuiMagnetFilter;
 import com.glodblock.github.client.gui.GuiOCPatternEditor;
 import com.glodblock.github.client.gui.GuiPatternItemRenamer;
 import com.glodblock.github.client.gui.GuiPatternMulti;
@@ -62,6 +63,7 @@ import com.glodblock.github.client.gui.container.ContainerLargeIngredientBuffer;
 import com.glodblock.github.client.gui.container.ContainerLevelMaintainer;
 import com.glodblock.github.client.gui.container.ContainerLevelTerminal;
 import com.glodblock.github.client.gui.container.ContainerLevelWireless;
+import com.glodblock.github.client.gui.container.ContainerMagnetFilter;
 import com.glodblock.github.client.gui.container.ContainerOCPatternEditor;
 import com.glodblock.github.client.gui.container.ContainerPatternMulti;
 import com.glodblock.github.client.gui.container.ContainerPatternValueAmount;
@@ -542,6 +544,19 @@ public enum GuiType {
         protected Object createClientGui(EntityPlayer player, ITerminalHost inv) {
             return new GuiPatternItemRenamer(player.inventory, inv);
         }
+    }),
+
+    WIRELESS_MAGNET_FILTER(new ItemGuiFactory<>(ITerminalHost.class) {
+
+        @Override
+        protected Object createServerGui(EntityPlayer player, ITerminalHost inv) {
+            return new ContainerMagnetFilter(player.inventory, inv);
+        }
+
+        @Override
+        protected Object createClientGui(EntityPlayer player, ITerminalHost inv) {
+            return new GuiMagnetFilter(player.inventory, inv);
+        }
     });
 
     public static final List<GuiType> VALUES = ImmutableList.copyOf(values());

src/main/java/com/glodblock/github/inventory/item/BaseWirelessInventory.java

@@ -0,0 +1,186 @@
+package com.glodblock.github.inventory.item;
+
+import static com.glodblock.github.common.item.ItemBaseWirelessTerminal.restockItems;
+import static com.glodblock.github.inventory.item.WirelessMagnet.modeKey;
+
+import java.util.Objects;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.glodblock.github.common.item.ItemBaseWirelessTerminal;
+import com.glodblock.github.util.Util;
+
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.implementations.items.IAEItemPowerStorage;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.security.PlayerSource;
+import appeng.api.networking.storage.IStorageGrid;
+import appeng.api.storage.MEMonitorHandler;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IAEStack;
+import appeng.api.util.AECableType;
+import appeng.items.tools.powered.ToolWirelessTerminal;
+import appeng.me.storage.NullInventory;
+import appeng.util.Platform;
+
+public abstract class BaseWirelessInventory extends MEMonitorHandler implements IWirelessTerminal, IWirelessExtendCard {
+
+    protected final ItemStack target;
+    protected final IAEItemPowerStorage ips;
+    protected final int inventorySlot;
+
+    protected final IGridNode grid;
+
+    protected final PlayerSource source;
+    protected final StorageChannel channel;
+    protected WirelessMagnet.Mode magnetMode = WirelessMagnet.Mode.Off;
+    protected EntityPlayer player;
+    protected boolean restock;
+
+    @SuppressWarnings("unchecked")
+    public BaseWirelessInventory(final ItemStack is, final int slot, IGridNode gridNode, EntityPlayer player,
+            StorageChannel channel) {
+        super(Objects.requireNonNull(Util.getWirelessInv(is, player, channel)));
+        this.ips = (ToolWirelessTerminal) is.getItem();
+        this.grid = gridNode;
+        this.target = is;
+        this.inventorySlot = slot;
+        this.channel = channel;
+        this.source = new PlayerSource(player, this);
+        this.readFromNBT();
+    }
+
+    @SuppressWarnings("unchecked")
+    public BaseWirelessInventory(final ItemStack is, final int slot, IGridNode gridNode, EntityPlayer player,
+            StorageChannel channel, boolean nullInventory) {
+        super(new NullInventory<>());
+        this.ips = (ToolWirelessTerminal) is.getItem();
+        this.grid = gridNode;
+        this.target = is;
+        this.inventorySlot = slot;
+        this.channel = channel;
+        this.source = new PlayerSource(player, this);
+        this.readFromNBT();
+    }
+
+    private void readFromNBT() {
+        NBTTagCompound data = Platform.openNbtData(this.target);
+        this.setMagnetCardMode(WirelessMagnet.Mode.values()[data.getInteger(modeKey)]);
+        this.setRestock(data.getBoolean(ItemBaseWirelessTerminal.restockItems));
+    }
+
+    public StorageChannel getChannel() {
+        return this.channel;
+    }
+
+    @Override
+    public ItemStack getItemStack() {
+        return this.target;
+    }
+
+    @Override
+    public double extractAEPower(double amt, Actionable mode, PowerMultiplier usePowerMultiplier) {
+        amt = usePowerMultiplier.multiply(amt);
+        if (mode == Actionable.SIMULATE) {
+            return usePowerMultiplier.divide(Math.min(amt, this.ips.getAECurrentPower(this.target)));
+        }
+        return usePowerMultiplier.divide(this.ips.extractAEPower(this.target, amt));
+    }
+
+    @Override
+    public int getInventorySlot() {
+        return this.inventorySlot;
+    }
+
+    @Override
+    public IGridNode getGridNode(ForgeDirection dir) {
+        return this.grid;
+    }
+
+    @Override
+    public AECableType getCableConnectionType(ForgeDirection dir) {
+        return AECableType.NONE;
+    }
+
+    @Override
+    public void securityBreak() {
+        this.getGridNode(ForgeDirection.UNKNOWN).getMachine().securityBreak();
+    }
+
+    @Override
+    public void saveChanges() {}
+
+    @Override
+    public IGridNode getActionableNode() {
+        return this.grid;
+    }
+
+    @Override
+    public PlayerSource getActionSource() {
+        return this.source;
+    }
+
+    @Override
+    public void setMagnetCardMode(WirelessMagnet.Mode mode) {
+        this.magnetMode = mode;
+    }
+
+    @Override
+    public WirelessMagnet.Mode getMagnetCardMode() {
+        return this.magnetMode;
+    }
+
+    public void setMagnetCardNextMode() {
+        setMagnetCardMode(
+                WirelessMagnet.Mode.values()[(getMagnetCardMode().ordinal() + 1)
+                        % WirelessMagnet.Mode.values().length]);
+    }
+
+    public void setRestock(boolean val) {
+        this.restock = val;
+    }
+
+    public boolean isRestock() {
+        return this.restock;
+    }
+
+    public IAEStack injectItems(IAEStack aeStack) {
+        try {
+            if (aeStack.isItem()) {
+                return ((IStorageGrid) getActionableNode().getGrid().getCache(IStorageGrid.class)).getItemInventory()
+                        .injectItems((IAEItemStack) aeStack, Actionable.MODULATE, getActionSource());
+            } else {
+                return ((IStorageGrid) getActionableNode().getGrid().getCache(IStorageGrid.class)).getFluidInventory()
+                        .injectItems((IAEFluidStack) aeStack, Actionable.MODULATE, getActionSource());
+            }
+        } catch (Exception e) {
+            return aeStack;
+        }
+    }
+
+    public IAEStack extractItems(IAEStack aeStack) {
+        try {
+            if (aeStack.isItem()) {
+                return ((IStorageGrid) getActionableNode().getGrid().getCache(IStorageGrid.class)).getItemInventory()
+                        .extractItems((IAEItemStack) aeStack, Actionable.MODULATE, getActionSource());
+            } else {
+                return ((IStorageGrid) getActionableNode().getGrid().getCache(IStorageGrid.class)).getFluidInventory()
+                        .extractItems((IAEFluidStack) aeStack, Actionable.MODULATE, getActionSource());
+            }
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    public void saveSettings() {
+        NBTTagCompound data = Platform.openNbtData(this.target);
+        data.setBoolean(restockItems, this.restock);
+        data.setInteger(modeKey, this.getMagnetCardMode().ordinal());
+    }
+}

src/main/java/com/glodblock/github/inventory/item/IWirelessExtendCard.java

@@ -0,0 +1,26 @@
+package com.glodblock.github.inventory.item;
+
+import appeng.api.networking.security.PlayerSource;
+import appeng.api.storage.data.IAEStack;
+
+public interface IWirelessExtendCard {
+
+    default void setMagnetCardMode(WirelessMagnet.Mode mode) {}
+
+    WirelessMagnet.Mode getMagnetCardMode();
+
+    PlayerSource getActionSource();
+
+    IAEStack injectItems(IAEStack aeStack);
+
+    IAEStack extractItems(IAEStack aeStack);
+
+    default void setMagnetCardNextMode() {};
+
+    void setRestock(boolean val);
+
+    default boolean isRestock() {
+        return false;
+    }
+
+}

src/main/java/com/glodblock/github/inventory/item/IWirelessMagnetFilter.java

@@ -0,0 +1,31 @@
+package com.glodblock.github.inventory.item;
+
+public interface IWirelessMagnetFilter extends IWirelessTerminal, IItemTerminal {
+
+    WirelessMagnet.ListMode getListMode();
+
+    boolean getNBTMode();
+
+    boolean getMetaMode();
+
+    boolean getOreMode();
+
+    boolean getOreDictMode();
+
+    String getOreDictFilter();
+
+    void setListMode(WirelessMagnet.ListMode mode);
+
+    void setNBTMode(boolean ignoreNBT);
+
+    void setMetaMode(boolean ignoreMeta);
+
+    void setOreMode(boolean useOre);
+
+    void setOreDictMode(boolean useOreDict);
+
+    void setOreDictFilter(String str);
+
+    default void clearConfig() {};
+
+}

src/main/java/com/glodblock/github/inventory/item/IWirelessTerminal.java

@@ -8,6 +8,7 @@ import appeng.api.implementations.guiobjects.IGuiItemObject;
 import appeng.api.implementations.tiles.IViewCellStorage;
 import appeng.api.networking.IGridHost;
 import appeng.api.networking.security.IActionHost;
+import appeng.api.storage.StorageChannel;
 import appeng.tile.inventory.IAEAppEngInventory;
 
 public interface IWirelessTerminal
@@ -21,4 +22,7 @@ public interface IWirelessTerminal
         return false;
     }
 
+    default StorageChannel getChannel() {
+        return null;
+    }
 }

src/main/java/com/glodblock/github/inventory/item/WirelessCraftingTerminalInventory.java

@@ -1,7 +1,5 @@
 package com.glodblock.github.inventory.item;
 
-import java.util.Objects;
-
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.IInventory;
 import net.minecraft.item.ItemStack;
@@ -9,7 +7,6 @@ import net.minecraft.nbt.NBTTagCompound;
 import net.minecraftforge.common.util.ForgeDirection;
 
 import com.glodblock.github.inventory.ItemBiggerAppEngInventory;
-import com.glodblock.github.util.Util;
 
 import appeng.api.config.Actionable;
 import appeng.api.config.PowerMultiplier;
@@ -20,9 +17,7 @@ import appeng.api.config.TypeFilter;
 import appeng.api.config.ViewItems;
 import appeng.api.implementations.items.IAEItemPowerStorage;
 import appeng.api.networking.IGridNode;
-import appeng.api.storage.IMEInventoryHandler;
 import appeng.api.storage.IMEMonitor;
-import appeng.api.storage.MEMonitorHandler;
 import appeng.api.storage.StorageChannel;
 import appeng.api.storage.data.IAEFluidStack;
 import appeng.api.storage.data.IAEItemStack;
@@ -35,8 +30,7 @@ import appeng.tile.inventory.InvOperation;
 import appeng.util.ConfigManager;
 import appeng.util.Platform;
 
-public class WirelessCraftingTerminalInventory extends MEMonitorHandler<IAEItemStack>
-        implements IWirelessCraftTerminal {
+public class WirelessCraftingTerminalInventory extends BaseWirelessInventory implements IWirelessCraftTerminal {
 
     private final ItemStack target;
     private final IAEItemPowerStorage ips;
@@ -51,9 +45,7 @@ public class WirelessCraftingTerminalInventory extends MEMonitorHandler<IAEItemS
     @SuppressWarnings("unchecked")
     public WirelessCraftingTerminalInventory(final ItemStack is, final int slot, IGridNode gridNode,
             EntityPlayer player) {
-        super(
-                (IMEInventoryHandler<IAEItemStack>) Objects
-                        .requireNonNull(Util.getWirelessInv(is, player, StorageChannel.ITEMS)));
+        super(is, slot, gridNode, player, StorageChannel.ITEMS);
         this.ips = (ToolWirelessTerminal) is.getItem();
         this.grid = gridNode;
         this.target = is;

src/main/java/com/glodblock/github/inventory/item/WirelessFluidTerminalInventory.java

@@ -1,15 +1,11 @@
 package com.glodblock.github.inventory.item;
 
-import java.util.Objects;
-
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.IInventory;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraftforge.common.util.ForgeDirection;
 
-import com.glodblock.github.util.Util;
-
 import appeng.api.config.Actionable;
 import appeng.api.config.PowerMultiplier;
 import appeng.api.config.Settings;
@@ -18,9 +14,7 @@ import appeng.api.config.SortOrder;
 import appeng.api.config.ViewItems;
 import appeng.api.implementations.items.IAEItemPowerStorage;
 import appeng.api.networking.IGridNode;
-import appeng.api.storage.IMEInventoryHandler;
 import appeng.api.storage.IMEMonitor;
-import appeng.api.storage.MEMonitorHandler;
 import appeng.api.storage.StorageChannel;
 import appeng.api.storage.data.IAEFluidStack;
 import appeng.api.storage.data.IAEItemStack;
@@ -33,7 +27,7 @@ import appeng.tile.inventory.InvOperation;
 import appeng.util.ConfigManager;
 import appeng.util.Platform;
 
-public class WirelessFluidTerminalInventory extends MEMonitorHandler<IAEFluidStack> implements IWirelessTerminal {
+public class WirelessFluidTerminalInventory extends BaseWirelessInventory implements IWirelessTerminal, IItemTerminal {
 
     private final ItemStack target;
     private final IAEItemPowerStorage ips;
@@ -44,9 +38,7 @@ public class WirelessFluidTerminalInventory extends MEMonitorHandler<IAEFluidSta
 
     @SuppressWarnings("unchecked")
     public WirelessFluidTerminalInventory(final ItemStack is, final int slot, IGridNode gridNode, EntityPlayer player) {
-        super(
-                (IMEInventoryHandler<IAEFluidStack>) Objects
-                        .requireNonNull(Util.getWirelessInv(is, player, StorageChannel.FLUIDS)));
+        super(is, slot, gridNode, player, StorageChannel.FLUIDS);
         this.ips = (ToolWirelessTerminal) is.getItem();
         this.grid = gridNode;
         this.target = is;
@@ -135,4 +127,9 @@ public class WirelessFluidTerminalInventory extends MEMonitorHandler<IAEFluidSta
     @Override
     public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removedStack,
             ItemStack newStack) {}
+
+    @Override
+    public IInventory getInventoryByName(String name) {
+        return null;
+    }
 }

src/main/java/com/glodblock/github/inventory/item/WirelessMagnet.java

@@ -0,0 +1,139 @@
+package com.glodblock.github.inventory.item;
+
+import static com.glodblock.github.common.Config.magnetRange;
+
+import java.util.Iterator;
+import java.util.List;
+
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.item.EntityXPOrb;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+
+import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
+
+import appeng.util.Platform;
+
+public class WirelessMagnet {
+
+    public static String modeKey = "MagnetMode";
+    public static String filterKey = "MagnetFilter";
+    public static String filterConfigKey = "MagnetConfig";
+
+    public enum Mode {
+        Off,
+        Inv,
+        ME
+    }
+
+    public enum ListMode {
+        WhiteList,
+        BlackList
+    }
+
+    public static List<?> getEntitiesInRange(Class<?> entityType, World world, int x, int y, int z, int distance) {
+        return world.getEntitiesWithinAABB(
+                entityType,
+                AxisAlignedBB.getBoundingBox(
+                        x - distance,
+                        y - distance,
+                        z - distance,
+                        x + distance,
+                        y + distance,
+                        z + distance));
+    }
+
+    @SuppressWarnings("unchecked")
+
+    public static boolean isConfigured(ItemStack wirelessTerm) {
+        NBTTagCompound data = Platform.openNbtData(wirelessTerm);
+        return data.hasKey(modeKey);
+    }
+
+    public static void doMagnet(ItemStack wirelessTerm, World world, EntityPlayer player) {
+        if (wirelessTerm == null || player == null || player.isSneaking() || !isConfigured(wirelessTerm)) return;
+
+        Iterator<?> iterator = getEntitiesInRange(
+                EntityItem.class,
+                world,
+                (int) player.posX,
+                (int) player.posY,
+                (int) player.posZ,
+                magnetRange).iterator();
+
+        while (iterator.hasNext()) {
+            EntityItem itemToGet = (EntityItem) iterator.next();
+            EntityPlayer closestPlayer = world.getClosestPlayerToEntity(itemToGet, magnetRange);
+
+            if (closestPlayer != null && closestPlayer == player) {
+                NBTTagCompound itemNBT = new NBTTagCompound();
+                itemToGet.writeEntityToNBT(itemNBT);
+
+                if (itemToGet.func_145800_j() == null
+                        || !itemToGet.func_145800_j().equals(player.getCommandSenderName()))
+                    itemToGet.delayBeforeCanPickup = 0;
+
+                if (itemToGet.delayBeforeCanPickup <= 0) {
+                    itemNBT.setBoolean("attractable", true);
+                    itemToGet.readEntityFromNBT(itemNBT);
+                }
+
+                if (itemNBT.getBoolean("attractable")) {
+                    itemToGet.motionX = itemToGet.motionY = itemToGet.motionZ = 0;
+                    itemToGet.setPosition(
+                            player.posX - 0.2 + (world.rand.nextDouble() * 0.4),
+                            player.posY - 0.6,
+                            player.posZ - 0.2 + (world.rand.nextDouble() * 0.4));
+                }
+            }
+        }
+
+        // xp
+        iterator = getEntitiesInRange(
+                EntityXPOrb.class,
+                world,
+                (int) player.posX,
+                (int) player.posY,
+                (int) player.posZ,
+                magnetRange).iterator();
+        while (iterator.hasNext()) {
+            EntityXPOrb xpToGet = (EntityXPOrb) iterator.next();
+            EntityPlayer closestPlayer = world.getClosestPlayerToEntity(xpToGet, magnetRange);
+
+            if (!xpToGet.isDead && !xpToGet.isInvisible() && closestPlayer != null && closestPlayer == player) {
+                int xpAmount = xpToGet.xpValue;
+                xpToGet.xpValue = 0;
+                player.xpCooldown = 0;
+                player.addExperience(xpAmount);
+                xpToGet.setDead();
+                xpToGet.setInvisible(true);
+                world.playSoundAtEntity(
+                        player,
+                        "random.orb",
+                        0.08F,
+                        0.5F * ((world.rand.nextFloat() - world.rand.nextFloat()) * 0.7F + 1.8F));
+            }
+        }
+    }
+
+    public static Mode getMode(ItemStack is) {
+        if (is != null && is.getItem() instanceof ItemWirelessUltraTerminal) {
+            NBTTagCompound data = Platform.openNbtData(is);
+            if (data.hasKey(modeKey)) {
+                return Mode.values()[data.getInteger(modeKey)];
+            }
+            setMode(is, Mode.Off);
+        }
+        return Mode.Off;
+    }
+
+    public static void setMode(ItemStack is, Mode mode) {
+        if (is != null && is.getItem() instanceof ItemWirelessUltraTerminal) {
+            NBTTagCompound data = Platform.openNbtData(is);
+            data.setInteger(modeKey, mode.ordinal());
+        }
+    }
+}

src/main/java/com/glodblock/github/inventory/item/WirelessMagnetCardFilterInventory.java

@@ -0,0 +1,291 @@
+package com.glodblock.github.inventory.item;
+
+import static com.glodblock.github.inventory.item.WirelessMagnet.filterConfigKey;
+import static com.glodblock.github.inventory.item.WirelessMagnet.filterKey;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.WeakHashMap;
+import java.util.function.Predicate;
+
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+
+import com.glodblock.github.inventory.ItemBiggerAppEngInventory;
+
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.networking.IGridNode;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.util.IConfigManager;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.Platform;
+import appeng.util.item.AEItemStack;
+import appeng.util.item.OreHelper;
+import appeng.util.prioitylist.OreFilteredList;
+
+public class WirelessMagnetCardFilterInventory extends BaseWirelessInventory implements IWirelessMagnetFilter {
+
+    private boolean ignoreNbt;
+    private boolean ignoreMeta;
+    private boolean useOre;
+    private boolean useOreDict;
+    private String oreDictFilter = "";
+    protected Predicate<IAEItemStack> filterPredicate = null;
+    private WirelessMagnet.ListMode listMode = WirelessMagnet.ListMode.BlackList;
+    private final AppEngInternalInventory filterInventory;
+    private final NBTTagCompound settingCache;
+    private final NBTTagCompound filterCache;
+
+    @SuppressWarnings("unchecked")
+    public WirelessMagnetCardFilterInventory(ItemStack is, int slot, IGridNode gridNode, EntityPlayer player) {
+        super(is, slot, gridNode, player, StorageChannel.ITEMS, true);
+        filterInventory = new ItemBiggerAppEngInventory(is, filterKey, 27) {
+
+            @Override
+            public void setInventorySlotContents(int slot, ItemStack newItemStack) {
+                if (newItemStack != null) newItemStack.stackSize = 1;
+                super.setInventorySlotContents(slot, newItemStack);
+            }
+        };
+        settingCache = getSettingTag(is);
+        filterCache = getFilterTag(is);
+        readFromNBT();
+    }
+
+    public void readFromNBT() {
+        NBTTagCompound data = Platform.openNbtData(this.target);
+        if (!data.hasKey(filterConfigKey)) this.writeToNBT();
+        NBTTagCompound tag = (NBTTagCompound) data.getTag(filterConfigKey);
+        ignoreNbt = tag.getBoolean("nbt");
+        ignoreMeta = tag.getBoolean("meta");
+        useOre = tag.getBoolean("ore");
+        useOreDict = tag.getBoolean("oreDict");
+        oreDictFilter = tag.getString("oreDictFilter");
+        this.listMode = WirelessMagnet.ListMode.values()[tag.getInteger("list")];
+    }
+
+    public void writeToNBT() {
+        NBTTagCompound data = Platform.openNbtData(this.target);
+        NBTTagCompound tmp = new NBTTagCompound();
+        tmp.setBoolean("nbt", ignoreNbt);
+        tmp.setBoolean("meta", ignoreMeta);
+        tmp.setBoolean("ore", useOre);
+        tmp.setBoolean("oreDict", useOreDict);
+        tmp.setString("oreDictFilter", oreDictFilter);
+        tmp.setInteger("list", this.listMode.ordinal());
+        data.setTag(filterConfigKey, tmp);
+    }
+
+    private NBTTagCompound getSettingTag(ItemStack is) {
+        return (NBTTagCompound) is.getTagCompound().getCompoundTag(filterConfigKey).copy();
+    }
+
+    private NBTTagCompound getFilterTag(ItemStack is) {
+        return (NBTTagCompound) is.getTagCompound().getCompoundTag(filterKey).copy();
+    }
+
+    @Override
+    public WirelessMagnet.ListMode getListMode() {
+        return this.listMode;
+    }
+
+    @Override
+    public boolean getNBTMode() {
+        return ignoreNbt;
+    }
+
+    @Override
+    public boolean getMetaMode() {
+        return ignoreMeta;
+    }
+
+    @Override
+    public boolean getOreMode() {
+        return useOre;
+    }
+
+    @Override
+    public boolean getOreDictMode() {
+        return useOreDict;
+    }
+
+    @Override
+    public String getOreDictFilter() {
+        return oreDictFilter;
+    }
+
+    @Override
+    public void setListMode(WirelessMagnet.ListMode mode) {
+        this.listMode = mode;
+    }
+
+    @Override
+    public void setNBTMode(boolean ignoreNBT) {
+        ignoreNbt = ignoreNBT;
+    }
+
+    @Override
+    public void setMetaMode(boolean ignoreMeta) {
+        this.ignoreMeta = ignoreMeta;
+    }
+
+    @Override
+    public void setOreMode(boolean useOre) {
+        this.useOre = useOre;
+    }
+
+    @Override
+    public void setOreDictMode(boolean useOreDict) {
+        this.useOreDict = useOreDict;
+    }
+
+    @Override
+    public void setOreDictFilter(String str) {
+        oreDictFilter = str;
+        filterPredicate = null;
+    }
+
+    @Override
+    public void clearConfig() {
+        IInventory inv = this.getInventoryByName("config");
+        for (int i = 0; i < inv.getSizeInventory(); i++) {
+            inv.setInventorySlotContents(i, null);
+        }
+    }
+
+    @Override
+    public StorageChannel getChannel() {
+        return null;
+    }
+
+    @Override
+    public IInventory getViewCellStorage() {
+        return null;
+    }
+
+    @Override
+    public double extractAEPower(double amt, Actionable mode, PowerMultiplier usePowerMultiplier) {
+        return 0;
+    }
+
+    @Override
+    public IMEMonitor<IAEItemStack> getItemInventory() {
+        return null;
+    }
+
+    @Override
+    public IMEMonitor<IAEFluidStack> getFluidInventory() {
+        return null;
+    }
+
+    @Override
+    public IConfigManager getConfigManager() {
+        return null;
+    }
+
+    @Override
+    public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removedStack,
+            ItemStack newStack) {}
+
+    @Override
+    public void saveSettings() {
+        super.saveSettings();
+        writeToNBT();
+    }
+
+    @Override
+    public IInventory getInventoryByName(String name) {
+        if (name.equals("config")) {
+            return filterInventory;
+        }
+        return null;
+    }
+
+    public boolean doInject(IAEItemStack is, EntityItem itemToGet, World world) {
+        IAEItemStack ais = (IAEItemStack) injectItems(is);
+        if (ais != null) {
+            player.onItemPickup(itemToGet, ais.getItemStack().stackSize);
+            player.inventory.addItemStackToInventory(ais.getItemStack());
+            world.playSoundAtEntity(
+                    player,
+                    "random.pop",
+                    0.15F,
+                    ((world.rand.nextFloat() - world.rand.nextFloat()) * 0.7F + 1.0F) * 2.0F);
+            return false;
+        }
+        return true;
+    }
+
+    public boolean isItemFiltered(ItemStack inputItemStack) {
+        if (useOreDict && !oreDictFilter.isEmpty()) {
+            if (filterPredicate == null) filterPredicate = OreFilteredList.makeFilter(oreDictFilter);
+            if (filterPredicate.test(AEItemStack.create(inputItemStack))) return true;
+        }
+
+        for (int i = 0; i < filterInventory.getSizeInventory(); i++) {
+            ItemStack is = filterInventory.getStackInSlot(i);
+            if (is != null) {
+                if (useOre) {
+                    // use oredict
+                    if (OreHelper.INSTANCE
+                            .sameOre(OreHelper.INSTANCE.isOre(is), OreHelper.INSTANCE.isOre(inputItemStack)))
+                        return true;
+                }
+                if (ignoreMeta && ignoreNbt) {
+                    // ignore meta & nbt
+                    return is.getItem().equals(inputItemStack.getItem());
+                } else if (ignoreMeta) {
+                    // ignore meta only
+                    return ItemStack.areItemStackTagsEqual(is, inputItemStack)
+                            && is.getItem() == inputItemStack.getItem();
+                } else if (ignoreNbt) {
+                    // ignore nbt only
+                    return is.getItem() == inputItemStack.getItem()
+                            && is.getItemDamage() == inputItemStack.getItemDamage();
+                } else {
+                    // ignore nothing/don't use oredict--must be exact match
+                    return is.isItemEqual(inputItemStack) && ItemStack.areItemStackTagsEqual(is, inputItemStack);
+                }
+            }
+        }
+        return false;
+    }
+
+    public boolean isPassFilter(ItemStack is) {
+        return is != null && (listMode == WirelessMagnet.ListMode.WhiteList) == isItemFiltered(is);
+    }
+
+    public boolean checkCache(ItemStack is) {
+        return settingCache.equals(getSettingTag(is)) && filterCache.equals(getFilterTag(is));
+    }
+
+    public static class FilterCache {
+
+        private static final Map<UUID, WirelessMagnetCardFilterInventory> cache = new WeakHashMap<>();
+
+        public static WirelessMagnetCardFilterInventory getFilter(ItemStack is, int slot, IGridNode gridNode,
+                EntityPlayer player) {
+            WirelessMagnetCardFilterInventory cachedInv = cache.get(player.getUniqueID());
+            if (cachedInv != null && cachedInv.checkCache(is)) {
+                return cachedInv;
+            } else {
+                WirelessMagnetCardFilterInventory newInv = new WirelessMagnetCardFilterInventory(
+                        is,
+                        slot,
+                        gridNode,
+                        player);
+                cache.put(player.getUniqueID(), newInv);
+                return newInv;
+            }
+        }
+    }
+}

src/main/java/com/glodblock/github/inventory/item/WirelessPatternTerminalExInventory.java

@@ -2,7 +2,6 @@ package com.glodblock.github.inventory.item;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.IInventory;
@@ -14,7 +13,6 @@ import com.glodblock.github.common.item.ItemFluidDrop;
 import com.glodblock.github.common.item.ItemFluidPacket;
 import com.glodblock.github.inventory.ItemBiggerAppEngInventory;
 import com.glodblock.github.inventory.WirelessFluidPatternTerminalPatterns;
-import com.glodblock.github.util.Util;
 
 import appeng.api.config.Actionable;
 import appeng.api.config.PowerMultiplier;
@@ -27,9 +25,7 @@ import appeng.api.implementations.ICraftingPatternItem;
 import appeng.api.implementations.items.IAEItemPowerStorage;
 import appeng.api.networking.IGridNode;
 import appeng.api.networking.crafting.ICraftingPatternDetails;
-import appeng.api.storage.IMEInventoryHandler;
 import appeng.api.storage.IMEMonitor;
-import appeng.api.storage.MEMonitorHandler;
 import appeng.api.storage.StorageChannel;
 import appeng.api.storage.data.IAEFluidStack;
 import appeng.api.storage.data.IAEItemStack;
@@ -42,8 +38,7 @@ import appeng.tile.inventory.InvOperation;
 import appeng.util.ConfigManager;
 import appeng.util.Platform;
 
-public class WirelessPatternTerminalExInventory extends MEMonitorHandler<IAEItemStack>
-        implements IWirelessPatternTerminal {
+public class WirelessPatternTerminalExInventory extends BaseWirelessInventory implements IWirelessPatternTerminal {
 
     private final ItemStack target;
     private final IAEItemPowerStorage ips;
@@ -68,9 +63,7 @@ public class WirelessPatternTerminalExInventory extends MEMonitorHandler<IAEItem
     @SuppressWarnings("unchecked")
     public WirelessPatternTerminalExInventory(final ItemStack is, final int slot, IGridNode gridNode,
             EntityPlayer player) {
-        super(
-                (IMEInventoryHandler<IAEItemStack>) Objects
-                        .requireNonNull(Util.getWirelessInv(is, player, StorageChannel.ITEMS)));
+        super(is, slot, gridNode, player, StorageChannel.ITEMS);
         this.ips = (ToolWirelessTerminal) is.getItem();
         this.grid = gridNode;
         this.target = is;
@@ -419,6 +412,7 @@ public class WirelessPatternTerminalExInventory extends MEMonitorHandler<IAEItem
 
     @Override
     public void saveSettings() {
+        super.saveSettings();
         this.writeToNBT();
     }
 

src/main/java/com/glodblock/github/inventory/item/WirelessPatternTerminalInventory.java

@@ -2,7 +2,6 @@ package com.glodblock.github.inventory.item;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.IInventory;
@@ -14,7 +13,6 @@ import com.glodblock.github.common.item.ItemFluidDrop;
 import com.glodblock.github.common.item.ItemFluidPacket;
 import com.glodblock.github.inventory.ItemBiggerAppEngInventory;
 import com.glodblock.github.inventory.WirelessFluidPatternTerminalPatterns;
-import com.glodblock.github.util.Util;
 
 import appeng.api.config.Actionable;
 import appeng.api.config.PowerMultiplier;
@@ -27,9 +25,7 @@ import appeng.api.implementations.ICraftingPatternItem;
 import appeng.api.implementations.items.IAEItemPowerStorage;
 import appeng.api.networking.IGridNode;
 import appeng.api.networking.crafting.ICraftingPatternDetails;
-import appeng.api.storage.IMEInventoryHandler;
 import appeng.api.storage.IMEMonitor;
-import appeng.api.storage.MEMonitorHandler;
 import appeng.api.storage.StorageChannel;
 import appeng.api.storage.data.IAEFluidStack;
 import appeng.api.storage.data.IAEItemStack;
@@ -42,8 +38,7 @@ import appeng.tile.inventory.InvOperation;
 import appeng.util.ConfigManager;
 import appeng.util.Platform;
 
-public class WirelessPatternTerminalInventory extends MEMonitorHandler<IAEItemStack>
-        implements IWirelessPatternTerminal {
+public class WirelessPatternTerminalInventory extends BaseWirelessInventory implements IWirelessPatternTerminal {
 
     private final ItemStack target;
     private final IAEItemPowerStorage ips;
@@ -68,9 +63,7 @@ public class WirelessPatternTerminalInventory extends MEMonitorHandler<IAEItemSt
     @SuppressWarnings("unchecked")
     public WirelessPatternTerminalInventory(final ItemStack is, final int slot, IGridNode gridNode,
             EntityPlayer player) {
-        super(
-                (IMEInventoryHandler<IAEItemStack>) Objects
-                        .requireNonNull(Util.getWirelessInv(is, player, StorageChannel.ITEMS)));
+        super(is, slot, gridNode, player, StorageChannel.ITEMS);
         this.ips = (ToolWirelessTerminal) is.getItem();
         this.grid = gridNode;
         this.target = is;
@@ -391,6 +384,7 @@ public class WirelessPatternTerminalInventory extends MEMonitorHandler<IAEItemSt
 
     @Override
     public void saveSettings() {
+        super.saveSettings();
         this.writeToNBT();
     }
 

src/main/java/com/glodblock/github/loader/KeybindLoader.java

@@ -8,7 +8,9 @@ import net.minecraft.item.ItemStack;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.lwjgl.input.Keyboard;
 
+import com.glodblock.github.FluidCraft;
 import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
+import com.glodblock.github.network.CPacketValueConfig;
 import com.glodblock.github.util.Util;
 
 import cpw.mods.fml.client.registry.ClientRegistry;
@@ -22,11 +24,14 @@ import cpw.mods.fml.relauncher.SideOnly;
 public class KeybindLoader implements Runnable {
 
     public static KeyBinding openTerminal;
+    public static KeyBinding restock;
 
     @Override
     public void run() {
-        openTerminal = new KeyBinding("key.OpenTerminal", Keyboard.CHAR_NONE, "itemGroup.ae2fc");
+        openTerminal = new KeyBinding(FluidCraft.MODID + ".key.OpenTerminal", Keyboard.CHAR_NONE, "itemGroup.ae2fc");
+        restock = new KeyBinding(FluidCraft.MODID + ".key.Restock", Keyboard.CHAR_NONE, "itemGroup.ae2fc");
         ClientRegistry.registerKeyBinding(openTerminal);
+        ClientRegistry.registerKeyBinding(restock);
         FMLCommonHandler.instance().bus().register(this);
     }
 
@@ -35,6 +40,8 @@ public class KeybindLoader implements Runnable {
     public void onKeyInput(InputEvent.KeyInputEvent event) {
         if (openTerminal.isPressed()) {
             handleOpenTerminalKey();
+        } else if (restock.isPressed()) {
+            handleRestockKey();
         }
     }
 
@@ -43,6 +50,8 @@ public class KeybindLoader implements Runnable {
     public void onMouseInput(InputEvent.MouseInputEvent event) {
         if (openTerminal.isPressed()) {
             handleOpenTerminalKey();
+        } else if (restock.isPressed()) {
+            handleRestockKey();
         }
     }
 
@@ -60,4 +69,17 @@ public class KeybindLoader implements Runnable {
                     ((ItemWirelessUltraTerminal) term.getRight().getItem()).guiGuiType(term.getRight()));
         }
     }
+
+    private void handleRestockKey() {
+        if (Minecraft.getMinecraft().currentScreen != null) return;
+        EntityClientPlayerMP p = Minecraft.getMinecraft().thePlayer;
+        if (p.openContainer == null) {
+            return;
+        }
+
+        ImmutablePair<Integer, ItemStack> term = Util.getUltraWirelessTerm(p);
+        if (term != null) {
+            FluidCraft.proxy.netHandler.sendToServer(new CPacketValueConfig(0, 1));
+        }
+    }
 }

src/main/java/com/glodblock/github/network/CPacketFluidPatternTermBtns.java

@@ -1,9 +1,20 @@
 package com.glodblock.github.network;
 
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Container;
+import net.minecraftforge.common.util.ForgeDirection;
 
 import com.glodblock.github.client.gui.container.ContainerFluidStorageBus;
+import com.glodblock.github.client.gui.container.base.FCBaseContainer;
 import com.glodblock.github.client.gui.container.base.FCContainerEncodeTerminal;
+import com.glodblock.github.inventory.InventoryHandler;
+import com.glodblock.github.inventory.gui.GuiType;
+import com.glodblock.github.inventory.item.IItemTerminal;
+import com.glodblock.github.inventory.item.IWirelessExtendCard;
+import com.glodblock.github.inventory.item.IWirelessMagnetFilter;
+import com.glodblock.github.inventory.item.WirelessMagnet;
+import com.glodblock.github.util.BlockPos;
+import com.glodblock.github.util.Util;
 
 import cpw.mods.fml.common.network.simpleimpl.IMessage;
 import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
@@ -25,6 +36,10 @@ public class CPacketFluidPatternTermBtns implements IMessage {
         Value = value.toString();
     }
 
+    public CPacketFluidPatternTermBtns(final String name, final boolean value) {
+        this(name, value ? 1 : 0);
+    }
+
     public CPacketFluidPatternTermBtns() {
         // NO-OP
     }
@@ -64,7 +79,55 @@ public class CPacketFluidPatternTermBtns implements IMessage {
             String Name = message.Name;
             String Value = message.Value;
             final Container c = ctx.getServerHandler().playerEntity.openContainer;
-            if (Name.startsWith("PatternTerminal.") && (c instanceof final FCContainerEncodeTerminal cpt)) {
+            final EntityPlayer player = ctx.getServerHandler().playerEntity;
+            if (Name.startsWith("WirelessTerminal.") && (c instanceof FCBaseContainer)) {
+                final FCBaseContainer cpt = (FCBaseContainer) c;
+                final IItemTerminal itemTerminal = (IItemTerminal) cpt.getHost();
+                final IWirelessExtendCard iwt = (IWirelessExtendCard) itemTerminal;
+                switch (Name) {
+                    case "WirelessTerminal.Stock":
+                        iwt.setRestock(!iwt.isRestock());
+                        break;
+                    case "WirelessTerminal.MagnetMode":
+                        iwt.setMagnetCardNextMode();
+                        break;
+                    case "WirelessTerminal.OpenMagnet":
+                        InventoryHandler.openGui(
+                            player,
+                            player.worldObj,
+                            new BlockPos(
+                                cpt.getPortableCell().getInventorySlot(),
+                                Util.GuiHelper.encodeType(0, Util.GuiHelper.GuiType.ITEM),
+                                -1),
+                            ForgeDirection.UNKNOWN,
+                            GuiType.WIRELESS_MAGNET_FILTER);
+                        break;
+                    case "WirelessTerminal.magnet.NBT":
+                        ((IWirelessMagnetFilter) itemTerminal).setNBTMode(Value.equals("1"));
+                        break;
+                    case "WirelessTerminal.magnet.Meta":
+                        ((IWirelessMagnetFilter) itemTerminal).setMetaMode(Value.equals("1"));
+                        break;
+                    case "WirelessTerminal.magnet.Ore":
+                        ((IWirelessMagnetFilter) itemTerminal).setOreMode(Value.equals("1"));
+                        break;
+                    case "WirelessTerminal.magnet.OreDictState":
+                        ((IWirelessMagnetFilter) itemTerminal).setOreDictMode(Value.equals("1"));
+                        break;
+                    case "WirelessTerminal.magnet.OreDictFilter":
+                        ((IWirelessMagnetFilter) itemTerminal).setOreDictFilter(Value);
+                        break;
+                    case "WirelessTerminal.magnet.FilterMode":
+                        ((IWirelessMagnetFilter) itemTerminal).setListMode(
+                            Value.equals("1") ? WirelessMagnet.ListMode.WhiteList
+                                : WirelessMagnet.ListMode.BlackList);
+                        break;
+                    case "WirelessTerminal.magnet.clear":
+                        ((IWirelessMagnetFilter) itemTerminal).clearConfig();
+                        break;
+                }
+                itemTerminal.saveSettings();
+            } else if (Name.startsWith("PatternTerminal.") && (c instanceof final FCContainerEncodeTerminal cpt)) {
                 switch (Name) {
                     case "PatternTerminal.CraftMode" -> cpt.getPatternTerminal().setCraftingRecipe(Value.equals("1"));
                     case "PatternTerminal.Encode" -> {

src/main/java/com/glodblock/github/network/CPacketValueConfig.java

@@ -2,9 +2,23 @@ package com.glodblock.github.network;
 
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Container;
+import net.minecraft.inventory.ContainerPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.StatCollector;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
 
 import com.glodblock.github.client.gui.container.ContainerFluidLevelEmitter;
+import com.glodblock.github.common.item.ItemBaseWirelessTerminal;
+import com.glodblock.github.inventory.item.WirelessCraftingTerminalInventory;
+import com.glodblock.github.util.NameConst;
+import com.glodblock.github.util.Util;
 
+import appeng.api.AEApi;
+import appeng.api.config.Actionable;
+import appeng.api.networking.IGridNode;
+import appeng.api.storage.data.IAEItemStack;
 import cpw.mods.fml.common.network.simpleimpl.IMessage;
 import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
 import cpw.mods.fml.common.network.simpleimpl.MessageContext;
@@ -39,13 +53,61 @@ public class CPacketValueConfig implements IMessage {
         @Override
         public IMessage onMessage(CPacketValueConfig message, MessageContext ctx) {
             EntityPlayer player = ctx.getServerHandler().playerEntity;
-            if (player.openContainer != null) {
-                Container container = player.openContainer;
+            Container container = player.openContainer;
+            if (container != null) {
                 if (container instanceof ContainerFluidLevelEmitter) {
                     ((ContainerFluidLevelEmitter) container).setLevel(message.amount, player);
+                } else if (container instanceof ContainerPlayer) {
+                    ImmutablePair<Integer, ItemStack> result = Util.getUltraWirelessTerm(player);
+                    if (result != null) {
+                        final ItemStack wirelessTerm = result.getRight();
+                        if (message.valueIndex == 1) {
+                            ItemBaseWirelessTerminal
+                                    .toggleRestockItemsMode(wirelessTerm, !Util.isRestock(wirelessTerm));
+                            player.addChatMessage(
+                                    new ChatComponentText(
+                                            StatCollector.translateToLocal(
+                                                    !Util.isRestock(wirelessTerm)
+                                                            ? NameConst.TT_ULTRA_TERMINAL_RESTOCK_ON
+                                                            : NameConst.TT_ULTRA_TERMINAL_RESTOCK_OFF)));
+                        } else {
+                            IGridNode gridNode = Util.getWirelessGrid(wirelessTerm);
+                            if (gridNode != null && Util.isRestock(wirelessTerm)
+                                    && Util.rangeCheck(wirelessTerm, player, gridNode)) {
+                                restockItems(wirelessTerm, gridNode, result.getLeft(), player);
+                            }
+                        }
+                    }
                 }
             }
             return null;
         }
+
+        @SuppressWarnings("unchecked")
+        private void restockItems(ItemStack terminal, IGridNode gridNode, int slot, EntityPlayer player) {
+            WirelessCraftingTerminalInventory inv = new WirelessCraftingTerminalInventory(
+                    terminal,
+                    slot,
+                    gridNode,
+                    player);
+
+            for (int i = 0; i < 9; i++) {
+                ItemStack is = player.inventory.mainInventory[i];
+                if (is != null) {
+                    int maxSize = is.getMaxStackSize();
+                    if (is.stackSize < maxSize) {
+                        int fillSize = maxSize - is.stackSize;
+                        IAEItemStack ias = AEApi.instance().storage().createItemStack(is);
+                        ias.setStackSize(fillSize);
+
+                        IAEItemStack extractedItem = (IAEItemStack) inv
+                                .extractItems(ias, Actionable.MODULATE, inv.getActionSource());
+                        if (extractedItem != null) {
+                            player.inventory.addItemStackToInventory(extractedItem.getItemStack());
+                        }
+                    }
+                }
+            }
+        }
     }
 }

src/main/java/com/glodblock/github/proxy/ClientProxy.java

@@ -1,18 +1,33 @@
 package com.glodblock.github.proxy;
 
+import static com.glodblock.github.common.Config.reStockTime;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.item.ItemStack;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+
+import com.glodblock.github.FluidCraft;
 import com.glodblock.github.loader.KeybindLoader;
 import com.glodblock.github.loader.ListenerLoader;
 import com.glodblock.github.loader.RenderLoader;
 import com.glodblock.github.nei.recipes.DefaultExtractorLoader;
+import com.glodblock.github.network.CPacketValueConfig;
 import com.glodblock.github.util.ModAndClassUtil;
+import com.glodblock.github.util.Util;
 
 import cpw.mods.fml.common.event.FMLInitializationEvent;
 import cpw.mods.fml.common.event.FMLLoadCompleteEvent;
 import cpw.mods.fml.common.event.FMLPostInitializationEvent;
 import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
 
 public class ClientProxy extends CommonProxy {
 
+    private static final Minecraft mc = Minecraft.getMinecraft();
+    private static long refreshTick = System.currentTimeMillis();
+
     @Override
     public void preInit(FMLPreInitializationEvent event) {
         super.preInit(event);
@@ -38,4 +53,16 @@ public class ClientProxy extends CommonProxy {
             new DefaultExtractorLoader().run();
         }
     }
+
+    @SubscribeEvent
+    public void tickEvent(TickEvent.PlayerTickEvent e) {
+        if (refreshTick + reStockTime < System.currentTimeMillis()) {
+            // try to stock items
+            ImmutablePair<Integer, ItemStack> result = Util.getUltraWirelessTerm(mc.thePlayer);
+            if (result != null && mc.currentScreen == null && Util.isRestock(result.getRight())) {
+                FluidCraft.proxy.netHandler.sendToServer(new CPacketValueConfig(1, 0));
+            }
+            refreshTick = System.currentTimeMillis();
+        }
+    }
 }

src/main/java/com/glodblock/github/proxy/CommonProxy.java

@@ -1,6 +1,13 @@
 package com.glodblock.github.proxy;
 
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.player.EntityItemPickupEvent;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
 
 import com.glodblock.github.FluidCraft;
 import com.glodblock.github.common.Config;
@@ -12,24 +19,74 @@ import com.glodblock.github.crossmod.extracells.EC2Replacer;
 import com.glodblock.github.crossmod.thaumcraft.AspectUtil;
 import com.glodblock.github.crossmod.thaumcraft.ThaumicEnergisticsCrafting;
 import com.glodblock.github.inventory.external.AEFluidInterfaceHandler;
+import com.glodblock.github.inventory.item.WirelessMagnet;
+import com.glodblock.github.inventory.item.WirelessMagnetCardFilterInventory;
+import com.glodblock.github.inventory.item.WirelessMagnetCardFilterInventory.FilterCache;
 import com.glodblock.github.loader.ItemAndBlockHolder;
 import com.glodblock.github.network.SPacketMEUpdateBuffer;
 import com.glodblock.github.network.wrapper.FCNetworkWrapper;
 import com.glodblock.github.util.ModAndClassUtil;
+import com.glodblock.github.util.Util;
 
 import appeng.api.AEApi;
 import appeng.api.IAppEngApi;
 import appeng.api.config.Upgrades;
+import appeng.api.networking.IGridNode;
+import appeng.util.Platform;
 import cpw.mods.fml.common.FMLCommonHandler;
 import cpw.mods.fml.common.event.FMLInitializationEvent;
 import cpw.mods.fml.common.event.FMLLoadCompleteEvent;
 import cpw.mods.fml.common.event.FMLPostInitializationEvent;
 import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 
 public class CommonProxy {
 
     public final FCNetworkWrapper netHandler = new FCNetworkWrapper(FluidCraft.MODID);
 
+    public CommonProxy() {
+        MinecraftForge.EVENT_BUS.register(this);
+        FMLCommonHandler.instance().bus().register(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    @SubscribeEvent
+    public void pickupEvent(EntityItemPickupEvent e) {
+        if (Platform.isServer() && e.entityPlayer != null) {
+            try {
+                EntityPlayer player = e.entityPlayer;
+                EntityItem itemEntity = e.item;
+                ItemStack stack = itemEntity.getEntityItem();
+                World world = player.getEntityWorld();
+
+                ImmutablePair<Integer, ItemStack> result = Util.getUltraWirelessTerm(player);
+                if (result != null) {
+                    final ItemStack wirelessTerm = result.getRight();
+                    WirelessMagnet.Mode mode = WirelessMagnet.getMode(wirelessTerm);
+                    if (mode == WirelessMagnet.Mode.ME) {
+                        IGridNode gridNode = Util.getWirelessGrid(wirelessTerm);
+                        if (gridNode != null && Util.rangeCheck(wirelessTerm, player, gridNode)) {
+                            WirelessMagnetCardFilterInventory inv = FilterCache
+                                    .getFilter(wirelessTerm, result.getLeft(), gridNode, player);
+
+                            if (inv.isPassFilter(stack)) {
+                                if (inv.doInject(
+                                        AEApi.instance().storage().createItemStack(stack),
+                                        itemEntity,
+                                        world)) {
+                                    itemEntity.setDead();
+                                    e.setCanceled(true);
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch (NullPointerException ex) {
+                ex.printStackTrace();
+            }
+        }
+    }
+
     public void preInit(FMLPreInitializationEvent event) {
         ModAndClassUtil.init();
         ItemAndBlockHolder.init();

src/main/java/com/glodblock/github/util/NameConst.java

@@ -57,7 +57,9 @@ public class NameConst {
     public static final String ITEM_ENERGY_CARD = "energy_card";
 
     public static final String TT_KEY = FluidCraft.MODID + ".tooltip.";
+    public static final String TT_CRAFTING_COMPLETE = TT_KEY + "crafting_complete";
     public static final String TT_FLUID_TERMINAL = TT_KEY + "fluid_terminal";
+    public static final String TT_FLUID_TERMINAL_AMOUNT = TT_FLUID_TERMINAL + ".amount";
     public static final String TT_LEVEL_TERMINAL = TT_KEY + "level_terminal";
     public static final String TT_INVALID_FLUID = TT_KEY + "invalid_fluid";
     public static final String TT_FLUID_PACKET = TT_KEY + "fluid_packet";
@@ -106,6 +108,12 @@ public class NameConst {
     public static final String TT_QUANTUM_BRIDGE_CARD_DESC = TT_QUANTUM_BRIDGE_CARD + ".desc";
     public static final String TT_ITEM_FLUID_VOID_CELL = TT_KEY + ITEM_FLUID_VOID_CELL;
 
+    public static final String TT_ULTRA_TERMINAL_RESTOCK = TT_ULTRA_TERMINAL + ".restock";
+    public static final String TT_ULTRA_TERMINAL_RESTOCK_ON = TT_ULTRA_TERMINAL_RESTOCK + ".on";
+    public static final String TT_ULTRA_TERMINAL_RESTOCK_OFF = TT_ULTRA_TERMINAL_RESTOCK + ".off";
+
+    public static final String TT_MAGNET_CARD_OREDICT = TT_KEY + "magnet_card.oreDictFilter";
+
     public static final String WAILA_KEY = FluidCraft.MODID + ".waila.";
     public static final String WAILA_ENABLE = WAILA_KEY + "enable";
     public static final String WAILA_DISABLE = WAILA_KEY + "disable";
@@ -130,6 +138,13 @@ public class NameConst {
     public static final String GUI_FLUID_EXPORT = GUI_KEY + ITEM_PART_FLUID_EXPORT;
     public static final String GUI_FLUID_STORAGE_BUS = GUI_KEY + ITEM_PART_FLUID_STORAGE_BUS;
 
+    public static final String GUI_MAGNET_CARD = GUI_KEY + "magnet";
+    public static final String GUI_MAGNET_CARD_NBT = GUI_MAGNET_CARD + ".nbt";
+    public static final String GUI_MAGNET_CARD_META = GUI_MAGNET_CARD + ".meta";
+    public static final String GUI_MAGNET_CARD_ORE = GUI_MAGNET_CARD + ".ore";
+    public static final String GUI_MAGNET_CARD_WhiteList = GUI_MAGNET_CARD + ".whitelist";
+    public static final String GUI_MAGNET_CARD_BlackList = GUI_MAGNET_CARD + ".blacklist";
+
     public static String i18n(String t, String delimiter, boolean hint) {
         if (!hint) {
             return I18n.format(t);

src/main/java/com/glodblock/github/util/Util.java

@@ -2,7 +2,9 @@ package com.glodblock.github.util;
 
 import static com.glodblock.github.common.item.ItemBaseWirelessTerminal.infinityBoosterCard;
 import static com.glodblock.github.common.item.ItemBaseWirelessTerminal.infinityEnergyCard;
+import static com.glodblock.github.common.item.ItemBaseWirelessTerminal.restockItems;
 import static com.glodblock.github.util.Util.DimensionalCoordSide.hasEnergyCard;
+import static net.minecraft.init.Items.glass_bottle;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -14,6 +16,7 @@ import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.init.Items;
 import net.minecraft.inventory.IInventory;
 import net.minecraft.item.Item;
+import net.minecraft.item.ItemPotion;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraftforge.common.util.ForgeDirection;
@@ -108,6 +111,40 @@ public final class Util {
         return ticks;
     }
 
+    public static boolean rangeCheck(ItemStack is, EntityPlayer player, IGridNode grid) {
+        if (grid.getGrid() == null) return false;
+        return rangeCheck(is, player, grid.getGrid());
+    }
+
+    public static boolean rangeCheck(ItemStack is, EntityPlayer player, IGrid grid) {
+        boolean canConnect = false;
+        if (hasInfinityBoosterCard(is)) {
+            canConnect = true;
+        } else {
+            for (IGridNode node : grid.getMachines(TileWireless.class)) {
+                IWirelessAccessPoint accessPoint = (IWirelessAccessPoint) node.getMachine();
+                if (accessPoint.isActive() && accessPoint.getLocation().getDimension() == player.dimension) {
+                    WorldCoord distance = accessPoint.getLocation()
+                            .subtract((int) player.posX, (int) player.posY, (int) player.posZ);
+                    int squaredDistance = distance.x * distance.x + distance.y * distance.y + distance.z * distance.z;
+                    if (squaredDistance <= accessPoint.getRange() * accessPoint.getRange()) {
+                        canConnect = true;
+                        break;
+                    }
+                }
+            }
+        }
+        return canConnect;
+    }
+
+    public static boolean isRestock(ItemStack is) {
+        if (is.getItem() instanceof ItemBaseWirelessTerminal) {
+            NBTTagCompound data = Platform.openNbtData(is);
+            return data.hasKey(restockItems) && data.getBoolean(restockItems);
+        }
+        return false;
+    }
+
     public static boolean hasInfinityBoosterCard(ItemStack is) {
         if (is.getItem() instanceof ItemBaseWirelessTerminal) {
             NBTTagCompound data = Platform.openNbtData(is);
@@ -128,39 +165,26 @@ public final class Util {
     }
 
     public static IMEInventoryHandler<?> getWirelessInv(ItemStack is, EntityPlayer player, StorageChannel channel) {
-        if (Platform.isClient()) return new NullInventory<>();
-        IGridNode gridNode = getWirelessGrid(is);
-        if (gridNode == null) return null;
-        IGrid grid = gridNode.getGrid();
-        if (grid == null) return null;
-        boolean canConnect = false;
-        if (hasInfinityBoosterCard(is)) {
-            canConnect = true;
-        } else {
-            for (IGridNode node : grid.getMachines(TileWireless.class)) {
-                IWirelessAccessPoint accessPoint = (IWirelessAccessPoint) node.getMachine();
-                if (accessPoint.isActive() && accessPoint.getLocation().getDimension() == player.dimension) {
-                    WorldCoord distance = accessPoint.getLocation()
-                            .subtract((int) player.posX, (int) player.posY, (int) player.posZ);
-                    int squaredDistance = distance.x * distance.x + distance.y * distance.y + distance.z * distance.z;
-                    if (squaredDistance <= accessPoint.getRange() * accessPoint.getRange()) {
-                        canConnect = true;
-                        break;
+        if (Platform.isServer()) {
+            IGridNode gridNode = getWirelessGrid(is);
+            if (gridNode != null) {
+                IGrid grid = gridNode.getGrid();
+                if (grid != null) {
+                    if (rangeCheck(is, player, grid)) {
+                        IStorageGrid gridCache = grid.getCache(IStorageGrid.class);
+                        if (gridCache != null) {
+                            if (channel == StorageChannel.FLUIDS) {
+                                return gridCache.getFluidInventory();
+                            } else {
+                                return gridCache.getItemInventory();
+                            }
+                        }
                     }
                 }
             }
+            return null;
         }
-        if (canConnect) {
-            IStorageGrid gridCache = grid.getCache(IStorageGrid.class);
-            if (gridCache != null) {
-                if (channel == StorageChannel.FLUIDS) {
-                    return gridCache.getFluidInventory();
-                } else {
-                    return gridCache.getItemInventory();
-                }
-            }
-        }
-        return null;
+        return new NullInventory<>();
     }
 
     public static ItemStack getWirelessTerminal(EntityPlayer player, int x) {
@@ -440,6 +464,18 @@ public final class Util {
 
     public static class FluidUtil {
 
+        private static final ItemStack glassBottle = new ItemStack(glass_bottle, 1);
+
+        public static ItemStack getPotion(FluidStack fs) {
+            if (fs == null) return null;
+            MutablePair<Integer, ItemStack> fillStack = Util.FluidUtil.fillStack(glassBottle, fs);
+            if (fillStack != null && fillStack.getRight() != null
+                    && fillStack.getRight().getItem() instanceof ItemPotion) {
+                return fillStack.right;
+            }
+            return null;
+        }
+
         public static final ItemStack water_bucket = new ItemStack(Items.water_bucket, 1);
 
         public static void fluidTankInfoWriteToNBT(FluidTankInfo[] infos, NBTTagCompound data) {