From ac5832fd1a9fd87e00914c4546f9be01e651278b Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Mon, 11 Sep 2023 09:27:34 -0700
Subject: [PATCH 01/22] api/features: Move iface term functionality to API

Does two things:
* Deprecate old interface terminal support classes.
* Refactors the interface terminal API into AEApi.
* Changes the API to use only relevant operations. Relevant here means
  things we will actually use when the packet format is updated in the
  next few commits.

This is a breaking change, but it won't be hard to fix.
---
 .../api/features/IIfaceTermRegistry.java      | 14 +++++
 .../api/features/IRegistryContainer.java      |  2 +
 .../appeng/api/util/IIfaceTermViewable.java   | 51 +++++++++++++++++++
 .../registries/IfaceTermRegistry.java         | 45 ++++++++++++++++
 .../registries/RegistryContainer.java         |  7 +++
 .../helpers/IInterfaceTerminalSupport.java    | 10 ++++
 ...terfaceTerminalSupportedClassProvider.java | 27 ++++------
 7 files changed, 139 insertions(+), 17 deletions(-)
 create mode 100644 src/main/java/appeng/api/features/IIfaceTermRegistry.java
 create mode 100644 src/main/java/appeng/api/util/IIfaceTermViewable.java
 create mode 100644 src/main/java/appeng/core/features/registries/IfaceTermRegistry.java

diff --git a/src/main/java/appeng/api/features/IIfaceTermRegistry.java b/src/main/java/appeng/api/features/IIfaceTermRegistry.java
new file mode 100644
index 00000000000..7f9baf4c64c
--- /dev/null
+++ b/src/main/java/appeng/api/features/IIfaceTermRegistry.java
@@ -0,0 +1,14 @@
+package appeng.api.features;
+
+import appeng.api.util.IIfaceTermViewable;
+
+/**
+ * Registry for interface terminal support.
+ */
+public interface IIfaceTermRegistry {
+
+    /**
+     * Registers a class to be considered supported in interface terminals.
+     */
+    void register(Class<? extends IIfaceTermViewable> clazz);
+}
diff --git a/src/main/java/appeng/api/features/IRegistryContainer.java b/src/main/java/appeng/api/features/IRegistryContainer.java
index d1b922ee9e6..8dc002fd598 100644
--- a/src/main/java/appeng/api/features/IRegistryContainer.java
+++ b/src/main/java/appeng/api/features/IRegistryContainer.java
@@ -73,6 +73,8 @@ public interface IRegistryContainer {
      */
     IInscriberRegistry inscriber();
 
+    IIfaceTermRegistry ifaceTerm();
+
     /**
      * get access to the locatable registry
      */
diff --git a/src/main/java/appeng/api/util/IIfaceTermViewable.java b/src/main/java/appeng/api/util/IIfaceTermViewable.java
new file mode 100644
index 00000000000..0ae440cf72f
--- /dev/null
+++ b/src/main/java/appeng/api/util/IIfaceTermViewable.java
@@ -0,0 +1,51 @@
+package appeng.api.util;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+
+import appeng.api.networking.IGridHost;
+
+/**
+ * Replacement for {@code IInterfaceTerminalSupport} in API.
+ */
+public interface IIfaceTermViewable extends IGridHost {
+
+    DimensionalCoord getLocation();
+
+    /**
+     * Number of rows to expect. This is used with {@link #rowSize()} to determine how to render the slots.
+     */
+    int rows();
+
+    /**
+     * Number of slots per row.
+     */
+    int rowSize();
+
+    /**
+     * Get the patterns. If multiple rows are supported, this is assumed to be tightly packed. Use {@link #rowSize()}
+     * with {@link #rows()} to determine where a row starts.
+     */
+    IInventory getPatterns();
+
+    String getName();
+
+    TileEntity getTileEntity();
+
+    boolean shouldDisplay();
+
+    /**
+     * Self representation
+     */
+    default ItemStack getSelfRep() {
+        return null;
+    }
+
+    /**
+     * "Target" Display representation
+     */
+    default ItemStack getDisplayRep() {
+        return null;
+    }
+}
diff --git a/src/main/java/appeng/core/features/registries/IfaceTermRegistry.java b/src/main/java/appeng/core/features/registries/IfaceTermRegistry.java
new file mode 100644
index 00000000000..846fdb8127f
--- /dev/null
+++ b/src/main/java/appeng/core/features/registries/IfaceTermRegistry.java
@@ -0,0 +1,45 @@
+package appeng.core.features.registries;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import appeng.api.features.IIfaceTermRegistry;
+import appeng.api.util.IIfaceTermViewable;
+import appeng.parts.misc.PartInterface;
+import appeng.parts.p2p.PartP2PInterface;
+import appeng.tile.misc.TileInterface;
+
+/**
+ * Interface Terminal Registry impl for registering viewable instances.
+ */
+public class IfaceTermRegistry implements IIfaceTermRegistry {
+
+    private final Set<Class<? extends IIfaceTermViewable>> supportedClasses = new HashSet<>();
+    private static IfaceTermRegistry INSTANCE;
+
+    /**
+     * Singleton, do not instantiate more than once.
+     */
+    public IfaceTermRegistry() {
+        supportedClasses.add(TileInterface.class);
+        supportedClasses.add(PartInterface.class);
+        supportedClasses.add(PartP2PInterface.class);
+        INSTANCE = this;
+    }
+
+    /**
+     * Get all supported classes that were registered during startup
+     */
+    public Set<Class<? extends IIfaceTermViewable>> getSupportedClasses() {
+        return supportedClasses;
+    }
+
+    @Override
+    public void register(Class<? extends IIfaceTermViewable> clazz) {
+        supportedClasses.add(clazz);
+    }
+
+    public static IfaceTermRegistry instance() {
+        return INSTANCE;
+    }
+}
diff --git a/src/main/java/appeng/core/features/registries/RegistryContainer.java b/src/main/java/appeng/core/features/registries/RegistryContainer.java
index 7c1d4086b50..506bb73c0ec 100644
--- a/src/main/java/appeng/core/features/registries/RegistryContainer.java
+++ b/src/main/java/appeng/core/features/registries/RegistryContainer.java
@@ -11,6 +11,7 @@
 package appeng.core.features.registries;
 
 import appeng.api.features.IGrinderRegistry;
+import appeng.api.features.IIfaceTermRegistry;
 import appeng.api.features.IInscriberRegistry;
 import appeng.api.features.ILocatableRegistry;
 import appeng.api.features.IMatterCannonAmmoRegistry;
@@ -42,6 +43,7 @@ public class RegistryContainer implements IRegistryContainer {
     private final IExternalStorageRegistry storage = new ExternalStorageRegistry();
     private final ICellRegistry cell = new CellRegistry();
     private final IItemDisplayRegistry itemDisplay = new ItemDisplayRegistry();
+    private final IIfaceTermRegistry ifaceTerm = new IfaceTermRegistry();
     private final ILocatableRegistry locatable = new LocatableRegistry();
     private final ISpecialComparisonRegistry comparison = new SpecialComparisonRegistry();
     private final IWirelessTermRegistry wireless = new WirelessRegistry();
@@ -97,6 +99,11 @@ public IInscriberRegistry inscriber() {
         return this.inscriber;
     }
 
+    @Override
+    public IIfaceTermRegistry ifaceTerm() {
+        return this.ifaceTerm;
+    }
+
     @Override
     public ILocatableRegistry locatable() {
         return this.locatable;
diff --git a/src/main/java/appeng/helpers/IInterfaceTerminalSupport.java b/src/main/java/appeng/helpers/IInterfaceTerminalSupport.java
index ffc4fcd7b0b..9b4c7a9b5df 100644
--- a/src/main/java/appeng/helpers/IInterfaceTerminalSupport.java
+++ b/src/main/java/appeng/helpers/IInterfaceTerminalSupport.java
@@ -6,10 +6,18 @@
 import appeng.api.networking.IGridHost;
 import appeng.api.util.DimensionalCoord;
 
+/**
+ * Refactoring this class into API, and renaming.
+ *
+ * @see appeng.api.util.IIfaceTermViewable
+ */
+@Deprecated
 public interface IInterfaceTerminalSupport extends IGridHost {
 
     class PatternsConfiguration {
 
+        /** This property should be used in the terminal level and items tightly packed. */
+        @Deprecated
         public int offset;
         public int size;
 
@@ -23,12 +31,14 @@ public PatternsConfiguration(int offset, int size) {
 
     PatternsConfiguration[] getPatternsConfigurations();
 
+    @Deprecated
     IInventory getPatterns(int index);
 
     String getName();
 
     TileEntity getTileEntity();
 
+    @Deprecated
     default long getSortValue() {
         var te = getTileEntity();
         return ((long) te.zCoord << 24) ^ ((long) te.xCoord << 8) ^ te.yCoord;
diff --git a/src/main/java/appeng/helpers/InterfaceTerminalSupportedClassProvider.java b/src/main/java/appeng/helpers/InterfaceTerminalSupportedClassProvider.java
index 01746b750ce..6f6e95f5565 100644
--- a/src/main/java/appeng/helpers/InterfaceTerminalSupportedClassProvider.java
+++ b/src/main/java/appeng/helpers/InterfaceTerminalSupportedClassProvider.java
@@ -1,27 +1,20 @@
 package appeng.helpers;
 
-import java.util.HashSet;
 import java.util.Set;
 
-import appeng.parts.misc.PartInterface;
-import appeng.parts.p2p.PartP2PInterface;
-import appeng.tile.misc.TileInterface;
-
+/**
+ * Interface Terminal Support handler.
+ *
+ * @deprecated This is being refactored to the API.
+ */
+@Deprecated
 public class InterfaceTerminalSupportedClassProvider {
 
-    private static final Set<Class<? extends IInterfaceTerminalSupport>> supportedClasses = new HashSet<>();
-
-    static {
-        supportedClasses.add(TileInterface.class);
-        supportedClasses.add(PartInterface.class);
-        supportedClasses.add(PartP2PInterface.class);
-    }
-
+    @Deprecated
     public static Set<Class<? extends IInterfaceTerminalSupport>> getSupportedClasses() {
-        return supportedClasses;
+        return null;
     }
 
-    public static void register(Class<? extends IInterfaceTerminalSupport> clazz) {
-        supportedClasses.add(clazz);
-    }
+    @Deprecated
+    public static void register(Class<? extends IInterfaceTerminalSupport> clazz) {}
 }

From ec392c1f49ee6ae65ad64b56d68873678b4cb01c Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Mon, 11 Sep 2023 09:28:41 -0700
Subject: [PATCH 02/22] me/cache: Add indication of booting/nonbooting to event

The booting/nonbooting event is posted whenever the ME system starts its
"boot" phase and when the "boot" phase is finished. This commit
distinguishes the two phases.

Some subscribers might need this information to determine whether to push
an update or not.

An example is written in this commit - part interface terminal is only
curious about when the terminal boots back up, not when the network enters
the booting state.
---
 .../events/MENetworkBootingStatusChange.java  |  9 +++++++++
 .../java/appeng/me/cache/PathGridCache.java   |  4 ++--
 .../reporting/PartInterfaceTerminal.java      | 20 +++++++++++++++++++
 3 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/src/main/java/appeng/api/networking/events/MENetworkBootingStatusChange.java b/src/main/java/appeng/api/networking/events/MENetworkBootingStatusChange.java
index da45dbe896e..025ad1ce285 100644
--- a/src/main/java/appeng/api/networking/events/MENetworkBootingStatusChange.java
+++ b/src/main/java/appeng/api/networking/events/MENetworkBootingStatusChange.java
@@ -22,4 +22,13 @@
  * Note: Most machines just need to check {@link IGridNode}.isActive()
  */
 public class MENetworkBootingStatusChange extends MENetworkEvent {
+
+    /**
+     * Indicates whether the network has changed to this state when the event is posted.
+     */
+    public final boolean isBooting;
+
+    public MENetworkBootingStatusChange(boolean isBooting) {
+        this.isBooting = isBooting;
+    }
 }
diff --git a/src/main/java/appeng/me/cache/PathGridCache.java b/src/main/java/appeng/me/cache/PathGridCache.java
index a51f347be60..73d7f277909 100644
--- a/src/main/java/appeng/me/cache/PathGridCache.java
+++ b/src/main/java/appeng/me/cache/PathGridCache.java
@@ -85,7 +85,7 @@ public void onUpdateTick() {
 
         if (this.updateNetwork) {
             if (!this.booting) {
-                this.myGrid.postEvent(new MENetworkBootingStatusChange());
+                this.myGrid.postEvent(new MENetworkBootingStatusChange(true));
             }
 
             this.booting = true;
@@ -186,7 +186,7 @@ public void onUpdateTick() {
 
                 this.booting = false;
                 this.setChannelPowerUsage(this.getChannelsByBlocks() / 128.0);
-                this.myGrid.postEvent(new MENetworkBootingStatusChange());
+                this.myGrid.postEvent(new MENetworkBootingStatusChange(false));
             }
         }
     }
diff --git a/src/main/java/appeng/parts/reporting/PartInterfaceTerminal.java b/src/main/java/appeng/parts/reporting/PartInterfaceTerminal.java
index f914fa4309f..d3f1744f6ee 100644
--- a/src/main/java/appeng/parts/reporting/PartInterfaceTerminal.java
+++ b/src/main/java/appeng/parts/reporting/PartInterfaceTerminal.java
@@ -14,6 +14,8 @@
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Vec3;
 
+import appeng.api.networking.events.MENetworkBootingStatusChange;
+import appeng.api.networking.events.MENetworkEventSubscribe;
 import appeng.client.texture.CableBusTextures;
 import appeng.core.sync.GuiBridge;
 import appeng.util.Platform;
@@ -23,6 +25,7 @@ public class PartInterfaceTerminal extends AbstractPartDisplay {
     private static final CableBusTextures FRONT_BRIGHT_ICON = CableBusTextures.PartInterfaceTerm_Bright;
     private static final CableBusTextures FRONT_DARK_ICON = CableBusTextures.PartInterfaceTerm_Dark;
     private static final CableBusTextures FRONT_COLORED_ICON = CableBusTextures.PartInterfaceTerm_Colored;
+    private boolean needsUpdate;
 
     public PartInterfaceTerminal(final ItemStack is) {
         super(is);
@@ -59,4 +62,21 @@ public CableBusTextures getFrontColored() {
     public CableBusTextures getFrontDark() {
         return FRONT_DARK_ICON;
     }
+
+    /**
+     * Indicates that the network has changed. Calling this will reset the flag.
+     */
+    public boolean needsUpdate() {
+        boolean ret = needsUpdate;
+
+        needsUpdate = false;
+        return ret;
+    }
+
+    @MENetworkEventSubscribe
+    public void onNetworkBootingChanged(MENetworkBootingStatusChange event) {
+        if (!event.isBooting) {
+            this.needsUpdate = true;
+        }
+    }
 }

From 203c64c8745c98870bb62d42dab6c78d2ffee906 Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Mon, 11 Sep 2023 20:27:28 -0700
Subject: [PATCH 03/22] appeng/core/sync/packets: Add
 PacketIfaceTermUpdate.java

Adds a new packet specifically for updating the entries on the terminal.
Reduces network traffic, potentially significantly, as it allows for
incremental updates instead of sending a fresh list every time the entries
on the list change (Note it WAS smart enough to not send a fresh list if
only patterns changed).

Deprecates appeng/core/sync/packets/PacketCompressedNBT

Commit does not add functionality to handling on the client side yet.
---
 .../implementations/GuiInterfaceTerminal.java |   5 +
 .../core/sync/AppEngPacketHandlerBase.java    |   4 +-
 .../sync/packets/PacketCompressedNBT.java     |   7 +-
 .../sync/packets/PacketIfaceTermUpdate.java   | 456 ++++++++++++++++++
 4 files changed, 467 insertions(+), 5 deletions(-)
 create mode 100644 src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java

diff --git a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
index 1ee28f24126..ebb7587d7bf 100644
--- a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
+++ b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
@@ -18,6 +18,7 @@
 import java.util.Set;
 import java.util.WeakHashMap;
 
+import appeng.core.sync.packets.PacketIfaceTermUpdate;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
@@ -425,6 +426,10 @@ private boolean handleTab() {
         return false;
     }
 
+    public void postUpdate(List<PacketIfaceTermUpdate.PacketEntry> updates) {
+
+    }
+
     public void postUpdate(final NBTTagCompound in) {
         if (in.getBoolean("clear")) {
             this.byId.clear();
diff --git a/src/main/java/appeng/core/sync/AppEngPacketHandlerBase.java b/src/main/java/appeng/core/sync/AppEngPacketHandlerBase.java
index 4102a1f6eb1..e3d5c17922c 100644
--- a/src/main/java/appeng/core/sync/AppEngPacketHandlerBase.java
+++ b/src/main/java/appeng/core/sync/AppEngPacketHandlerBase.java
@@ -26,6 +26,7 @@
 import appeng.core.sync.packets.PacketCraftingItemInterface;
 import appeng.core.sync.packets.PacketCraftingRemainingOperations;
 import appeng.core.sync.packets.PacketCraftingTreeData;
+import appeng.core.sync.packets.PacketIfaceTermUpdate;
 import appeng.core.sync.packets.PacketInventoryAction;
 import appeng.core.sync.packets.PacketLightning;
 import appeng.core.sync.packets.PacketMEInventoryUpdate;
@@ -110,7 +111,8 @@ public enum PacketTypes {
         PACKET_CRAFTING_REMAINING_OPERATIONS(PacketCraftingRemainingOperations.class),
         PACKET_CRAFTING_ITEM_INTERFACE(PacketCraftingItemInterface.class),
         PACKET_CRAFTING_TREE_DATA(PacketCraftingTreeData.class),
-        PACKET_NEI_BOOKMARK(PacketNEIBookmark.class);
+        PACKET_NEI_BOOKMARK(PacketNEIBookmark.class),
+        PACKET_IFACE_TERMINAL_UPDATE(PacketIfaceTermUpdate.class),;
 
         private final Class<? extends AppEngPacket> packetClass;
         private final Constructor<? extends AppEngPacket> packetConstructor;
diff --git a/src/main/java/appeng/core/sync/packets/PacketCompressedNBT.java b/src/main/java/appeng/core/sync/packets/PacketCompressedNBT.java
index 1f34d5f4a8a..7a59fddfd6f 100644
--- a/src/main/java/appeng/core/sync/packets/PacketCompressedNBT.java
+++ b/src/main/java/appeng/core/sync/packets/PacketCompressedNBT.java
@@ -24,7 +24,6 @@
 import net.minecraft.nbt.CompressedStreamTools;
 import net.minecraft.nbt.NBTTagCompound;
 
-import appeng.client.gui.implementations.GuiInterfaceTerminal;
 import appeng.core.sync.AppEngPacket;
 import appeng.core.sync.network.INetworkInfo;
 import cpw.mods.fml.relauncher.Side;
@@ -89,8 +88,8 @@ public void write(final int value) throws IOException {
     public void clientPacketData(final INetworkInfo network, final AppEngPacket packet, final EntityPlayer player) {
         final GuiScreen gs = Minecraft.getMinecraft().currentScreen;
 
-        if (gs instanceof GuiInterfaceTerminal) {
-            ((GuiInterfaceTerminal) gs).postUpdate(this.in);
-        }
+        // if (gs instanceof GuiInterfaceTerminal) {
+        // ((GuiInterfaceTerminal) gs).postUpdate(this.in);
+        // }
     }
 }
diff --git a/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java b/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java
new file mode 100644
index 00000000000..e7c5e6b585c
--- /dev/null
+++ b/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java
@@ -0,0 +1,456 @@
+package appeng.core.sync.packets;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompressedStreamTools;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraftforge.common.util.Constants.NBT;
+
+import appeng.client.gui.implementations.GuiInterfaceTerminal;
+import appeng.core.AELog;
+import appeng.core.sync.AppEngPacket;
+import appeng.core.sync.network.INetworkInfo;
+import appeng.helpers.Reflected;
+import cpw.mods.fml.common.network.ByteBufUtils;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.buffer.ByteBufOutputStream;
+import io.netty.buffer.Unpooled;
+
+/**
+ * Packet used for interface terminal updates. Packet allows the server to send an array of command packets, which are
+ * then processed in order. This allows for chaining commands to produce the desired update.
+ */
+public class PacketIfaceTermUpdate extends AppEngPacket {
+
+    public static final int CLEAR_ALL_BIT = 1;
+    public static final int DISCONNECT_BIT = 2;
+
+    private final List<PacketEntry> commands = new ArrayList<>();
+    private int statusFlags;
+
+    @Reflected
+    public PacketIfaceTermUpdate(final ByteBuf buf) throws IOException {
+        decode(buf);
+    }
+
+    public PacketIfaceTermUpdate() {}
+
+    private void decode(ByteBuf buf) {
+        this.statusFlags = buf.readByte();
+        int numEntries = buf.readInt();
+
+        for (int i = 0; i < numEntries; ++i) {
+            int packetType = -1;
+            try {
+                packetType = buf.readByte();
+                PacketType type = PacketType.valueOf(packetType);
+                switch (type) {
+                    case ADD -> this.commands.add(new PacketAdd(buf));
+                    case REMOVE -> this.commands.add(new PacketRemove(buf));
+                    case OVERWRITE -> this.commands.add(new PacketOverwrite(buf));
+                    case RENAME -> this.commands.add(new PacketRename(buf));
+                }
+            } catch (ArrayIndexOutOfBoundsException e) {
+                AELog.error("Unknown packet type of type %d (-1 = uninitialized)", packetType);
+                break;
+            } catch (IOException e) {
+                AELog.error(e);
+                break;
+            }
+        }
+    }
+
+    public void encode() {
+        try {
+            ByteBuf buf = Unpooled.buffer(2048);
+            buf.writeInt(this.getPacketID());
+            buf.writeByte(this.statusFlags);
+            buf.writeInt(commands.size());
+            for (PacketEntry entry : commands) {
+                entry.write(buf);
+            }
+            super.configureWrite(buf);
+        } catch (IOException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    /**
+     * Remove all entries on the terminal. This is done BEFORE any entries are processed, so you can set this to clear
+     * old entries, and add new ones after in one packet.
+     */
+    public void setClear() {
+        this.statusFlags |= CLEAR_ALL_BIT;
+    }
+
+    /**
+     * The terminal disconnected. Entries are still processed, but indicates for the GUI to darken/turn off the
+     * terminal. No further updates will arrive until the terminal reconnects.
+     */
+    public void setDisconnect() {
+        this.statusFlags |= DISCONNECT_BIT;
+    }
+
+    /**
+     * Adds a new entry. Fill out the rest of the command using the {@link PacketAdd#setItems(int, int, NBTTagList)} and
+     * {@link PacketAdd#setLoc(int, int, int, int)}.
+     *
+     * @return the packet, which needs to have information filled out.
+     */
+    public PacketAdd addNewEntry(long id, String name, boolean online) {
+        PacketAdd packet = new PacketAdd(id, name, online);
+
+        commands.add(packet);
+        return packet;
+    }
+
+    /**
+     * Remove the entry with the id from the terminal.
+     */
+    public void addRemovalEntry(long id) {
+        commands.add(new PacketRemove(id));
+    }
+
+    /**
+     * Rename the entry
+     */
+    public void addRenamedEntry(long id, String newName) {
+        commands.add(new PacketRename(id, newName));
+    }
+
+    /**
+     * Overwrite the entry with new items or new status
+     */
+    public PacketOverwrite addOverwriteEntry(long id) {
+        PacketOverwrite packet = new PacketOverwrite(id);
+
+        commands.add(packet);
+        return packet;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void clientPacketData(final INetworkInfo network, final AppEngPacket packet, final EntityPlayer player) {
+        final GuiScreen gs = Minecraft.getMinecraft().currentScreen;
+
+        if (gs instanceof GuiInterfaceTerminal) {
+            ((GuiInterfaceTerminal) gs).postUpdate(this.commands, this.statusFlags);
+        }
+    }
+
+    enum PacketType {
+
+        ADD,
+        REMOVE,
+        OVERWRITE,
+        RENAME;
+
+        public static final PacketType[] TYPES = PacketType.values();
+
+        /**
+         * Get the indexed value of packet type, throws on invalid index
+         */
+        public static PacketType valueOf(int idx) throws ArrayIndexOutOfBoundsException {
+            return TYPES[idx];
+        }
+    }
+
+    /**
+     * A packet for updating an entry.
+     */
+    public abstract static class PacketEntry {
+
+        public final long entryId;
+
+        protected PacketEntry(long entryId) {
+            this.entryId = entryId;
+        }
+
+        protected PacketEntry(ByteBuf buf) throws IOException {
+            this.entryId = buf.readLong();
+            read(buf);
+        }
+
+        /**
+         * Needs to write the packet id.
+         */
+        protected abstract void write(ByteBuf buf) throws IOException;
+
+        /**
+         * Reading the entry id is not needed.
+         */
+        protected abstract void read(ByteBuf buf) throws IOException;
+    }
+
+    /**
+     * A command for sending a new entry.
+     */
+    public static class PacketAdd extends PacketEntry {
+
+        public String name;
+        public int x, y, z, dim;
+        public int rows, rowSize;
+        public boolean online;
+        public ItemStack selfRep, dispRep;
+        public NBTTagList items;
+
+        PacketAdd(long id, String name, boolean online) {
+            super(id);
+            this.name = name;
+            this.online = online;
+        }
+
+        PacketAdd(ByteBuf buf) throws IOException {
+            super(buf);
+        }
+
+        public PacketAdd setLoc(int x, int y, int z, int dim) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            this.dim = dim;
+            return this;
+        }
+
+        public PacketAdd setItems(int rows, int rowSize, NBTTagList items) {
+            this.rows = rows;
+            this.rowSize = rowSize;
+            this.items = items;
+
+            return this;
+        }
+
+        /**
+         * Set representatives for the interface
+         *
+         * @param selfRep the stack representing me
+         * @param dispRep the stack representing my target
+         */
+        public PacketAdd setReps(ItemStack selfRep, ItemStack dispRep) {
+            this.selfRep = selfRep;
+            this.dispRep = dispRep;
+
+            return this;
+        }
+
+        @Override
+        protected void write(ByteBuf buf) throws IOException {
+            buf.writeByte(PacketType.ADD.ordinal());
+            buf.writeLong(entryId);
+            ByteBufUtils.writeUTF8String(buf, this.name);
+            buf.writeInt(x);
+            buf.writeInt(y);
+            buf.writeInt(z);
+            buf.writeInt(dim);
+            buf.writeInt(rows);
+            buf.writeInt(rowSize);
+
+            ByteBuf tempBuf = Unpooled.buffer(256);
+            try (ByteBufOutputStream stream = new ByteBufOutputStream(tempBuf)) {
+
+                NBTTagCompound wrapper = new NBTTagCompound();
+
+                if (selfRep != null) {
+                    wrapper.setTag("self", selfRep.writeToNBT(new NBTTagCompound()));
+                }
+                if (dispRep != null) {
+                    wrapper.setTag("disp", dispRep.writeToNBT(new NBTTagCompound()));
+                }
+                wrapper.setTag("data", items);
+                CompressedStreamTools.writeCompressed(wrapper, stream);
+            }
+            try {
+                buf.writeInt(tempBuf.readableBytes());
+                buf.writeBytes(tempBuf);
+            } finally {
+                tempBuf.release();
+            }
+        }
+
+        @Override
+        protected void read(ByteBuf buf) throws IOException {
+            this.name = ByteBufUtils.readUTF8String(buf);
+            this.x = buf.readInt();
+            this.y = buf.readInt();
+            this.z = buf.readInt();
+            this.dim = buf.readInt();
+            this.rows = buf.readInt();
+            this.rowSize = buf.readInt();
+            int payloadSize = buf.readInt();
+            try (ByteBufInputStream stream = new ByteBufInputStream(buf, payloadSize)) {
+                NBTTagCompound payload = CompressedStreamTools.readCompressed(stream);
+                if (payload.hasKey("self", NBT.TAG_COMPOUND)) {
+                    this.selfRep = ItemStack.loadItemStackFromNBT(payload.getCompoundTag("self"));
+                }
+
+                if (payload.hasKey("disp", NBT.TAG_COMPOUND)) {
+                    this.dispRep = ItemStack.loadItemStackFromNBT(payload.getCompoundTag("disp"));
+                }
+
+                this.items = payload.getTagList("data", NBT.TAG_COMPOUND);
+            }
+        }
+    }
+
+    public static class PacketRemove extends PacketEntry {
+
+        PacketRemove(long id) {
+            super(id);
+        }
+
+        PacketRemove(ByteBuf buf) throws IOException {
+            super(buf);
+        }
+
+        @Override
+        protected void write(ByteBuf buf) {
+            buf.writeByte(PacketType.REMOVE.ordinal());
+            buf.writeLong(entryId);
+        }
+
+        @Override
+        protected void read(ByteBuf buf) {}
+    }
+
+    /**
+     * Overwrite online status or inventory of the entry.
+     */
+    public static class PacketOverwrite extends PacketEntry {
+
+        public static final int ONLINE_BIT = 1;
+        public static final int ONLINE_VALID = 1 << 1;
+        public static final int ITEMS_VALID = 1 << 2;
+        public static final int ALL_ITEM_UPDATE_BIT = 1 << 3;
+        public boolean onlineValid;
+        public boolean online;
+        public boolean itemsValid;
+        public boolean allItemUpdate;
+        public int[] validIndices;
+        public NBTTagList items;
+
+        protected PacketOverwrite(long id) {
+            super(id);
+        }
+
+        protected PacketOverwrite(ByteBuf buf) throws IOException {
+            super(buf);
+        }
+
+        public PacketOverwrite setOnline(boolean online) {
+            this.onlineValid = true;
+            this.online = online;
+            return this;
+        }
+
+        public PacketOverwrite setItems(int[] validIndices, NBTTagList items) {
+            this.itemsValid = true;
+            this.allItemUpdate = validIndices == null || validIndices.length == 0;
+            this.validIndices = validIndices;
+            this.items = items;
+
+            return this;
+        }
+
+        @Override
+        protected void write(ByteBuf buf) throws IOException {
+            buf.writeByte(PacketType.OVERWRITE.ordinal());
+            buf.writeLong(entryId);
+
+            int flags = 0;
+
+            if (onlineValid) {
+                flags |= ONLINE_VALID;
+                flags |= online ? ONLINE_BIT : 0;
+            }
+            if (itemsValid) {
+                flags |= ITEMS_VALID;
+                if (allItemUpdate) {
+                    flags |= ALL_ITEM_UPDATE_BIT;
+                    buf.writeByte(flags);
+                } else {
+                    buf.writeByte(flags);
+                    buf.writeInt(validIndices.length);
+                    for (int validIndex : validIndices) {
+                        buf.writeInt(validIndex);
+                    }
+                }
+                try (ByteBufOutputStream stream = new ByteBufOutputStream(buf)) {
+
+                    NBTTagCompound wrapper = new NBTTagCompound();
+
+                    wrapper.setTag("data", items);
+                    CompressedStreamTools.writeCompressed(wrapper, stream);
+                }
+            } else {
+                buf.writeByte(flags);
+            }
+        }
+
+        @Override
+        protected void read(ByteBuf buf) throws IOException {
+            int flags = buf.readByte();
+
+            /* Decide whether to use online flag or not */
+            if ((flags & ONLINE_VALID) == ONLINE_VALID) {
+                this.onlineValid = true;
+                this.online = (flags & ONLINE_BIT) == ONLINE_BIT;
+            }
+            /* Decide whether to read item list or not */
+            if ((flags & ITEMS_VALID) == ITEMS_VALID) {
+                if ((flags & ALL_ITEM_UPDATE_BIT) == ALL_ITEM_UPDATE_BIT) {
+                    this.allItemUpdate = true;
+                } else {
+                    int numItems = buf.readInt();
+                    this.itemsValid = true;
+                    this.validIndices = new int[numItems];
+                    for (int i = 0; i < numItems; ++i) {
+                        this.validIndices[i] = buf.readInt();
+                    }
+                }
+
+                try (ByteBufInputStream stream = new ByteBufInputStream(buf)) {
+                    this.items = CompressedStreamTools.readCompressed(stream).getTagList("data", NBT.TAG_COMPOUND);
+                }
+            }
+        }
+    }
+
+    /**
+     * Rename the entry.
+     */
+    public static class PacketRename extends PacketEntry {
+
+        public String newName;
+
+        protected PacketRename(long id, String newName) {
+            super(id);
+            this.newName = newName;
+        }
+
+        protected PacketRename(ByteBuf buf) throws IOException {
+            super(buf);
+        }
+
+        @Override
+        protected void write(ByteBuf buf) {
+            buf.writeByte(PacketType.RENAME.ordinal());
+            buf.writeLong(entryId);
+            ByteBufUtils.writeUTF8String(buf, newName);
+        }
+
+        @Override
+        protected void read(ByteBuf buf) {
+            newName = ByteBufUtils.readUTF8String(buf);
+        }
+    }
+}

From a89f6346331991b7c813f09ba73ba927a8618773 Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Fri, 15 Sep 2023 09:33:16 -0700
Subject: [PATCH 04/22] appeng/helpers: Use new iface terminal API

---
 .../java/appeng/helpers/DualityInterface.java |  5 ---
 .../java/appeng/helpers/IInterfaceHost.java   | 33 +++++++++----------
 .../java/appeng/parts/misc/PartInterface.java |  5 +++
 .../appeng/parts/p2p/PartP2PInterface.java    |  5 +++
 .../java/appeng/tile/misc/TileInterface.java  |  5 +++
 5 files changed, 31 insertions(+), 22 deletions(-)

diff --git a/src/main/java/appeng/helpers/DualityInterface.java b/src/main/java/appeng/helpers/DualityInterface.java
index 31ef4fe3b92..68d4d6c5329 100644
--- a/src/main/java/appeng/helpers/DualityInterface.java
+++ b/src/main/java/appeng/helpers/DualityInterface.java
@@ -1155,11 +1155,6 @@ public String getTermName() {
         }
     }
 
-    public long getSortValue() {
-        final TileEntity te = this.iHost.getTileEntity();
-        return (te.zCoord << 24) ^ (te.xCoord << 8) ^ te.yCoord;
-    }
-
     public BaseActionSource getActionSource() {
         return interfaceRequestSource;
     }
diff --git a/src/main/java/appeng/helpers/IInterfaceHost.java b/src/main/java/appeng/helpers/IInterfaceHost.java
index 2cdcb0ec67f..e5db9ca329b 100644
--- a/src/main/java/appeng/helpers/IInterfaceHost.java
+++ b/src/main/java/appeng/helpers/IInterfaceHost.java
@@ -10,11 +10,10 @@
 
 package appeng.helpers;
 
-import java.util.ArrayList;
 import java.util.EnumSet;
-import java.util.List;
 
 import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.common.util.ForgeDirection;
 
@@ -24,9 +23,9 @@
 import appeng.api.implementations.IUpgradeableHost;
 import appeng.api.networking.crafting.ICraftingProvider;
 import appeng.api.networking.crafting.ICraftingRequester;
+import appeng.api.util.IIfaceTermViewable;
 
-public interface IInterfaceHost
-        extends ICraftingProvider, IUpgradeableHost, ICraftingRequester, IInterfaceTerminalSupport {
+public interface IInterfaceHost extends ICraftingProvider, IUpgradeableHost, ICraftingRequester, IIfaceTermViewable {
 
     DualityInterface getInterfaceDuality();
 
@@ -37,17 +36,7 @@ public interface IInterfaceHost
     void saveChanges();
 
     @Override
-    default PatternsConfiguration[] getPatternsConfigurations() {
-        DualityInterface dual = getInterfaceDuality();
-        List<PatternsConfiguration> patterns = new ArrayList<>();
-        for (int i = 0; i <= dual.getInstalledUpgrades(Upgrades.PATTERN_CAPACITY); ++i) {
-            patterns.add(new PatternsConfiguration(i * 9, 9));
-        }
-        return patterns.toArray(new PatternsConfiguration[0]);
-    }
-
-    @Override
-    default IInventory getPatterns(int index) {
+    default IInventory getPatterns() {
         return getInterfaceDuality().getPatterns();
     }
 
@@ -62,7 +51,17 @@ default String getName() {
     }
 
     @Override
-    default long getSortValue() {
-        return getInterfaceDuality().getSortValue();
+    default int rows() {
+        return getInterfaceDuality().getInstalledUpgrades(Upgrades.PATTERN_CAPACITY) + 1;
+    }
+
+    @Override
+    default int rowSize() {
+        return DualityInterface.NUMBER_OF_PATTERN_SLOTS;
+    }
+
+    @Override
+    default ItemStack getDisplayRep() {
+        return getInterfaceDuality().getCrafterIcon();
     }
 }
diff --git a/src/main/java/appeng/parts/misc/PartInterface.java b/src/main/java/appeng/parts/misc/PartInterface.java
index 23704196044..d8a7f1064f8 100644
--- a/src/main/java/appeng/parts/misc/PartInterface.java
+++ b/src/main/java/appeng/parts/misc/PartInterface.java
@@ -386,4 +386,9 @@ public int getPriority() {
     public void setPriority(final int newValue) {
         this.duality.setPriority(newValue);
     }
+
+    @Override
+    public ItemStack getSelfRep() {
+        return this.getItemStack();
+    }
 }
diff --git a/src/main/java/appeng/parts/p2p/PartP2PInterface.java b/src/main/java/appeng/parts/p2p/PartP2PInterface.java
index 8ae7facbc7c..f5e9a2d25c7 100644
--- a/src/main/java/appeng/parts/p2p/PartP2PInterface.java
+++ b/src/main/java/appeng/parts/p2p/PartP2PInterface.java
@@ -390,4 +390,9 @@ public void onTunnelNetworkChange() {
     public boolean shouldDisplay() {
         return IInterfaceHost.super.shouldDisplay() && !isOutput();
     }
+
+    @Override
+    public ItemStack getSelfRep() {
+        return this.getItemStack();
+    }
 }
diff --git a/src/main/java/appeng/tile/misc/TileInterface.java b/src/main/java/appeng/tile/misc/TileInterface.java
index 8409a7a6fbe..d3628bcf1b8 100644
--- a/src/main/java/appeng/tile/misc/TileInterface.java
+++ b/src/main/java/appeng/tile/misc/TileInterface.java
@@ -319,4 +319,9 @@ public boolean isActive() {
     public boolean isBooting() {
         return (clientFlags & BOOTING_FLAG) == BOOTING_FLAG;
     }
+
+    @Override
+    public ItemStack getSelfRep() {
+        return this.getItemFromTile(this);
+    }
 }

From 6597d85b3d329a1681a36fadc537c5f89d1043e6 Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Fri, 15 Sep 2023 09:36:59 -0700
Subject: [PATCH 05/22] appeng/container/implementations: Optimize iface
 terminal

The interface terminal is ripe for many optimizations. This commit seeks
to fix the biggest issues:

* Every tick, the interface terminal checks for any network changes. This
  has been improved to check only when the network has finished booting.

* Every tick, the interface terminal iterates through all of its tracked
  inventories to check for changes. This is bad when the ME system has a
  nontrivial amount of tracked inventories, because it it tries to check
  whether items are different, and is expensive for NBT items such as
  patterns. This has been changed to send changes that have been marked
  dirty.

This commit does not implement handling on the GUI side.
---
 .../ContainerInterfaceTerminal.java           | 517 ++++++++++--------
 1 file changed, 278 insertions(+), 239 deletions(-)

diff --git a/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java b/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
index 7cfb9467501..2b9dbb6c1ca 100644
--- a/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
+++ b/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
@@ -1,3 +1,4 @@
+
 /*
  * This file is part of Applied Energistics 2. Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. Applied
  * Energistics 2 is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General
@@ -10,62 +11,69 @@
 
 package appeng.container.implementations;
 
-import java.io.IOException;
-import java.util.Collection;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Set;
 
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.inventory.IInventory;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
 import net.minecraftforge.common.util.ForgeDirection;
 
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
+import com.google.common.primitives.Ints;
 
 import appeng.api.networking.IGrid;
 import appeng.api.networking.IGridNode;
-import appeng.api.networking.security.IActionHost;
 import appeng.api.util.DimensionalCoord;
+import appeng.api.util.IIfaceTermViewable;
 import appeng.container.AEBaseContainer;
+import appeng.core.features.registries.IfaceTermRegistry;
 import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketCompressedNBT;
-import appeng.helpers.IInterfaceTerminalSupport;
-import appeng.helpers.IInterfaceTerminalSupport.PatternsConfiguration;
-import appeng.helpers.InterfaceTerminalSupportedClassProvider;
+import appeng.core.sync.packets.PacketIfaceTermUpdate;
 import appeng.helpers.InventoryAction;
 import appeng.items.misc.ItemEncodedPattern;
 import appeng.parts.reporting.PartInterfaceTerminal;
-import appeng.tile.inventory.AppEngInternalInventory;
 import appeng.util.InventoryAdaptor;
 import appeng.util.Platform;
-import appeng.util.inv.AdaptorIInventory;
 import appeng.util.inv.AdaptorPlayerHand;
 import appeng.util.inv.ItemSlot;
-import appeng.util.inv.WrapperInvSlot;
 
 public final class ContainerInterfaceTerminal extends AEBaseContainer {
 
-    /**
-     * this stuff is all server side..
-     */
-    private static long autoBase = Long.MIN_VALUE;
+    private int nextId = 0;
 
-    private final Multimap<IInterfaceTerminalSupport, InvTracker> supportedInterfaces = HashMultimap.create();
-    private final Map<Long, InvTracker> byId = new HashMap<>();
+    private final Map<IIfaceTermViewable, InvTracker> tracked = new HashMap<>();
+    private final Map<Long, InvTracker> trackedById = new HashMap<>();
+    private PacketIfaceTermUpdate dirty;
+    private boolean isDirty;
     private IGrid grid;
-    private NBTTagCompound data = new NBTTagCompound();
+    private PartInterfaceTerminal partRef;
+    private boolean wasOff;
 
     public ContainerInterfaceTerminal(final InventoryPlayer ip, final PartInterfaceTerminal anchor) {
         super(ip, anchor);
-
+        assert anchor != null;
+        this.partRef = anchor;
         if (Platform.isServer()) {
             this.grid = anchor.getActionableNode().getGrid();
+            dirty = this.updateList();
+            if (dirty != null) {
+                dirty.encode();
+                this.isDirty = true;
+            } else {
+                dirty = new PacketIfaceTermUpdate();
+            }
         }
-
-        this.bindPlayerInventory(ip, 14, 0);
+        this.bindPlayerInventory(ip, 14, 3);
     }
 
     @Override
@@ -80,154 +88,128 @@ public void detectAndSendChanges() {
             return;
         }
 
-        int total = 0;
-        boolean missing = false;
-
-        final IActionHost host = this.getActionHost();
-        if (host != null) {
-            final IGridNode agn = host.getActionableNode();
-            if (agn != null && agn.isActive()) {
-                for (var clz : InterfaceTerminalSupportedClassProvider.getSupportedClasses()) {
-                    for (final IGridNode gn : this.grid.getMachines(clz)) {
-                        final IInterfaceTerminalSupport interfaceTerminalSupport = (IInterfaceTerminalSupport) gn
-                                .getMachine();
-                        if (!gn.isActive() || !interfaceTerminalSupport.shouldDisplay()) continue;
-
-                        final Collection<InvTracker> t = supportedInterfaces.get(interfaceTerminalSupport);
-                        final String name = interfaceTerminalSupport.getName();
-                        missing = t.isEmpty() || t.stream().anyMatch(it -> !it.unlocalizedName.equals(name));
-                        total += interfaceTerminalSupport.getPatternsConfigurations().length;
-                        if (missing) break;
-                    }
-                    // we can stop if any is missing. The value of `total` is not important if `missing == true`
-                    if (missing) break;
-                }
-            }
-        }
+        final IGridNode agn = this.partRef.getActionableNode();
 
-        if (total != this.supportedInterfaces.size() || missing) {
-            this.regenList(this.data);
-        } else {
-            for (final InvTracker inv : supportedInterfaces.values()) {
-                for (int x = 0; x < inv.client.getSizeInventory(); x++) {
-                    if (this.isDifferent(inv.server.getStackInSlot(inv.offset + x), inv.client.getStackInSlot(x))) {
-                        this.addItems(this.data, inv, x, 1);
-                    }
-                }
+        if (!agn.isActive()) {
+            /*
+             * Should turn off the terminal. However, there's no need to remove all the entries from the client.
+             * Continue tracking on the server just in case the system comes back online. Just don't send any new
+             * updates. This prevents DoSing the player if their network is flickering.
+             */
+            if (!this.wasOff) {
+                PacketIfaceTermUpdate update = new PacketIfaceTermUpdate();
+
+                update.setDisconnect();
+                this.wasOff = true;
+                NetworkHandler.instance.sendTo(update, (EntityPlayerMP) this.getPlayerInv().player);
             }
+            return;
         }
+        this.wasOff = false;
 
-        if (!this.data.hasNoTags()) {
-            try {
-                NetworkHandler.instance
-                        .sendTo(new PacketCompressedNBT(this.data), (EntityPlayerMP) this.getPlayerInv().player);
-            } catch (final IOException e) {
-                // :P
+        if (this.partRef.needsUpdate()) {
+            PacketIfaceTermUpdate update = this.updateList();
+            if (update != null) {
+                update.encode();
+                NetworkHandler.instance.sendTo(update, (EntityPlayerMP) this.getPlayerInv().player);
             }
-
-            this.data = new NBTTagCompound();
+        } else if (isDirty) {
+            this.dirty.encode();
+            NetworkHandler.instance.sendTo(this.dirty, (EntityPlayerMP) this.getPlayerInv().player);
+            this.dirty = new PacketIfaceTermUpdate();
+            this.isDirty = false;
         }
     }
 
     @Override
     public void doAction(final EntityPlayerMP player, final InventoryAction action, final int slot, final long id) {
-        final InvTracker inv = this.byId.get(id);
+        final InvTracker inv = this.trackedById.get(id);
         if (inv != null) {
-            final ItemStack is = inv.server.getStackInSlot(slot + inv.offset);
-            final boolean hasItemInHand = player.inventory.getItemStack() != null;
-
-            final InventoryAdaptor playerHand = new AdaptorPlayerHand(player);
-
-            final WrapperInvSlot slotInv = new PatternInvSlot(inv.server);
+            final ItemStack handStack = player.inventory.getItemStack();
 
-            final IInventory theSlot = slotInv.getWrapper(slot + inv.offset);
-            final InventoryAdaptor interfaceSlot = new AdaptorIInventory(theSlot);
+            if (handStack != null && !(handStack.getItem() instanceof ItemEncodedPattern)) {
+                // Why even bother if we're not dealing with an encoded pattern in hand
+                return;
+            }
 
-            IInventory interfaceHandler = inv.server;
-            boolean canInsert = true;
+            final ItemStack slotStack = inv.patterns.getStackInSlot(slot);
+            final InventoryAdaptor playerHand = new AdaptorPlayerHand(player);
 
             switch (action) {
+                /* Set down/pickup. This is the same as SPLIT_OR_PLACE_SINGLE as our max stack sizes are 1 in slots. */
                 case PICKUP_OR_SET_DOWN -> {
-                    if (hasItemInHand) {
-                        for (int s = 0; s < interfaceHandler.getSizeInventory(); s++) {
-                            if (Platform.isSameItemPrecise(
-                                    interfaceHandler.getStackInSlot(s),
-                                    player.inventory.getItemStack())) {
-                                canInsert = false;
-                                break;
+                    if (handStack != null) {
+                        for (int s = 0; s < inv.patterns.getSizeInventory(); s++) {
+                            /* Is there a duplicate pattern here? */
+                            if (Platform.isSameItemPrecise(inv.patterns.getStackInSlot(s), handStack)) {
+                                /* We're done here - dupe found. */
+                                return;
                             }
                         }
-                        if (canInsert) {
-                            ItemStack inSlot = theSlot.getStackInSlot(0);
-                            if (inSlot == null) {
-                                player.inventory.setItemStack(interfaceSlot.addItems(player.inventory.getItemStack()));
-                            } else {
-                                inSlot = inSlot.copy();
-                                final ItemStack inHand = player.inventory.getItemStack().copy();
-
-                                theSlot.setInventorySlotContents(0, null);
-                                player.inventory.setItemStack(null);
-
-                                player.inventory.setItemStack(interfaceSlot.addItems(inHand.copy()));
-
-                                if (player.inventory.getItemStack() == null) {
-                                    player.inventory.setItemStack(inSlot);
-                                } else {
-                                    player.inventory.setItemStack(inHand);
-                                    theSlot.setInventorySlotContents(0, inSlot);
-                                }
-                            }
-                        }
-                    } else {
-                        final IInventory mySlot = slotInv.getWrapper(slot + inv.offset);
-                        mySlot.setInventorySlotContents(0, playerHand.addItems(mySlot.getStackInSlot(0)));
                     }
-                }
-                case SPLIT_OR_PLACE_SINGLE -> {
-                    if (hasItemInHand) {
-                        for (int s = 0; s < interfaceHandler.getSizeInventory(); s++) {
-                            if (Platform.isSameItemPrecise(
-                                    interfaceHandler.getStackInSlot(s),
-                                    player.inventory.getItemStack())) {
-                                canInsert = false;
-                                break;
-                            }
-                        }
-                        if (canInsert) {
-                            ItemStack extra = playerHand.removeItems(1, null, null);
-                            if (extra != null && !interfaceSlot.containsItems()) {
-                                extra = interfaceSlot.addItems(extra);
-                            }
-                            if (extra != null) {
-                                playerHand.addItems(extra);
-                            }
-                        }
-                    } else if (is != null) {
-                        ItemStack extra = interfaceSlot.removeItems((is.stackSize + 1) / 2, null, null);
-                        if (extra != null) {
-                            extra = playerHand.addItems(extra);
+
+                    if (slotStack == null) {
+                        /* Insert to container, if valid */
+                        if (handStack == null) {
+                            /* Nothing happens */
+                            return;
                         }
-                        if (extra != null) {
-                            interfaceSlot.addItems(extra);
+                        inv.patterns.setInventorySlotContents(slot, playerHand.removeItems(1, null, null));
+                    } else {
+                        /* Exchange? */
+                        if (handStack != null && handStack.stackSize > 1) {
+                            /* Exchange is impossible, abort */
+                            return;
                         }
+                        inv.patterns.setInventorySlotContents(slot, playerHand.removeItems(1, null, null));
+                        playerHand.addItems(slotStack.copy());
                     }
+                    syncIfaceSlot(inv, id, slot, inv.patterns.getStackInSlot(slot));
                 }
+                /* Shift click from slot -> player. Player -> slot is not supported. */
                 case SHIFT_CLICK -> {
-                    final IInventory mySlot = slotInv.getWrapper(slot + inv.offset);
-                    final InventoryAdaptor playerInv = InventoryAdaptor.getAdaptor(player, ForgeDirection.UNKNOWN);
-                    mySlot.setInventorySlotContents(0, mergeToPlayerInventory(playerInv, mySlot.getStackInSlot(0)));
+                    InventoryAdaptor playerInv = InventoryAdaptor.getAdaptor(player.inventory, ForgeDirection.UNKNOWN);
+                    ItemStack leftOver = mergeToPlayerInventory(playerInv, slotStack);
+
+                    if (leftOver == null) {
+                        inv.patterns.setInventorySlotContents(slot, null);
+                        syncIfaceSlot(inv, id, slot, null);
+                    }
                 }
+                /* Move all blank patterns -> player */
                 case MOVE_REGION -> {
-                    final InventoryAdaptor playerInvAd = InventoryAdaptor.getAdaptor(player, ForgeDirection.UNKNOWN);
-                    for (int x = 0; x < inv.client.getSizeInventory(); x++) {
-                        inv.server.setInventorySlotContents(
-                                x + inv.offset,
-                                mergeToPlayerInventory(playerInvAd, inv.server.getStackInSlot(x + inv.offset)));
+                    final InventoryAdaptor playerInv = InventoryAdaptor.getAdaptor(player, ForgeDirection.UNKNOWN);
+                    List<Integer> valid = new ArrayList<>();
+
+                    for (int i = 0; i < inv.patterns.getSizeInventory(); i++) {
+                        ItemStack toExtract = inv.patterns.getStackInSlot(i);
+
+                        if (toExtract == null) {
+                            continue;
+                        }
+
+                        ItemStack leftOver = mergeToPlayerInventory(playerInv, toExtract);
+
+                        if (leftOver != null) {
+                            break;
+                        } else {
+                            inv.patterns.setInventorySlotContents(i, null);
+                        }
+                        valid.add(i);
+                    }
+                    if (valid.size() > 0) {
+                        int[] validIndices = Ints.toArray(valid);
+                        NBTTagList tag = new NBTTagList();
+                        for (int i = 0; i < valid.size(); ++i) {
+                            tag.appendTag(new NBTTagCompound());
+                        }
+                        dirty.addOverwriteEntry(id).setItems(validIndices, tag);
+                        isDirty = true;
                     }
                 }
                 case CREATIVE_DUPLICATE -> {
-                    if (player.capabilities.isCreativeMode && !hasItemInHand) {
-                        player.inventory.setItemStack(is == null ? null : is.copy());
+                    if (player.capabilities.isCreativeMode) {
+                        playerHand.addItems(handStack);
                     }
                 }
                 default -> {
@@ -239,6 +221,32 @@ public void doAction(final EntityPlayerMP player, final InventoryAction action,
         }
     }
 
+    /**
+     * Since we are not using "slots" like MC and instead taking the Thaumic Energistics route, this is used to
+     * eventually send a packet to the client to indicate that a slot has changed. <br/>
+     * Why weren't slots used? Because at first I was more concerned about performance issues, and by the time I
+     * realized I was perhaps making a huge mistake in not using the notion of a "slot", I had already finished
+     * implementing my own version of a "slot". Because of this everything in this GUI is basically hand written. Also,
+     * the previous implementation was seemingly allocating slots. <br/>
+     * // rant over
+     */
+    private void syncIfaceSlot(InvTracker inv, long id, int slot, ItemStack stack) {
+        int[] validIndices = { slot };
+        NBTTagList list = new NBTTagList();
+        NBTTagCompound item = new NBTTagCompound();
+
+        if (stack != null) {
+            stack.writeToNBT(item);
+        }
+        list.appendTag(item);
+        inv.updateNBT();
+        this.dirty.addOverwriteEntry(id).setItems(validIndices, list);
+        this.isDirty = true;
+    }
+
+    /**
+     * Merge from slot -> player inv. Returns the items not added.
+     */
     private ItemStack mergeToPlayerInventory(InventoryAdaptor playerInv, ItemStack stack) {
         if (stack == null) return null;
         for (ItemSlot slot : playerInv) {
@@ -252,36 +260,75 @@ private ItemStack mergeToPlayerInventory(InventoryAdaptor playerInv, ItemStack s
         return playerInv.addItems(stack);
     }
 
-    private void regenList(final NBTTagCompound data) {
-        this.byId.clear();
-        this.supportedInterfaces.clear();
-
-        final IActionHost host = this.getActionHost();
-        if (host != null) {
-            final IGridNode agn = host.getActionableNode();
-            if (agn != null && agn.isActive()) {
-                for (var clz : InterfaceTerminalSupportedClassProvider.getSupportedClasses()) {
-                    for (final IGridNode gn : this.grid.getMachines(clz)) {
-                        final IInterfaceTerminalSupport terminalSupport = (IInterfaceTerminalSupport) gn.getMachine();
-                        if (!gn.isActive() || !terminalSupport.shouldDisplay()) continue;
-
-                        final var configurations = terminalSupport.getPatternsConfigurations();
+    /**
+     * Finds out whether any updates are needed, and if so, incrementally updates the list.
+     */
+    private PacketIfaceTermUpdate updateList() {
+        PacketIfaceTermUpdate update = null;
+        var supported = IfaceTermRegistry.instance().getSupportedClasses();
+        Set<IIfaceTermViewable> visited = new HashSet<>();
+
+        for (Class<? extends IIfaceTermViewable> c : supported) {
+            for (IGridNode node : grid.getMachines(c)) {
+                IIfaceTermViewable machine = (IIfaceTermViewable) node.getMachine();
+                /* First check if we are already tracking this node */
+                if (tracked.containsKey(machine)) {
+                    /* Check for updates */
+                    InvTracker known = tracked.get(machine);
+
+                    /* Name changed? */
+                    String name = machine.getName();
+
+                    if (!Objects.equals(known.name, name)) {
+                        if (update == null) update = new PacketIfaceTermUpdate();
+                        update.addRenamedEntry(known.id, name);
+                        known.name = name;
+                    }
 
-                        for (int i = 0; i < configurations.length; ++i) {
-                            this.supportedInterfaces
-                                    .put(terminalSupport, new InvTracker(terminalSupport, configurations[i], i));
-                        }
+                    /* Status changed? */
+                    boolean isActive = node.isActive() || machine.shouldDisplay();
+
+                    if (!known.online && isActive) {
+                        /* Node offline -> online */
+                        known.online = true;
+                        if (update == null) update = new PacketIfaceTermUpdate();
+                        known.updateNBT();
+                        update.addOverwriteEntry(known.id).setOnline(true).setItems(new int[0], known.invNbt);
+                    } else if (known.online && !isActive) {
+                        /* Node online -> offline */
+                        known.online = false;
+                        if (update == null) update = new PacketIfaceTermUpdate();
+                        update.addOverwriteEntry(known.id).setOnline(false);
                     }
+                } else {
+                    /* Add a new entry */
+                    if (update == null) update = new PacketIfaceTermUpdate();
+                    InvTracker entry = new InvTracker(nextId++, machine, node.isActive());
+                    update.addNewEntry(entry.id, entry.name, entry.online).setLoc(entry.x, entry.y, entry.z, entry.dim)
+                            .setItems(entry.rows, entry.rowSize, entry.invNbt)
+                            .setReps(machine.getSelfRep(), machine.getDisplayRep());
+                    tracked.put(machine, entry);
+                    trackedById.put(entry.id, entry);
                 }
+                visited.add(machine);
             }
         }
 
-        data.setBoolean("clear", true);
+        /* Now find any entries that we need to remove */
+        Iterator<Entry<IIfaceTermViewable, InvTracker>> it = tracked.entrySet().iterator();
+        while (it.hasNext()) {
+            var entry = it.next();
+            if (visited.contains(entry.getKey())) {
+                continue;
+            }
+
+            if (update == null) update = new PacketIfaceTermUpdate();
 
-        for (final InvTracker inv : this.supportedInterfaces.values()) {
-            this.byId.put(inv.which, inv);
-            this.addItems(data, inv, 0, inv.client.getSizeInventory());
+            trackedById.remove(entry.getValue().id);
+            it.remove();
+            update.addRemovalEntry(entry.getValue().id);
         }
+        return update;
     }
 
     private boolean isDifferent(final ItemStack a, final ItemStack b) {
@@ -296,89 +343,81 @@ private boolean isDifferent(final ItemStack a, final ItemStack b) {
         return !ItemStack.areItemStacksEqual(a, b);
     }
 
-    private void addItems(final NBTTagCompound data, final InvTracker inv, final int offset, final int length) {
-        final String name = '=' + Long.toString(inv.which, Character.MAX_RADIX);
-        final NBTTagCompound tag = data.getCompoundTag(name);
-
-        if (tag.hasNoTags()) {
-            tag.setLong("sortBy", inv.sortBy);
-            tag.setString("un", inv.unlocalizedName);
-            tag.setInteger("x", inv.X);
-            tag.setInteger("y", inv.Y);
-            tag.setInteger("z", inv.Z);
-            tag.setInteger("dim", inv.dim);
-            tag.setInteger("size", inv.client.getSizeInventory());
-        }
-
-        for (int x = 0; x < length; x++) {
-            final NBTTagCompound itemNBT = new NBTTagCompound();
-
-            final ItemStack is = inv.server.getStackInSlot(x + offset + inv.offset);
-
-            // "update" client side.
-            inv.client.setInventorySlotContents(offset + x, is == null ? null : is.copy());
-
-            if (is != null) {
-                is.writeToNBT(itemNBT);
-            }
-
-            tag.setTag(Integer.toString(x + offset), itemNBT);
-        }
-
-        data.setTag(name, tag);
-    }
-
     private static class InvTracker {
 
-        private final long sortBy;
-        private final long which = autoBase++;
-        private final String unlocalizedName;
-        private final IInventory client;
-        private final IInventory server;
-        private final int offset;
-        private final int X;
-        private final int Y;
-        private final int Z;
+        private final long id;
+        private String name;
+        private final IInventory patterns;
+        private final int rowSize;
+        private final int rows;
+        private final int x;
+        private final int y;
+        private final int z;
         private final int dim;
-
-        public InvTracker(final DimensionalCoord coord, long sortValue, final IInventory patterns,
-                final String unlocalizedName, int offset, int size) {
-            this(coord.x, coord.y, coord.z, coord.getDimension(), sortValue, patterns, unlocalizedName, offset, size);
-        }
-
-        public InvTracker(int x, int y, int z, int dim, long sortValue, final IInventory patterns,
-                final String unlocalizedName, int offset, int size) {
-            this.server = patterns;
-            this.client = new AppEngInternalInventory(null, size);
-            this.unlocalizedName = unlocalizedName;
-            this.sortBy = sortValue + offset << 16;
-            this.offset = offset;
-            this.X = x;
-            this.Y = y;
-            this.Z = z;
-            this.dim = dim;
-        }
-
-        public InvTracker(IInterfaceTerminalSupport terminalSupport, PatternsConfiguration configuration, int index) {
-            this(
-                    terminalSupport.getLocation(),
-                    terminalSupport.getSortValue(),
-                    terminalSupport.getPatterns(index),
-                    terminalSupport.getName(),
-                    configuration.offset,
-                    configuration.size);
+        private boolean online;
+        private NBTTagList invNbt;
+
+        InvTracker(long id, IIfaceTermViewable machine, boolean online) {
+            DimensionalCoord location = machine.getLocation();
+
+            this.id = id;
+            this.name = machine.getName();
+            this.patterns = machine.getPatterns();
+            this.rowSize = machine.rowSize();
+            this.rows = machine.rows();
+            this.x = location.x;
+            this.y = location.y;
+            this.z = location.z;
+            this.dim = location.getDimension();
+            this.online = online;
+            this.invNbt = new NBTTagList();
+            updateNBT();
         }
-    }
-
-    private static class PatternInvSlot extends WrapperInvSlot {
 
-        public PatternInvSlot(final IInventory inv) {
-            super(inv);
+        /**
+         * Refresh nbt items in the row, item idx.
+         */
+        private void updateNBT(int row, int idx) {
+            ItemStack stack = this.patterns.getStackInSlot(row * this.rowSize + idx);
+
+            if (stack != null) {
+                NBTTagCompound itemNbt = this.invNbt.getCompoundTagAt(idx);
+                stack.writeToNBT(itemNbt);
+            } else {
+                // replace
+                this.invNbt.func_150304_a(idx, new NBTTagCompound());
+            }
         }
 
-        @Override
-        public boolean isItemValid(final ItemStack itemstack) {
-            return itemstack != null && itemstack.getItem() instanceof ItemEncodedPattern;
+        /**
+         * Refreshes all nbt tags.
+         */
+        private void updateNBT() {
+            this.invNbt = new NBTTagList();
+            for (int i = 0; i < this.rows; ++i) {
+                for (int j = 0; j < this.rowSize; ++j) {
+                    final int offset = this.rowSize * i;
+                    ItemStack stack = this.patterns.getStackInSlot(offset + j);
+
+                    if (stack != null) {
+                        this.invNbt.appendTag(stack.writeToNBT(new NBTTagCompound()));
+                    } else {
+                        this.invNbt.appendTag(new NBTTagCompound());
+                    }
+                }
+            }
         }
     }
+    //
+    // private static class PatternInvSlot extends WrapperInvSlot {
+    //
+    // public PatternInvSlot(final IInventory inv) {
+    // super(inv);
+    // }
+    //
+    // @Override
+    // public boolean isItemValid(final ItemStack itemstack) {
+    // return itemstack != null && itemstack.getItem() instanceof ItemEncodedPattern;
+    // }
+    // }
 }

From 247c18901b9a54b559dab7fcb7fb31d897575209 Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Sun, 17 Sep 2023 23:21:09 -0700
Subject: [PATCH 06/22] appeng/client/render/AppEngRenderItem: Don't disable
 depth test

appeng/client/render: Render items using translations

appeng/client/gui/AEBaseGui: Use custom renderSlot

Squash of 2 commits:

* Depth test should be allowed to be used when rendering slots to make it
  easier to support z-level translations rather than use a pass-based
  rendering system.

* This commit disables those depth tests which allows tooltips to be drawn
  before the rest of the screen is drawn, which makes it way less messy to
  code as everything can be done in 1 pass.

MC's native RenderItem disregards z-level when drawing item overlays,
since it disables GL_DEPTH_TEST before drawing it. This commit adds a way
for AE2 to draw slots with its own z-level methods.
---
 .../java/appeng/client/gui/AEBaseGui.java     | 58 +++++++++++++++----
 .../client/render/AppEngRenderItem.java       | 17 ------
 .../client/render/TranslatedRenderItem.java   | 55 ++++++++++++++++++
 src/main/resources/META-INF/appeng_at.cfg     |  2 +
 4 files changed, 104 insertions(+), 28 deletions(-)
 create mode 100644 src/main/java/appeng/client/render/TranslatedRenderItem.java

diff --git a/src/main/java/appeng/client/gui/AEBaseGui.java b/src/main/java/appeng/client/gui/AEBaseGui.java
index d64cc3b99f9..5f0594c593d 100644
--- a/src/main/java/appeng/client/gui/AEBaseGui.java
+++ b/src/main/java/appeng/client/gui/AEBaseGui.java
@@ -50,6 +50,7 @@
 import appeng.client.me.SlotDisconnected;
 import appeng.client.me.SlotME;
 import appeng.client.render.AppEngRenderItem;
+import appeng.client.render.TranslatedRenderItem;
 import appeng.container.AEBaseContainer;
 import appeng.container.slot.AppEngCraftingSlot;
 import appeng.container.slot.AppEngSlot;
@@ -85,7 +86,8 @@ public abstract class AEBaseGui extends GuiContainer {
     private final List<InternalSlotME> meSlots = new LinkedList<>();
     // drag y
     private final Set<Slot> drag_click = new HashSet<>();
-    private final AppEngRenderItem aeRenderItem = new AppEngRenderItem();
+    public static final AppEngRenderItem aeRenderItem = new AppEngRenderItem();
+    public static final TranslatedRenderItem translatedRenderItem = new TranslatedRenderItem();
     private GuiScrollbar scrollBar = null;
     private boolean disableShiftClick = false;
     private Stopwatch dbl_clickTimer = Stopwatch.createStarted();
@@ -784,8 +786,10 @@ public void drawItem(final int x, final int y, final ItemStack is) {
         GL11.glEnable(GL11.GL_LIGHTING);
         GL11.glEnable(GL12.GL_RESCALE_NORMAL);
         GL11.glEnable(GL11.GL_DEPTH_TEST);
+        GL11.glTranslatef(0.0f, 0.0f, 101.0f);
         RenderHelper.enableGUIStandardItemLighting();
         itemRender.renderItemAndEffectIntoGUI(this.fontRendererObj, this.mc.renderEngine, is, x, y);
+        GL11.glTranslatef(0.0f, 0.0f, -101.0f);
         GL11.glPopAttrib();
 
         itemRender.zLevel = 0.0F;
@@ -817,10 +821,9 @@ private void drawSlot(final Slot s) {
 
             RenderItem pIR = this.setItemRender(this.aeRenderItem);
             try {
-                this.zLevel = 100.0F;
-                itemRender.zLevel = 100.0F;
-
                 if (!this.isPowered()) {
+                    this.zLevel = 100.0F;
+                    itemRender.zLevel = 100.0F;
                     GL11.glDisable(GL11.GL_LIGHTING);
                     drawRect(
                             s.xDisplayPosition,
@@ -829,14 +832,14 @@ private void drawSlot(final Slot s) {
                             16 + s.yDisplayPosition,
                             GuiColors.ItemSlotOverlayUnpowered.getColor());
                     GL11.glEnable(GL11.GL_LIGHTING);
-                }
-
-                this.zLevel = 0.0F;
-                itemRender.zLevel = 0.0F;
+                    this.zLevel = 0.0F;
+                    itemRender.zLevel = 0.0F;
+                } else {
+                    this.aeRenderItem.setAeStack(Platform.getAEStackInSlot(s));
 
-                this.aeRenderItem.setAeStack(Platform.getAEStackInSlot(s));
+                    this.drawAESlot(s);
+                }
 
-                this.safeDrawSlot(s);
             } catch (final Exception err) {
                 AELog.warn("[AppEng] AE prevented crash while drawing slot: " + err.toString());
             }
@@ -940,7 +943,7 @@ private void drawSlot(final Slot s) {
 
                 if (s instanceof AppEngSlot) {
                     ((AppEngSlot) s).setDisplay(true);
-                    this.safeDrawSlot(s);
+                    this.drawMCSlot(s);
                 } else {
                     this.safeDrawSlot(s);
                 }
@@ -954,6 +957,39 @@ private void drawSlot(final Slot s) {
         this.safeDrawSlot(s);
     }
 
+    public void drawMCSlot(Slot slotIn) {
+        int i = slotIn.xDisplayPosition;
+        int j = slotIn.yDisplayPosition;
+        ItemStack itemstack = slotIn.getStack();
+        String s = null;
+
+        GL11.glEnable(GL11.GL_DEPTH_TEST);
+        translatedRenderItem.zLevel = 100.0f;
+        translatedRenderItem
+                .renderItemAndEffectIntoGUI(this.fontRendererObj, this.mc.getTextureManager(), itemstack, i, j);
+        translatedRenderItem.zLevel = 200.0f;
+        translatedRenderItem
+                .renderItemOverlayIntoGUI(this.fontRendererObj, this.mc.getTextureManager(), itemstack, i, j, s);
+        translatedRenderItem.zLevel = 0.0f;
+    }
+
+    public void drawAESlot(Slot slotIn) {
+        int i = slotIn.xDisplayPosition;
+        int j = slotIn.yDisplayPosition;
+        ItemStack itemstack = slotIn.getStack();
+        String s = null;
+
+        this.zLevel = 100.0F;
+        itemRender.zLevel = 100.0F;
+        itemRender.renderItemAndEffectIntoGUI(this.fontRendererObj, this.mc.getTextureManager(), itemstack, i, j);
+        itemRender.zLevel = 0.0F;
+
+        this.zLevel = 0.0F;
+        GL11.glTranslatef(0.0f, 0.0f, 200.0f);
+        aeRenderItem.renderItemOverlayIntoGUI(this.fontRendererObj, this.mc.getTextureManager(), itemstack, i, j, s);
+        GL11.glTranslatef(0.0f, 0.0f, -200.0f);
+    }
+
     private RenderItem setItemRender(final RenderItem item) {
         if (IntegrationRegistry.INSTANCE.isEnabled(IntegrationType.NEI)) {
             return ((INEI) IntegrationRegistry.INSTANCE.getInstance(IntegrationType.NEI)).setItemRender(item);
diff --git a/src/main/java/appeng/client/render/AppEngRenderItem.java b/src/main/java/appeng/client/render/AppEngRenderItem.java
index 7db9653b0c0..c5623a7cc28 100644
--- a/src/main/java/appeng/client/render/AppEngRenderItem.java
+++ b/src/main/java/appeng/client/render/AppEngRenderItem.java
@@ -79,7 +79,6 @@ public void renderItemOverlayIntoGUI(final FontRenderer fontRenderer, final Text
                 final int k = (int) Math.round(255.0D - health * 255.0D);
 
                 GL11.glDisable(GL11.GL_LIGHTING);
-                GL11.glDisable(GL11.GL_DEPTH_TEST);
                 GL11.glDisable(GL11.GL_TEXTURE_2D);
                 GL11.glDisable(GL11.GL_ALPHA_TEST);
                 GL11.glDisable(GL11.GL_BLEND);
@@ -95,7 +94,6 @@ public void renderItemOverlayIntoGUI(final FontRenderer fontRenderer, final Text
                 GL11.glEnable(GL11.GL_ALPHA_TEST);
                 GL11.glEnable(GL11.GL_TEXTURE_2D);
                 GL11.glEnable(GL11.GL_LIGHTING);
-                GL11.glEnable(GL11.GL_DEPTH_TEST);
                 GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
             }
 
@@ -105,7 +103,6 @@ public void renderItemOverlayIntoGUI(final FontRenderer fontRenderer, final Text
                         : GuiText.SmallFontCraft.getLocal();
 
                 GL11.glDisable(GL11.GL_LIGHTING);
-                GL11.glDisable(GL11.GL_DEPTH_TEST);
                 GL11.glPushMatrix();
                 GL11.glScaled(scaleFactor, scaleFactor, scaleFactor);
 
@@ -117,7 +114,6 @@ public void renderItemOverlayIntoGUI(final FontRenderer fontRenderer, final Text
 
                 GL11.glPopMatrix();
                 GL11.glEnable(GL11.GL_LIGHTING);
-                GL11.glEnable(GL11.GL_DEPTH_TEST);
             }
 
             final long amount = this.aeStack != null ? this.aeStack.getStackSize() : is.stackSize;
@@ -126,7 +122,6 @@ public void renderItemOverlayIntoGUI(final FontRenderer fontRenderer, final Text
                 final String stackSize = this.getToBeRenderedStackSize(amount);
 
                 GL11.glDisable(GL11.GL_LIGHTING);
-                GL11.glDisable(GL11.GL_DEPTH_TEST);
                 GL11.glPushMatrix();
                 GL11.glScaled(scaleFactor, scaleFactor, scaleFactor);
 
@@ -138,24 +133,12 @@ public void renderItemOverlayIntoGUI(final FontRenderer fontRenderer, final Text
 
                 GL11.glPopMatrix();
                 GL11.glEnable(GL11.GL_LIGHTING);
-                GL11.glEnable(GL11.GL_DEPTH_TEST);
             }
 
             fontRenderer.setUnicodeFlag(unicodeFlag);
         }
     }
 
-    private void renderQuad(final Tessellator par1Tessellator, final int par2, final int par3, final int par4,
-            final int par5, final int par6) {
-        par1Tessellator.startDrawingQuads();
-        par1Tessellator.setColorOpaque_I(par6);
-        par1Tessellator.addVertex(par2, par3, 0.0D);
-        par1Tessellator.addVertex(par2, par3 + par5, 0.0D);
-        par1Tessellator.addVertex(par2 + par4, par3 + par5, 0.0D);
-        par1Tessellator.addVertex(par2 + par4, par3, 0.0D);
-        par1Tessellator.draw();
-    }
-
     private String getToBeRenderedStackSize(final long originalSize) {
         if (AEConfig.instance.useTerminalUseLargeFont()) {
             return SLIM_CONVERTER.toSlimReadableForm(originalSize);
diff --git a/src/main/java/appeng/client/render/TranslatedRenderItem.java b/src/main/java/appeng/client/render/TranslatedRenderItem.java
new file mode 100644
index 00000000000..19784fdceac
--- /dev/null
+++ b/src/main/java/appeng/client/render/TranslatedRenderItem.java
@@ -0,0 +1,55 @@
+package appeng.client.render;
+
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.client.renderer.texture.TextureManager;
+import net.minecraft.item.ItemStack;
+
+import org.lwjgl.opengl.GL11;
+
+/**
+ * Uses translations instead of depth test to perform rendering.
+ */
+public class TranslatedRenderItem extends RenderItem {
+
+    @Override
+    public void renderItemOverlayIntoGUI(FontRenderer font, TextureManager texManager, ItemStack stack, int x, int y,
+            String customText) {
+        if (stack != null) {
+            GL11.glPushMatrix();
+            if (stack.stackSize > 1 || customText != null) {
+                GL11.glTranslatef(0.0f, 0.0f, this.zLevel);
+                String s1 = customText == null ? String.valueOf(stack.stackSize) : customText;
+                GL11.glDisable(GL11.GL_LIGHTING);
+                GL11.glDisable(GL11.GL_BLEND);
+                font.drawStringWithShadow(s1, x + 19 - 2 - font.getStringWidth(s1), y + 6 + 3, 16777215);
+                GL11.glEnable(GL11.GL_LIGHTING);
+                GL11.glTranslatef(0.0f, 0.0f, -this.zLevel);
+            }
+
+            if (stack.getItem().showDurabilityBar(stack)) {
+                double health = stack.getItem().getDurabilityForDisplay(stack);
+                int j1 = (int) Math.round(13.0D - health * 13.0D);
+                int k = (int) Math.round(255.0D - health * 255.0D);
+                GL11.glDisable(GL11.GL_LIGHTING);
+                GL11.glDisable(GL11.GL_TEXTURE_2D);
+                GL11.glDisable(GL11.GL_ALPHA_TEST);
+                GL11.glDisable(GL11.GL_BLEND);
+                Tessellator tessellator = Tessellator.instance;
+                int l = 255 - k << 16 | k << 8;
+                int i1 = (255 - k) / 4 << 16 | 16128;
+                this.renderQuad(tessellator, x + 2, y + 13, 13, 2, 0);
+                this.renderQuad(tessellator, x + 2, y + 13, 12, 1, i1);
+                this.renderQuad(tessellator, x + 2, y + 13, j1, 1, l);
+                // GL11.glEnable(GL11.GL_BLEND); // Forge: Disable Bled because it screws with a lot of things down the
+                // line.
+                GL11.glEnable(GL11.GL_ALPHA_TEST);
+                GL11.glEnable(GL11.GL_TEXTURE_2D);
+                GL11.glEnable(GL11.GL_LIGHTING);
+                GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+            }
+            GL11.glPopMatrix();
+        }
+    }
+}
diff --git a/src/main/resources/META-INF/appeng_at.cfg b/src/main/resources/META-INF/appeng_at.cfg
index 6018bae349e..489b3d1948f 100644
--- a/src/main/resources/META-INF/appeng_at.cfg
+++ b/src/main/resources/META-INF/appeng_at.cfg
@@ -3,3 +3,5 @@ public net.minecraft.client.gui.inventory.GuiContainer func_146977_a(Lnet/minecr
 public net.minecraft.client.gui.GuiTextField func_146188_c(IIII)V # drawSelectionBox
 #Pattern Value Setting
 public net.minecraft.client.gui.inventory.GuiContainer field_147006_u #theSlot
+# RenderItem
+public net.minecraft.client.renderer.entity.RenderItem func_77017_a(Lnet/minecraft/client/renderer/Tessellator;IIIII)V #renderQuad

From 8bd7c6695e90499478beac8c34bbed59a82fb630 Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Thu, 21 Sep 2023 07:48:24 -0700
Subject: [PATCH 07/22] appeng/client/gui/widgets: GuiImgButton.java: Add extra
 options button

Adds generic extra options button, which is a button that is skinned as
'...' (ellipses). Can be used for any gui.
---
 .../java/appeng/api/config/ActionItems.java   |   3 ++-
 .../client/gui/widgets/GuiImgButton.java      |   5 +++++
 .../core/localization/ButtonToolTips.java     |   3 ++-
 .../appliedenergistics2/lang/en_US.lang       |   2 ++
 .../textures/guis/states.png                  | Bin 16666 -> 18891 bytes
 5 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/main/java/appeng/api/config/ActionItems.java b/src/main/java/appeng/api/config/ActionItems.java
index 4fcc6730af6..bd7347a23e0 100644
--- a/src/main/java/appeng/api/config/ActionItems.java
+++ b/src/main/java/appeng/api/config/ActionItems.java
@@ -28,5 +28,6 @@ public enum ActionItems {
     TOGGLE_SHOW_FULL_INTERFACES_OFF,
     TOGGLE_SHOW_ONLY_INVALID_PATTERN_ON,
     TOGGLE_SHOW_ONLY_INVALID_PATTERN_OFF,
-    HIGHLIGHT_INTERFACE
+    HIGHLIGHT_INTERFACE,
+    EXTRA_OPTIONS,
 }
diff --git a/src/main/java/appeng/client/gui/widgets/GuiImgButton.java b/src/main/java/appeng/client/gui/widgets/GuiImgButton.java
index f254e1bd8f8..bf28fc67d26 100644
--- a/src/main/java/appeng/client/gui/widgets/GuiImgButton.java
+++ b/src/main/java/appeng/client/gui/widgets/GuiImgButton.java
@@ -635,6 +635,7 @@ public GuiImgButton(final int x, final int y, final Enum idx, final Enum val) {
                     CraftingMode.IGNORE_MISSING,
                     ButtonToolTips.CraftingModeIgnoreMissing,
                     ButtonToolTips.CraftingModeIgnoreMissingDesc);
+            this.registerApp(16 * 6 + 5, Settings.ACTIONS, ActionItems.EXTRA_OPTIONS, ButtonToolTips.ExtraOptions, "");
         }
     }
 
@@ -798,6 +799,10 @@ public boolean isVisible() {
         return this.visible;
     }
 
+    public boolean getMouseIn() {
+        return this.field_146123_n;
+    }
+
     public void set(final Enum e) {
         if (this.currentValue != e) {
             this.currentValue = e;
diff --git a/src/main/java/appeng/core/localization/ButtonToolTips.java b/src/main/java/appeng/core/localization/ButtonToolTips.java
index 7e385799778..35b644d661f 100644
--- a/src/main/java/appeng/core/localization/ButtonToolTips.java
+++ b/src/main/java/appeng/core/localization/ButtonToolTips.java
@@ -184,7 +184,8 @@ public enum ButtonToolTips {
     CraftingModeStandard,
     CraftingModeStandardDesc,
     CraftingModeIgnoreMissing,
-    CraftingModeIgnoreMissingDesc;
+    CraftingModeIgnoreMissingDesc,
+    ExtraOptions;
 
     private final String root;
 
diff --git a/src/main/resources/assets/appliedenergistics2/lang/en_US.lang b/src/main/resources/assets/appliedenergistics2/lang/en_US.lang
index 21620440996..eeba5e10a32 100644
--- a/src/main/resources/assets/appliedenergistics2/lang/en_US.lang
+++ b/src/main/resources/assets/appliedenergistics2/lang/en_US.lang
@@ -445,6 +445,8 @@ gui.tooltips.appliedenergistics2.CraftingModeStandardDesc=Only starts craft if a
 gui.tooltips.appliedenergistics2.CraftingModeIgnoreMissing=Ignore Missing Crafting Mode
 gui.tooltips.appliedenergistics2.CraftingModeIgnoreMissingDesc=Starts craft even if ingredients are missing from the ME System.
 
+gui.tooltips.appliedenergistics2.ExtraOptions=Extra Options
+
 # Units
 gui.appliedenergistics2.units.appliedenergstics=AE
 gui.appliedenergistics2.units.ic2=Energy Units
diff --git a/src/main/resources/assets/appliedenergistics2/textures/guis/states.png b/src/main/resources/assets/appliedenergistics2/textures/guis/states.png
index 434498a7adec658f2e954d43d163fd0cb815a2f2..fef9c0f46df531fa1b019cdab913bab465038309 100644
GIT binary patch
literal 18891
zcmY&<XE>X0*!P`?5wliRjc9Autg715q4sF)J!=#-Y8DwNS~S$EnnlePwYMmW+C^<*
zm9|F23W6v95AS<C&xaft$DKQOlIuLL-#T9#=&3W%UZn*9fI(B^;S&G=kspEp8Y=Rg
zm2a^#`N?y)2M-L~9325bIMF|`S-aDK?K{$>+vShlJ?3con~dTy;Twhi-XhnHJ0^b?
zxQQ0HX*_voMae<kanEn}4iUC-v*9L9`1P2E##4)j%Z(<*F$>-=5TQqi=p@NYS{9Ew
z$~dFKx0*}7M#|n+ESgaM2~ReOqA6k+=1hODLD+fOT&Ois*6{b>qE*$@@cTY}aVZC{
z6!#=Ys+)$y@!MtprQ$?=m&l_?$8vh%&~m@l0j4)Eo+2J^>V0~2t>EReM%d>IyBj-~
zBSRt;=}h{F+3I1M)o%LwTApe1X!SR@SX?)f&APq`Nlc^;oF5(_j=zh%=}D;XlrER^
zUG3&#t>w4YEioU}4Hio^-frL9uR04`+a81#w=#vVOBByWV&eIN7Ma2^6vb^3hRw^8
zT6z%`d0s{}L)I~$zwMf<jn(6v7-pVl)nuH%D}5SWWgesuju)%3y1x=CU$*mt(aY|c
z8e){vV+US8hY<?}E1A0r=ze(HNd5z$-WujF0DzA5zZ(enka-0F_yEm^_l$yUw!)w-
zM%^ihgOJU<+~sgZpC$QG;pbN<sN&x!IL#e(jW+yyFMQ?It>Xws?zmf5doIOm8wg1-
zPxi(LKW3Zb@V*D41f|6ke?Bn_-8uhPwmnwS)KvO>qILevCeU=Zxn=e!+pxd!AWOmj
zS^vYwUDE0Fbk{WaUPG=2Ad@32jFdP7LQC@At?YsxiuCU!mG|!KAdVCrPgIE=Opw97
zVO6i>$3?yx6>L6_Ms**%|5p0tt&G{q%V>C~Fl;IJMLGSFUgyo<gO+ck$91{&g~a}#
z<=c`;u3cK3K@l-DS^soOeje#gnmD5_`h;@W_@lXfV;)1D6!IuXzL|{|hXV7rlK=?5
zd6$Oq$CHPKL}b~RD0mgLTN3=@OQ_qi_1LY^!Hm25tH{%>`oPjTiT!V24Jb~AR0$YF
z+lKCT*DQ<R7QNcf@Uv=qO2<Dx?If1>Rt$j?I`m&ji=d<4Y3aVEXV1Rb>aO5=461Yu
zxa<MOl5CV#c06|Z#8Ij*AVR!9Doz`gP_d%n15)2DLiUd0J$HZjWcAjnNEni0n(bvx
zug_f{O%V}S{X{pyj9+bepWXa}on-0pm9q0wtZjTx+QJ>!#QnfIpPtvHrhiC<x~87T
zpiqbz#kfF1zmqZGlcK;FCyTujeBqrPl;Y;VsRcU<ijqK!JH7O6JCLWW>7Hj%6$y_x
zR&2Q&neJ2QbdeDh*kvX3laK*7y(ty&@B83&3{HE8*`H550%C-x*l+OA;`;@T`7&M?
z-UU4BnR)56WGElD#3TiIcFai~EE8`l<Xl@nkdu!6f_~6=z3-T6wfF;~MReBtR5yP2
zK@l9J{EeruNdj(xkhcdg7SF)#OjoQeh|=Tj0k5l!&UOO&LZPe^Xk_cbFGuo+VM~GK
zo3-K>KB!x}vJYEQ)<DjxpK^8>y<Ku|tzNAku;yN+kiY1Un-95PKwVpSZ7!%s*W7Vf
z;+H<5h?)B9;!a&ks-U>)b+tv(n7-=MGSdp@0!S{6H^wE1V-hL!>ao67?)Vw<1nV}q
z%d$LsHD#y<qn#1-IUmS-B1yU_A+Zty{Pr>o>Ny_7WUZj;VPPKc&+fjRlDU7<z%fjJ
z1C)25u9}l^ra^OtFar$0lJum^r@w0j^mi<T2r8{I3L_&U*e1WPq5zk!1>(mwpuFy+
z4HtMhfZ>wwaARzKIhEEkNpLNpYFZKlE<PF;ue1OpQf5-W6p&W&HxRz`C!uOfq<(Yo
zI8Wv7(Z*;*ZC#y3QsrpD+L1`cTa!s+z8-sJa|*XLvq4g62~)z#PZ99VB4bd4(chX}
z>D~O=qWzWMK(0WKK@RP{;t8zJNZ?Y|H*pHRvLObzD0yWsO3U$PTuS*ZIl4j6*@-z?
znxoP1Q`W}>y5x3wkl2dooksfSL97YJ`22o+)=p^AhHuH-+SOOynu;R@X{b_&2TuLj
zFA0?PtJ<fHd8E)xTLujzKE(2?8-?m+74(MD_LbEz=m6A!LVh~xy#2-$lRWI(NakcF
zVwT%yf4gc_opuEA{dfm_A)P%J)OA$6(LWnbi`YMA?q!0%y_W<-B~u1@=g9E!(5}W}
zy?*Hb45F|N=0~L?e6=M5sT1-@ZxLgg@G|iG<MU;su}INA%;nYt=)zClo-@$gEGGQP
zN!}t8UbQ;~t92I12OikMw4`o`ep*XoH9jR3T+!i7I-`OhxXe7?KD;BLHP#JE*YHM{
z@UuvXfFA0ZplA`Kx|=AFqUX@UF>bGm^Rt{Pbs!{RJqoyJv6j7%I_=)%X|eqzITYL;
zc0J`bxmJDEaQPuWO8zujvG91WJfgQ^*8-3ZG)BpfjlsUlR~RGLZLK-%jDg#~5rQY(
znh!o5b6EuS59>Y;BHm&rW=05peR2LO0wFDV4_XKoN{L{~f!0Xa$<{8Y{5ciQ;@_pp
zCTL*`AbvPZEpSd6i8K1*5VA{04fFc*>N@UY_GOAh7VpPbe2l-c`E-3^UP!Y67eIua
zXB~1Go3B=~Ig|+D%I48edWYp1Ehg3naxWFG>3?|6uy+sIAV&Q*i`J@BnpSOv1#2`T
zV|vNKUpsg6GL|^1{;0@ySEIE2p?_=xqwnI|e)K<h)9W`IO)$8*IDmpR7PY_D`iXuY
z#RS`~Q8FsbP!6eM)eqrdz5Q%OLPe>s$gzI3HZc3aNjD3Ce~KS-;Cor_o2&~e&aGe<
z@Sbrik_XMC3>m#1`|(e5((IRb5nS)Zi)zDTL;lB}pLrbQ!65E1WZWqQk;WEzR!h`&
zhZw0Dr1GFWQtoO7;__l8-lU3Ke&23bVcaQ?6s^$ycRpe2NtZv~(o2$_?@hd6ZfKZf
z+J+2Sx;9$Kb#MvBNNDnj2+X51-CXAGiKw^b5x-!0!OVF&{Rvq~81uEL+4kwpPmg<F
zJl+}-_&Cta`F_X_&8k>h1L0FBY|VtJFfQsVlvR+AvB=k6ozI_|50!(Gba{l(yFu|)
z1z1!e$*VI}niSk?_GH&Z?l~5HyS8;V&8z3+a7*+D+GIi<3XsZMq+M6qaLe7Xu^N6P
zg{FpvKWExrl1``FO<y)t2HOIdo3nH=Lv|6Ft5I@I<?Yujt9?a6_N(giIL@yO!|v)%
z-&yq6Nn66k8|Q6_z_OlH-UJ$%c4mCnzn|YQvbkgT;R_S7L)B%7yYBhCLfxS3Y>+4j
zX2a19ri2*ie~>AmiIHyC2|PQP6e?#cfP9c>d^Om1=<$5`*cc{^<|rq==kX0vJzQOZ
zSsYt$nn_=bo}8`~JTF#^wDN=B4Flyf@wvfxF9TT24^e8=Mcj=ehe}|%G$K<LD~mi2
zt#ci{ZV%nxp0_ju`}p9(uG(0W1o34x<$e-R`Q%mFDNF(Aw{V^|r;E**0TYsNbEU8+
z4NhOQgFrA`v`u@non-=ge}b2ID`EzW`#xS1z&D!#3f<MZN5fZ=u^~IHX*-M!G0Z*!
zYiguYTlgg5AHhEF#qMp_m5_6awB=`R=Ua2fn_JPUj*5)t_VJxhC4e2l7=)_z>)Y&C
z`mciw7jsx{^utXcYP8r-OkVx19-ssPRO(_kc;pj<fVBGp%jk#vr)2C>nsoaTPXC8!
z+VI4T_gS9Au64jlQi)EV<IojzZ2Rb1#dl|Y-UY+xQ=QI;uZdLQZ?v$^Cu8TR-UJ=f
zRSJ#S=(OWL7VlcX&y9k#de_?%{S@C!_-o<fyLqeto2bz9Iqjl0?-Fse+)`L;8BK5Y
zYWh}E#^1vlb$s*9^gE$K#*1kSWXo6ps5dU{#kxZqYwHXHA04(ER9v|A?Z&zxHG)Hg
zBJ;0Ws9Vc%OvLg*yyTX{O<_=46)OW4GYVMAZGF2Oo`+BLICgWxsMc(k3gjN1t?53D
z&j)<nHz^S2P<+VJrTw*f^J_kN{MC!5J{ylf9yS*Zp}jjI+x)xtF89D{V)sT$K1d3q
z7tfE_nd|SjB;WhM^D5Md)pbl8^^2IqlDk+yvr%!vD`FW9g2uGjJxPJHAhc#pmE0_K
z<y)V;+++6oN!-pMyyXZoPPabHd7cU=kyIXp+3O<~XUuJ0f>mnq1O!UMJW#{c+!>r&
z|Nh$H6D<^6Y^R(-04F`iL4J*(%^zFltWT{c_!he+3IezN{NPe_+!R&w?|6*R{JVN+
z!=ooWNjRL+z$GPbyqmp<!qf*>L}z$Z%C?5zE}gc(YsJ*Ax`W1bPRj*^?;r&tH!>d0
z*mu{E+K%HtdF`A5KMN%f)ig24=epNeyaX<ZE=seQi37nV+5ap6`3jsD&mN8Yl@|qO
z6TdCry1Ou8WH*sKmI^L%%>{oHybz1~H}6U6LwwDVxxYokktO}YVyGIxLmlxP6q6qR
zNx{~;{p>IzChK3R2dE)?cimy;2CIZ+I43*m`Ah{<43uQF6q*8{bBOM`P=1hVU)~LK
z;2wyr)ToWvA0jV_HeP67EG+iS2xYM?<w5`aObMql!mn_OfzoOrxyBtBmr4k}WnA1W
zq$`bz)azw|uugBZJ6fCkEf|asJamkod601Dy`b*&r#?l3*X(_mIUC_Jj_?+);KP0l
zRC2!3E%*6%+`&}&51h^Pva1aS5J3Uf*cX;3p%17eDLW>;INm?=A3}Bs{i{$Ve7^Qz
zN_vf^x=^ysE~oY6reZowrm;K`HvfUHl=SQpX6p&R&fMdo{qN%YqqU?U!5x}{YVI06
z_=nDl)P;ko&!%rVv4_Flj}r0UciN0U!?`4<UL73=GK;re9bu3oc*W^@{S>7c*{L2@
z`Rb;@-VjrFnOM<w^6YRe&Gt<d4}!R~iK1W}`N3bm7Z=oXXQ}vghL?)(rncnQ4wBUS
zqf`m@Vae%0+kolM=9@c3**~cE|CwIG4D5*Q!#4y#oJ1cj_&l9KHj7Rw8N<Y#f;N8b
zHUH+uMYAMOV38*Sn5;a$o*W%|e1;fBk;cDB*WUx_9z|IJ4s(tC<vlRuT;poscAH|z
z)BO0UmBGPHjN|vpkRjEacpUB0j_R4n=|fQaivn~dKg-DAZrTkK{qv=y#xD2y1yoh_
zXp=~BOZH+tTNMi)r26TGC>lTn{_!Fs-f#J5{kG>%-XjgbDoc&|Zyhi=qo?HnB6K}#
zld~KGCWi5w@md7SSBOwHc6)hxvOATs=Muhe(<+H{JF^*plb9B|8`so-TYPU#8orSX
z5Z6*K5?Qw;F_G^4zvAyMn4u8#)KU^pAm!Z@7tY-KXY!qUR_IJpk*eF>_kQt`BLYdN
zro3U749TSG5jTCf$0K{oXx{otbv#m<Px=_JB388WDV}30hha=h7cMDaG4vm=@59s$
ztM9bm6d<;0Ck0Pgpbay(!~8(oZKvCz9Jr6sybk&5n1IwCQ+?IJ^Oba$DMO*0fdJ$Z
zWdPR^b>>n>4%`Z@b_2xT<#Pide9V1TCb<JC2w*3#l`&^FAKWM381~>EwwoY73ajH=
ze}o2=094p=*K0Kg9$61FwVRe9h3$$vJ?%e~4_%L$aZFNc>g?Yyi<(qEZW%`YiQ=l_
z+G&hFSb|9UZx0B<0=c=Goix>)Om|)vYX@oaN?b;T3JVX4REkqRn){WGs)VGLoAszz
zR}FBs5U6$fB{8SX1CXxIH?9A<mm2-mYd9Df?$Hma*qm_xb5cM5ed=pZ-D{5y@OLUE
z=gnW1oQnG+;K%n7_SX&Ux3m<PX}%`=3g%u-b33%#bl~%Nl<2JdGGuQuBzD;lQ4R^f
zb)wZ26A0_gdqKP_ljWo{Y5AdCK&uD{Z8I)$b<9G!VKF*&cabF!W2W5=tmMGM@6La*
zwoK9`2h!imsXqIIA_<L}aL;49hM(o@US5d1%;WsV27vLox%St%JD+GWP21eYI;O*~
z)nq`z!LD~lqa*iNTzl5A2j}b#VZea|-_47OkSZF}+8-;p2&T8*#_s12+WK#R$|$ie
z?_Se(UI^aVEB+?1CaGV-<EXrm8<7{0s>eL8ZtIOmb)U=0ORV^JHxw(iyg6O{<?C>k
zVw!G-tga}ghV<;4G;UaFPiOb)aQ4f;C2zu*emoEu^CPu96nu2s7MGN*;Ojj-_h3kM
zgG`|Vb~oZ~4~=Zo#05U01n`bGMZP6mdvG1WZ`yq`e*3{HVI_llNBjfuQVW(VzZ6+C
z^(JuU@;G-G+MJA|>Mz!jUt#B)P5}$S>+EbRg&EHshR+@Nxs;CD;}68dRY5IM7eX<t
zscSA0TDhKSxcmksZ!w?425F9*h|(ZExg|(y{IF^{En2!Wkno!5iy!Y>GtoHtW$4*N
zFl%e+4xD=nZ_<1~U~!bc^@YsunH(~ECKt5$?$+~Y^%*w|{eFIHL;sRA*xL!eGVL64
zAzDv0poNO0!xlkRNDA1;=TFI9+L`wL*G6FwaM<8-9;-{l-Tppw|EMR_**=taZbj=x
zJzEPWqs_X4qh?PnLLtINF!Flk7L8NJtztv48ZDesRlw${7WVi7n4}I1^Sc-OB|ORr
zzdx0;)~<GOp7Ax&R`P9mw)GrO(4hqdQPpC@NHvTIQko=PEHNQ_i`qLG743E+H&RS(
zzM4#})Xf^<bt+fq?l4LC$U}=mAC_P<1TFvC^ENfODg$DGzn<!baV)4%6)eK=#;}gh
zj~0IU{yiA4RxY@Mc0o>?&!wbyTBbWqQfR=xrh%H*Oo=QHv@P;3N(!I%du;@&{9u&_
zF9;i|BP`FKjv#kJ7DYAw9!%QShYoqf#sfILhLj5NOD3p=3;X^DhGW9NSxqVbnni1c
zV?VpMuBpL&{(*{zG2i;gl$xH<Tv%8bdfX{xr^g0djD-qtpZ~~}Hw7v8s-`RVH-gXb
zQDt<l)nzsF5u)uP7dJN&3DhvQ!NUn>8Y~CS7T;(Xr5nsAu*{lf82;&+Z{20(q`fM^
zUM17PeYug4-z70E+_Z2ZgWb6LA-qr*^!vUFEP9X$MPwJ{lW1*8^0?8)HPm{v&`%5B
zW7xTP8E%t8D9msk-1rol@#T*DuOMW#;^O;mlM1W8%X?Hr(+KLzyM}3M85i8Oq8n?y
zpitA1nLT{6!S!;VU^-!eh*-xlA?We@J1`Y<C=t&ro=zf)XPh;pEt)q2nk*(kK*Mzb
z91X&qQ10WJjJmUMy3?M+gCy-*Ty3niJsqSyByh#<`8Ay*p{u5BlvppiUR7}FdFef>
z^Sg_oolez@3l~Va+e@g5{FR*Jupwwn)~f+MxFv5C(@syhq8;Q#d>OZNTx_+`I@s=x
z-MjzP30DpnSNnFPZ60;y+FCn7iZA|p@hNR`Cm4>PO-6}&dr}_7cN#-=(xnA*Ou-5C
zA3TE#3w4o;Jo{d4#zyotq@jDAnAAl!sWwKTx%1PVVW}SAp6AwaON3HL=2(SPmQW+h
zl|=11dPJHMJh-82O|0lDe<aHYC0Kc(n*lT<%Q)eA^N9o{UoxQMGbi`{>}$?#P404~
zDwf>1ORi0yLvtGI_JLf5A&g3U*|gX4WcpbZ)(I#*?(tF`adAu-Se}w#+gKqa#14y;
zPyH}(gaCJ7@eVD#zqNl;yfo%k$jt~~do$0J``yV?oG}WLCTT0-N-S3}er&#WE-D84
zfn*s;Teb{Y2gRaie8k};7%I_;C_W$YFp)O)W#J-9gHk0EvFuC%gRlEqSqAFwpU*NA
z44yTb+-%cA+eqje04XO;*LbQS-w?o-iQ+R05Iy&ZEs@VA`&QA-fn)w!zCQ`9p9Jdm
zX+J&}FbJSTQQQmDWB;B8c#nl&_91P~Elo3p?D_v960ekS(0GWRlvWAWI>M}a%UZ{F
za$$pklzi+D?&?k%byeL26d0z++_8bdlEERgN!vld06^IIexz|o#(GXMOy08V)ny>a
z?<^8p_Z9tryt#Ztv!6jE*3GBXX?ZtE>Rogndra%R8nG9^y=<ws0G40K-?tj?_tk_e
z)6N+~bJwVeNP<vX`8i3@OMou|R(*0wPvH;0kO1&PVe7LLaGn*oz#OtS)}TbFoPFN>
zIwh!ivr4=1;q%x)G2}6f^f&!RcwOhqwOpE+75A<JO}@g9%?<1*Uq3%tRM~^CVv67r
zToL_;>=osM$=3nH+vm2AC{<CIST>Lt=njuOJ6M$sJy%~CVu|F!_FS54@L7QnsTr;&
zt7cKty(hPKm#Ar9xke#DoSCi8S?A`p0WO;kNssO=)#wKCYpz+ay)xMTwf0KIUN;|3
z=#Ho)Xm%PXU#B9jTDXIXS%Wt2s(EDCIVzgalOh6UZ$8ndc{hj{u~J=VD|=gxQo!#h
z;5U^-lHr*Ge3pO#Romqb)$?7Zs80E>N~Vm~%>nF};TT@!Na;6U!8nYWY7Zv(q4kTS
zy8PfuuM0-fOSl$CQ3!n2ZjA}6Zx3qc?5I#aUR&7NEip#RCPIv=ZQpjeJh+t8mDL1D
z<BXr?3JSiZToEL-H9N3)+BcjfPSyy~_c^!E5t;)imI(#F^Fu1yLhYZ}u3NvgN(NaV
zYqry@1JWxY=ZE#}Uyl}%wgbb|syTc&J_8DM(}YCt>uC}m4ol{Pi)WJUc;%fHjv+YL
za77k_QtR<vunN1tNUABgbQ&|>8`q<lwvF<*HuahEp95d;I?SJgFU=Zl2LecP7FH%;
z;DS?q`;{-dIS?e=a^5n0F`1bOLVTp>4g<N)U-<6%=T%5%oW;DgK+dr;_|vTpYgq#a
z6}>XlU&UJvep%*WFu!=IeGmVPMQ4Q_PCM)lh8@idZR;|2uo#KI*J)qlFxk{un~Wzl
zh1+@)OF-)(o;{M&7Q*)~-)GYlNa(7$8+_9DWMqv}>!EJ{3}wO%ACT(CQ#w>KfL?S0
z87NRbKw5DEq$-w?pPK0qqQ4eE3qmiXtFWb$>e|{gnL`PELLU9%^=ywHaK>@VKLL2P
z{oE2q!H6N7qwV><H`tHgYUD;PL1lTdHqMd+clP#~x(l~hNIo!CPV>Vatv-jY8DQa4
z&!M;D{7ks1>K_fe<6gt3aaJZ8ZURc^(=V(QB_^Vtf#Bqd!Bhj|1Bq&IExX}NTik)O
zUP&CIjO2w&wzV;M|2}2=zyq14)Ww75BscxeFk);ua5>1MW%s*7`fqL0>O2Lb9QKZu
zt%4s#Hf~Z)9$&_bhy#=cD$<AtT#LOFVaEcw+1uLAs(;^la#nu0eGq9sTX=mapDZ-{
zO+N(Dp)3%#bnqg``Afv?p&CcdLKoh0fVFp!K*5wu3Fx7dQBYFugs#lH)-xHF-19pr
z)^+riAA7wJdt9UJSXUs5;uZ@agyRj_d@LiB`_Py!Tp`W2{WnJxX$F$UbDq&9=?6tv
z<n7;=5qO8%HuJI`FMkVv!u{9QI#ca3Y7?IyGWoPN8TFqY0Y5lD?PbCVjr<jaz77nn
zVj4W}v<)Wen@|;+N4bfitOMs$lutLS^Il#2(WkpbwGIOx1Kj<(r{4C#4i#5;L)GQZ
zp8w{sID!#kbJhomjSKXwC;$=pm^5=UkcsZz`VH>^8$Qub5Z8QtR3=+EBVMAK6e<Q3
zJx1|Urli2F7F8t>_J`UX5IbXNuae`CO0;LSI?}UWpEcko5g7TqC(u9!=w9q!RNy<(
zH%6WuZmKvu2Z^ho;@gzJb(21HROI047{A?XT=!JWa1sLf2gJ73mFP6zGj19u@bmg>
zOV<1@uReWp3TPR7KLNX0APAHVdQ7q+AXeg9RpD2F&u_DyNkA%?;B=VQPWl9obL@F5
zp7sahhr=gjA$Eju<@+@&PmDjl=}J-@$iME^EpXiuEd52hUw>caGJL{=X1N(ovwvkr
z9o0Ep*WilBb=btBFBSa>s%T)E8(oN<Ky9^NDdHJh=L)YW^G%*iC`P3rn{~GQdGwN3
zO0QBTK;#7EW~DT%jJpkY`q7G|;9?_zQa8#3lNh%n)+-8r#g$?~Y1pYB-i!Cp2k4KT
zHm&<As`JgM6aD7(&#eh+TjOR*m3yArqGQUoZ3M1gy?66;Iu}3nL{T~%4qjw<o!#7W
zDRn=0N3I9VBx`CseF3hUG#wQ`)U2upmK#qL<R&<|<VjXL#;<{kf^{Lf^G;%`E;KV>
z#x2-K+`KB%v+6bC*N%Hd>-WPM?SVqJrMHUPcFL3gzB4LbR~+rTt8_RrfB#m&l5G#G
zZW1zaJzx_&{_vy?W|K$eyTFLe36|?KQ-5}QwfsfMKcXt3xw!?13p#8B=eth74q8U+
zn-BTa9Il=QwX38*mAa7=t!dbB9XEW{<PT;7JcwWF?Dlhvd+5D(jr%p>@57e?NArPn
zAO4m14~4jT4qm-P@X?nz00}YQ^=;-Czi7%ldna=t5zHWiV39fo`ynF1l(?qi?=q6P
z%EzD?ciy1*2o*)p^M}q9ho`QTivRrL60S9fpzBiGUn$pAJ@)2pMbIgJu%z%w1xz^}
zN9i~AaVP5Tw%Jdg(de;>ddp8`<KCbp_dQ)jOdy2t{0B_RG8OdL=s?14QXz%#)vGfv
zIqoiI)|xGUYb1+)mxhJzUaYlgvYcnW9auLVbhkQRAzWQ()`nBH(FU}PZAlq9fp7q$
zWsD+Ujq-839Yfv(H4(NVx`-s%n?Ok$^dH_knu4G8BUfbKt9P<vf0itJk@q<)=2eT8
zmyW9YRm<Cw&A8_$l+zLNRJHWZqlP4^veOr!Fz5G&1a3&pA>oNr6|K{U$N7(5mwe9(
zsXe%uFVjk8X+z6^NN#&Mf@fGuVG!qjDZAZOwUGdjj>}Hp19#b_qBUgT#puii$6Hqi
znVO;-d}FX&YNF%`iANS${rQ2o9<*3o6?>t>NTl|Vi?nWV{V>6TnwGRcFrLS(gpF8~
zEBRt`de}iGP`!&|8QEeVDfg_YUp%Nzrn3{tcG8m?0-y>$U%orvKa6KYfbjv(#1@1g
z>d1fLFC7wwZqcZ~&TEdD_$0nST-#8L_@+k4oi&OCH7LHK{hnl<@2+p1#3N`!fVD8f
zUlr|$QI>TutS)mOB~Xw?``;t($}OI7ggUFpA5A^L#PbH>&@GgDVTfm2IYHomFK58X
zXsw9)$7QYT(VB0y12>c7Ic{HFOEAx{e-One5+t}MG>CL7L&n7O^F_?dzU~daWgwuY
z_<n~Xx7mt-=iH$Rt#L~H@A?CNYoW+uO2@^^XQRLD$a={mnC<@Q=(_qpOe&0HdzXF(
zPGKQGchN;5_TrLbG~!lr7-_c$yzk)nKp5>4F?~4eHC#9IOmug9<kMWsdJQfy!gGun
zrH`_%)@DB0Z2~N6h*Qa3HIa?46!Ctf`gqYfVP6(c)c?x@(EP~>1_dyS(&LJ7Rc>$S
z;`{G1%6v+Ko3ml#B_Abj-?Xk9yrnGbD3Nh&e7DY5jcdbLz;5{w>>_2<WzDv8vqufI
zQ<YC~f?ATIAG}tq1q|c$c%`fRBH)<z#~eGa-+=dhP`CX-KtS5QE-8gLbS?g;My?nw
zkP);YF)1dr)MIw>sb{-ecIPWv<9h)_*37)6C#vNx@csO$HvIXqn+>p>7R-3sVQ_i(
z1&@B{KL25v?U|Ms<u7w^P~dV`5=1;`HCN&xc*7XqEN1e~a@DhLI?A(otL|$v=byG%
ziLkP7KemcJW_7xSF3SA{M#$ey_ZaAk%;}F->#@Fbs{#_>(qG*MJZJXXx!3H#LCX+&
zWjX&>mKccs>{?AN$$Sk&c}-t}B`H+uFo(_w3g9atIJ!&oXo=~^l;7*O4TPu?$1s_w
zZ`XP+cz#?wHgLnwt@e3&csMmIhrhn~Ts^dGNuAR-w0vO|E^%=)N8&=lhx!9S6J7>*
zSh_SjQMw<EMaqyA1f=}OzDyT;RpYW|ix<7D@Vk8~ke4-wrdEm8*0HD2m5=W-8BjH)
zzk0tK;e((*m=D}<{l?O;MAo@<+HqO{Zv6p@`8P;|HC!q#Y8qL}Iw->&Gw^a#8nQ5W
z_nYs<x7?Sfo{RTgzMtZY29Y0LvILE3=N8kUd=Np6x~5j|wgxdIP%f(k?0djep<>2N
zO~iXvsk-%m>;JeO{jQesO+|f;dDd_Hu(u=L2jNGFBjrnNI3qCT_k%F=Cj}^b8TvmZ
zXZ|OiGo{=QqH*zDl$BwUc(TKoanW$Xws5KqzsouzqgaUr<L8gn2g#X-{$tSlp7VY6
z(c+6U>KxWe0mZ`LTb4gZ(!~e;9LCOfBvuG^6D+xMy5jAbh3}VogpTbpVW)T<IpKeQ
zFqQnMjI+8DY#S@u^=9Q}cM&I|-1rd>NTVy~MG604ySoiVRtCgX6=cw?Lsfb_fzsrl
zKHe0{J(Z!1MK^Q~*Ic0~1Fa>3{5vq*^-Tse`Ly%L4|5A*g9Vj8WR+${wKslp@92&4
zI`4jlt-R99Fn^O>)kJyg8TNxI(8r&#rq!GScplm*(#UN2;=D4_s<M@vcBh#(o;t15
z$@o%0j>saW?B4MdxRc)Q^VR2T4_*xpmKp9=IKEOzspOW^jo({mpvBrc-|1!!wA1vk
zzs*V#;_P~KmFA`Zx`sBlFbX6pu<u*+f->aBa!-<jIml}|SUbC&7HQktX8B?3b2v16
zGs&0LD)KPZwrY;9JQsLEQ^EaNv8w0#cE<Yb>9#%OuB(K@EQjD?t$Ww6&m!^nh1EOm
zXYxD&-vjyO4ukF5hY^`>Pb)YFee>Mxb}s+?Y(0zCVyXIR!{R-C#VACsc;}6re{aRY
z@fgAzEW3Q`%TAKp)jJt<>4i%+exqumRZsgXFJJSzR&dBuAnuKm%z&&?sEyyI{u6Uc
zs|5>As89K@OSrxHuX$!Dp6JWraVLl2jOj|=V9P-J@$Zb=GfJzmT<vz6L=on$+w18i
z3x8N2EVfN=b@=d4<=y=)w{9!J-;H)@N_sUGIw(3Fx50Y|olVh=Q}D6Vch0Fsd$6=e
ztE>K_!0w4`CMcokjtHYgDv15W(Tx6j$K*hjxhs8Ie7e~bUOlM*O79Ik5MOKp^4q*V
z@qBw^9f@J+k2rmDsO85nTa>Fhtm=a9vn>Fw6B%aB0EC9eP^P@ce3L&tUBsnumg4!B
z4+WAs^oMnXXw#nFvD=Dms1fjRvsCB59(CU!;u(QM1Qivf#EORb=zNe7x&40}P+|1X
zRKBiXiTr%9TYA)y*O7!5Uno&o4k9tN07o5r850+a<)d`lww)LDur@<4Uj)C$-+<n9
z=}(erB^RLSZIndUZV%LMr}fDBKMy2ZZ2K;ADQfZ<Fv4=UZT~W{2le9ANyK==4~>kM
z)RR{R?h`5Q7l%Q6izqVQ(hQ#hGa<al+9J%~t`685T+(B=VbPf~0Sm?@X1&-)U4Mi^
z{%R5MILWvz9nBM9Rui=AV9y>0!*oVID1HhB_WcZsOEQn69v&`_wf0q4gp{j{b*ra)
zFPXY|?xJO%v)z|S(mzq?NdI|qguDo>TT8Y4ZN7|P{WwE;<wu><MbBk5%-2_=`5yQ7
zrP@a*-(!EPBOUkhLZ+z`$pTfU87N5JspI0Sfd-&bZc)Df(L*Qmy3W1l#}mxJNLM!9
zC2BEqoUBD!(6Z~#HcT0}&u-7|V(@wvCGO4Xyfdh#JMLp!=hQDXKIJH79-f}I8`=Gx
z=x5ohj?=pmgM9-&YYaPzg%Cd*q%Zx|Xpp~P1IGM$zW-~Xw}M+CCq{)q%gd7MMS?IC
z!_+FIX4HV!SioSYCAxw99w&iZF7{lj=yVhh?(`%1LOkA+d}MqdYe4-_%df<Y%)q{)
z`bP?T?ZtEkOQBJ#zAU)YBSO~2NoB+|odXXbu~|JDz(o69N_R?7W^l7DZr0v@$#DD)
zL`Min|G{xcQB07`d8y@P#%MKhCwDuILVff6Bzyc_y1@jyoKssU%LoruX`u<13hK}X
z!}C+$Bv$dq%admph^v1nNQ6ATiq3ob@@s6KWj}@sD>kkWZuM{{4fjMashEw{Bu#8!
z+4)D#SpXsoLA1XGr2!qO^Z2ukiJ-xBaH{j|<{cY@cj>oXq+i-TSA%1bXB~qNd4FxG
zW{g&o<(u~KSKNM9P=kKSVW3Nyfv!|57Y+iZY7zwiN$Mvwbqo^P*DeERWffJkZbyo!
zVcT`qf4|CK#(q(%e|4bX3MfY9ba5raMfiD^i|>#jUb}@#mVm)31%L+yOn~7|rB5oM
z26ci~;#8=19~{Ld_4@5Y;yE|T%PLKO`9;8`)6hA~O>8ubMl1K%v**J4&!F!u5D#_6
z(Eh0?ANfl902uDZJ=Dc&lD_k#)eDB^zolgaYwENo3q<Yjg{0%l0W<&1{|b0~X!rnI
z5_(2RP~KOJ<U{j;-l6(s?MiE6idIiSmxxTNB<}!n2&#Ib%=ES}MUrEpbkwhlMcyD(
zR<ClW`;JORe7{vsc5GC&F0tc7*>rTU03QF?>()pg<2M8LaL8Y4@OV!VJ8G4}fSeu-
z*DeR}*G9q`2tP!pcY9#NzXvmV$lUr?(N4q*@6q+>KNu4vvK-?4LZI@F;+^5ePwPho
zd%jtD3=i*t{jY)ku4K^0CITb9AIZST(tw#rj=K1-GYDtn<RdyU-_$oHe({@w|83pM
z{Bi_!%>6G*sgY|27SzVp@D;Dp0*vkblI=>1g!a?z=H<*2IdwjzQ>5ylS-^PbqGK!K
z-JP@MuZUo69QZlZPk!xk04%2l)Fj1nsT7$2HvwOnN#ZyyPDRZSB2uF$`lVT=r~_`j
z?x7?RqOG#4!MTtr+u4P=uR@N|s)4f2_`s!VYA6I+%mU<s{QQONM*2cPrL5sKwD9$V
zBOYjs`>ub^r7sHKj{{d9g!LB<;P|bec%a(WwF!2+ZuHT|1EvX84Y&}f3NnsR8T}!y
zsw_%Q4od`Y8jlEpYIlmR3skDOWY#)~{3BT<#W)N*UXE?=*gr~f&8-lE7N-I!^KLh#
zm`%YOb(s5n91p@k!~-Mb19NRY(1cK~`>{xR=_1pAC6$)@EmFAD6kK-({B@A`j^fFA
zmSShXH(`1FU}#Jmt3W$4b35drZs*NG&E!90+j6&zPG8~^E}Z;JOb&01B&$py05Ea>
zN<VjUe4{_@MQao34UX(pc`wXI>))1mMou0Gm8qdcHF6y_0bE+z*|JU8BYBBRfcPl+
zaiI|PIrH>ndULfn($C=+i)&c;g>@hMJ#E@pT>d%pzn{HRfBoY;PZ7*9USz0x-7P!#
zce;Z$=&-$$c`AaMNmh&7?-}mRJ-lJ%Zs2EqPG44joDisSt%%`XB`>xH2Jg^;gAj4;
zKA|kcSJxXbD~yvJB<ckrh8$TnkBIU(|CN_T9ZFDUzM|N7d4rPHvK<fxYw7kAF}GV_
z+XT3JGO8q{sO6mi-?}p9{`<4MwRJvBVQuY+^sPmtbkdS&K<{0g00f0>l`v1On3S$N
z;LhLEqqY-<e2go&QK|dqA6v|Jy6HKEPXe4e6{scol!5G_z5UU%O+d@ABoM&Sk6p#s
z4BZ6Pkkr<wwr(=H72_5i>Ly-DMsWYI+n#Iuwz-JBIQ#Ou{h4^eH$DW0oBAgox-=2~
z^9-<KrlEt^oX;((JGV<6QTtLR7=kHHfCV257f~!LNkh99$PU?-f5fq%pCK!5g6_4Z
z(PQHEX~dfjrZI6cu=Hx8PKbqJK(Dm-0u#0nlKCkcAdNp8TjVcn-jp2i7s}j&(L_K>
zHNZ_OZJA+N7`Pd5WgSC&Yq`25B$&k#qqoE$QzZVLtJ1qCM*KX@wYgjM8P|7h8blRf
zq>b%9P8+UYmDI?Cmu_T4f2M-6X<(h8T|3m+o@4)yaA@WS9>%UrR5*Z9Iog!8^kSF|
z=>GV)qN2@q10VZmuk6nc#&&*y@iH8)rmP9iI<2rEb92cGhF%PqMik{$+sX7%@<SZi
z!jD?WS>Az7=+K0#=Y$-l)qb|4<5F?#Z<cXcWAbVjB1TXe=o{Znt~FvYxTpVL^_Km}
z^_I%kC%guH<G`ze7c_9+YFN+2qaZKBImHGLs_lNLMRWcH%HPGxZ{WpZAP%Y}eLV%m
za3cB}qLB^(H>E_-uD-uEG1jbr06At!lj?&Qi|+8|i8^@~B{i33<cqE_;fJT9TIeqQ
z_$|Z!K9UbLWcl(VO;8MFn^-FZD|Fbf)Y^baPF0mS$E#@MUgbA1Jp~n<@!89JTR^GK
z50l~ZJJfKxNEsODSFC@N&)aAw8P`7iNQ1&--c%V~{nYnrHseNO!Ro)pYr>9{HTrE6
zU-GbdA9r~uuvqDR6>A2kRcW~7ga!DKMcyuBgyGY)6codyrog|qZ4u`53Qt)~1-D-h
zK4PvXp_8Cmy!Q7p%SoR|Hm{dyPdWKnxbn~F-}%s$w}5e{c=?KM>Kls{!)9oZ#g8P4
zp!jKZC83<4JXeO5<*!DEEi9FwZ<JzfBsFnFxiyBu@8=FwE%zpx-^a6;!%$+4PP#)e
z<Z!dNq(sETyzkG$41B1V=1>m*FuKS9{PzS%x?^AmiVHiZWA1mi%>0tFZj-ZcJ)6mD
zEZ`+ZOCxu_&Q`S!-^rAPrMqqn(#=*%kH327jc5IQ0KLyWC_RsY5x<L}3QyB@Gev=J
z`9NbfK-nBr#p1m-*|%w{GN<seeo@^9o3;|{m{aJAG2M)9Q`oOBMGr7<c*ee}u|~N@
zw(W;-WwYMF>gRUf=4|m1m)p<;ZGHXgAC(Ftu`wYQUo3`wez86@Ghlu*q>W`3SOQ<R
zMNAjm7mQi#ANTznb5#J>n=bI6OrJiC!$bV}N66IGde@P^tZQ+I=`V91A#)8B#vz)y
zPU;bl`}K1_ftT)LMFZ)`KlHllg*hs$Bb+jv4Y_+7pG^wl3%f*oCz1EgQi_$q)pKXH
z!OyJ$pMR9FKA8UJD-K}wS6p^V?SI(T5;GSK%PoriIkP;pW&Ms_22i%{+CQ?%P~4;b
z_EQtSz=aB+kTwSi_=A7z9OS)wpFR7AUch@uew}6wgm-BRO0ga}dT}^&6%kr#ITFwz
zU}C!`8*i$d$U5@n{VSs?0X`$W&mZ~-{l8T#5Gdr2_a&TygEX~k>as`w$v%$RA3iMc
za`$lai+JKRML}P{Qy~xQDt5R=)=kBMuEae`;-en&Aixf8zS{XuTk}ixvF~u>QH~R~
z2%&a8ijUQL+b42P4Sw2wKZT!wv#<9@EGA)kp(N-ug(ancfixZ8WDjO!re6y+5Xb=o
zQkvl)pK4pu`Dn%TXQY*g#&?X0w8GgN^>^PI!k5K$w1WN)JU@{OyX1mqYf0m}$Q*jT
zGVEefL;ApnVVsJLNwqz);pK6y$6R8ONI;o@NM|ev+9E;HY%RvTTU`rqR*VNH9NW;2
zl<Sp2ewN0u;AcPk`oF)mU4L@xO_a!|$JFTaOj?a+=6r9Y6bvk{cJ+Z9$Y5%U9JAUs
z@_hn+7`I6F%CwA>O$Bld;RT@qTz-&{7bp21WX9lg+~Eyc3{irGE|oFPq{OKfL6oQ|
zSKhb>Nfs?Hu_id?GlPTuur4tPk7!m$(NYiJ<3m#44{Cylg(V+O#}-L)wg*-zz^4*J
zl}6%nl|Y2;vx^qCaC(>vtHqD^9PKmGJ!dAAcKO3D3#ReA4{3<WyrGbtD$Md~4pJXm
zL_Ix<o*p8hD??eluTmvjB6Yx5?>^5AyaRR}eb&Bzc;6n{aJdBH_Ad%-on*>R&9L_A
z_au$fb7AR;km&=Q7|BXxbjC0?r|VwKuWSnvj&Hw2VXa8K5^#-LG&cR?a<UsA&Wg@?
zb1xOu7h3-*M|O)4TeUCJprc>+sg%&4PZ5ADQ2E7=OLL^fNrv%^b{EfH>5^e@IKfa4
z^Kks;n+cD?RCM*<{T4M5`Zw2B^Eeo>;*?|Str3!`ko;Ki7J0Gp$uMaI6()yUeWs$1
zMZeQbkff>-rw({sBc=kRMT)}nn_60$#m(bZA9Np&1^uJMGRSY!U?qv?Zl<*pibz^1
z<5qAbH@oxJUj^=4&Xh{KmP1^APp<I(TMBF5epai|pOg22^4Hs&=u%UF$GFnwm{zco
zoMG-7Crmbz-f8N4%g2KYVpJ=s$WYGD4ho?hL96QZS|q@)LhUH+<~lykNMOlHoV*gl
z+21c#>NA;-vq)CzMX~)|6_-uk4o9o2m;HVqWM(LD-JkQ@k#d0#{X`Q5*SCyVQ34?I
z26l;HzT9Gz4`r@smbN`}8lAWGvhSzI?65P5r;S#7EF0mFPyu)d2$yU}TXo$a1%8hM
zPQ`^DzDt2t`48NN3BYmW-Y%kUL5Fqb?Wv7)lIR(&t%xBRR!sOFYhU;FGlClYBP&*<
zDFzKjKbu?+N;VO|aB-1+q}(s%lEb_0h`ybX#2?1c=~ptPWVeOr{{y8pX|E14>aqN!
zLXFZh4O#p6<SE0S@l=SPJFvQq+V&n{ECYTbu1=??%a&td{03iG__X0$j0VA(F5o7{
zzCRo9>IyW8<B1W6S2T-%{a_(jpRpu-0SM<~mATKaNIh4xIM6N_5J(uN(MdLPzHi20
zx?>n@nB2b2M6C;H!m{xjP_uZ;bJsYB0si=~2h0(WC)#{|peJuC`K?jO!8Dr(qUai~
za0ngW)A^1zz^y#FkNS`gln-H%q$&+aXXGAHeHr|nyNE$v;i0*q9Qxro1+r?`O!O4$
zs>OuwFQVw-Wh&<#<`H^4%REoGm#ZQK{_|65t7a@ual4_Da{xegnnYY#d^oNRjpMv6
zIAb5pv;0PU0g3ORjvM1x?Ndh>hqN>%`GFsYklh7U0vKO5ER3Pt12%%TC+p-aEu&gh
z2D3Renved*Y$V$$aK?;1)Jy@ei_L*vzw;p@<YldT%(@sz4iUHr0Qg1X>E@`T&(b&M
z_FwO&R@bjLH~4j)@}cGa6aGbjB$g39$eTwSNz=3V%wo_v*<V;2rt0EEHzuK5Q?TTV
zyKH~eaj`8-ZJ!+3ymNZAIW%RvQt&BQHRRl7nLJW>!`;nIq@kypr+%Ja)+CFx?8L$4
z#z(^vlZfiuELv9}w_G8<TGHP?SYmuNc<nj*Us~6Gw_5CFr~nznyuIsn_+k%sG>Oqi
z{H2G#tqj<*_z3Y{;{9QF@OPrzoXPJVm^}s6*JXP9o)#)QO$WsH&C1=@$b0NXMx>zb
zhh+1Xps!{>uM|P-4(kz0Ssj~c9hgM}8qGF{2pGs=ySF|h_gsohJ>QC;8@AdL+*2OS
zQVPpu&*p!oQzcd6T)iE-_xP8HVNF%1w&nw}vmUoULh7cSxtQb275V-%-}RkUv6$z;
z-ach7*(lMc1(3~tf0m8n3J5RWC|#n2Ug77<Ao^-oyrt^Z!jcV!%<(@)b~T5-ckRfV
zFTHx?sRGys!8gQgb?kP?X7>bKNu!ew{{I$wuJlwC4agU)vQcu776$gIs?2)M-NUs&
z4J}9{2V;dLiXH>ke;M1g<lku0<>VJYsi?+-0aCi8jlarOZXZ^nPgJg)K7J6xnHe4w
zU5<`L^<L)_sB{^U#J{|~UKhuhKncecovVs~(`uex&B>n#TVdS42UdU<52<7zv3+2C
zNf&uM#gVA&TK@$SWc`*(5{#6%Zi?#%Un3WPJ8@rdcScqp*R1%Q^O<o1d_o&ONjbv)
zgS>}mJ-Bo9#|S4UU<YpZI#GCu%F#j2^Iy~1z7@Yywu}CCCm9#?VzK~i&7+N#omRgb
z`;0+O1ogydSx&$}4^LNZORE6GzPaT%C9)$W>%j3Hv4c-b;&|oV63la>l7dZH54zC=
zrliH1pdYI&_*VI>e3w7y@F(yIpxRom;_&@P$J)X=f2q23nYOdE#||n!bW63?N5aG(
zrjR+gfE|Hie9#y7wh6A0$;f?qkG~9GTlHS3`{=GXwMoyZZY=umBM^U?{n|P~j<<!B
z4iz!Vf_zK0Gd}9O9~A+)c>|Ot-jSJ!O6hz4=gD!mB!YR~yOZH{7<-$%W-FWAE2uEx
zDltseJhjcF=~ADTWCMW~rFhixd%)JagYpq7o>y4`Hpx!54QON9&kri{MJrl<$}^(c
z-6zWjOrdc+iYA{`{GjjSdrg%uuZoCK1|(YLmefF;Y~h=Kux6n*YVHfQ+T+RdVQ-FV
z3?7+YK_SUtdmu+QYVp5X$56_tXaWBjck?@lNo{fpbMN=yixZVuulCkN3G&%k?D<Mj
zkkx8%V&=9JpZL$f=~qlq?%xK|Z-1GlnhKn86Z+MvXtE@=%YoI(gGjXQ|D<_SY+3*O
zdbylHZXL0lE^r(?3cWeCj*%r5gpjsI^P`Qan3VSoMo%BBZX|^S@G0W46nnoOUs3oB
z(EgQy9=!J+cQ5L^m-Hjn0s&U-j##Xuc_$1q;~pFw41VSC1Y9+Z@uQ}{l2CKSAwnN$
zudPkFBjaSMy~5k!PmLSl(GWYwnt`FkxOz2nGX2yEbDeCf%^Y<vZxpO{9=!TU3rGe0
zsmH+`o7Cb12u{*CgT{43VKBJ0<zI!q)dpj68WS>?fd!v}Vj?ovn}D$6lh!`zw|L;L
zFL^l@A8~nhg(hP^n^#Yfdv4b&<IoK%;!V)Atv;4q6Btrcq-#yFg^9(L3EF^y&7-O|
zsR4D^K<IyE3<#2hazej_@}Ny^!~APPj|t(P4VO5?z+=TIrG53c@GO=}2Ig;@)KhEc
zs^&nsHR_N^yf(-OG6qX9RQ!TA><uZpe>z?W*)jj5qXp-s1c;+oDMoInzxBI1bOWCc
zT<ob{+z7(4MczS`qx*|e)hTiz#qOvUa$~Ru8E9kLiMn6fD=04oQ28D|K^KmbDG}@d
zNlsvUOjX)DG<z4lhLah@Q~Y)_gbWvB7gaBghhMGFszEofOg7{~4(2Bpvic;@A*-M3
zGMp{Z?Ux5tq>z6taw)|e477^Ki2#eF5;7R~;rQRBoJ9$IapPJ{TN!tos;g#keQ9nl
z5h`meq89vs`#=Q5HRaFZLk>Oshx(So!h~*H>0QzSu=m<|;ik6@_3&l)M~?xOlZ_j<
zT<i}wr@tca&ijppZ#pW$`U}RyQp$(_Ue&VJf?^Az-C!KOBx-9kCHywYj_~jP6TG37
z6LiDEK$xm=7-mW{c{I)tlff%?bjln!=QX+ix|}Velvv2Q@lT&TSvN9VlzWphSj&4}
zjQY@;E1~AEo&Cs|{;cVGZ|eOiCX}{<n6sA2e2~}JQ&nKL6x;Ne>>ODk$}3^;<EK{r
zB2$MH-XekKnJ5WpAlnB3`<5VZUuEV2IrNJwNYZ;_eL0k@`oB~JdA@p~Y1kvV-YN7p
zk3`KXV?JM&a<D&fe)g$?BT(u649|!Kz|D8uCn*D^Lh7p=I|cL!q)D|%`b&Khsp!gY
z@vh`prNCXBAGPmfehS%c6k6U*HF_;C#7h=Ieu#l|j_y$UYgV2Ic{2t;f_Yoqv#l*0
zvM4_mK0RenE1)B1wCjRe{*^aNkDa~Zu<4DW=UlePgmds49I)he2Q>+FSWxD=`-lDR
z5c<le<Mu%e#c%rx+unWIlHZ<5=^mJDIFXZQCfT2XU;&A3V}aZ(8mDJr*4jCdi#=ee
zH41T6i7N1F2*M)K_4v4eXVL-E^q&v}0QwwHE$ZoQ!wQXoLQSdipBmp_cXuC!dHn?^
z{K2&Q>5Hp6%ly1OS@qxX&k_KXZkj%#-vJc2wC=on0O*{#_nV1`0oEi4qJ~uU3U{Lb
z&c#16DgcaSOXReqc2i>~X<he#_4(RKo3b!dS{RT{8mCO?*twBRKG49EMWgE9<sW7;
zte0#^=Vzzx{r`>A-6GYkXNO#k9>IFO0RMdic)0zQ&ifq^1$sK%?r~V=^Vy=7_Cb0c
zz5PuIj{CKkh)JLGTdW54r;;R);3q&E9Ys<5KLM8rX!jOCk``PBSrR9pDNUUMuvrqI
zms@@)1=%vd`xjq)vDy@T$ZwE<RRT#Z0B<Lt%Phc3I01F}0MLWCKOm(ZB>*dcE-Jrn
z)vfxh<P(9AIA-dhl~(`SK8%kO&@>Uq<n0fh|9XT({ghdr-m7*80C;&K5Tqi{1}wP~
z(8WT~eVVjRK$F8SbOGuI2%)5U3CMy8V9@{o2kS{hK~$~2Iu%&!1hfe<DZp)Ux=bHd
z`PF>*#3AzrCtz>_R<jdST@LKK7^v>|0|?83L%Uhc5~%+D0CtL9eQf<c(cB5?BB<uC
zAMzd~kWvEH4MBQuvPsmLubN%*`R8R_Ivd?QK@?-e#FwJq58Kz8mQ0g5_qc5F>v$YE
zls|m`G&(@50JiJbPqeD*@jde4oZED>&7#l#`A_!c7hiZOf`J42i+En1F(;M}U>-i~
zC3gB<k4NKAJ={v~LX$=)fj3B?+9VLy_gBk9BL@WvpiiGZ(YF2iu}}GFJ~&Nh^|!68
zN0(0Gc&=W3Ho{Te(K>#}z~>GY0l<IAu;baRci&|L`Gh;05<sgC@PGByS0bM}fP)6_
zWE#efi&ZSu_8~)lg9MUFz_$6P9H*=-@)LnL;G+yb7w?;IzF`|~xFN&+*UP>VzrW#Q
ziECDU!@mBenJrtf5~uW9``rNlkq^ygnGH5(Gx>oWTYhgaBWplcIDndfjrWTeFJ@%k
z<1a29O;SMxz94~Gm4Lh`NO!N6JFft6^fp@hMGF@)nER{OwFoPq6F&$fYK_>krAt}!
z*Q;3f9^F_&qxn1$YWbTVxPiU%(loaF-~-v-V{T<@qV7f|0F(cY7siX$9N?cc@9_-z
z1t`OKPhA7hJpRkmL+f9wwK$ZkViL$B8K>^HwzRVD-MTZz0p7e~8JvG?!G|BRFTVUj
z_yT(L=)oE@4J^a|=>mZt@7{U)6+zN%!wh?M%vo&3iWThm|972H2>|c_HV=95U;OtM
z*hPn59G$k`=@BV}0RD>AjgU|sNFc8OvPWXKGMxU?vwKg5W3pit;CI*V-NmuoIGwkd
zcL_3F38+Cf`_b>8IsGNpYsW3v53fI0D1i+&*nmxb@HVz&`8uN#K&#F#5jDWiL)5o#
zU)H;KZ{ZifgV6HVL9Gl$te6Dad;r~h2(SO@)y=#m{wG@(wFuDTc<i;!&0>R4bP2j~
z3!zh|Mr{UR_J8!{Jn?S#0Rz})Z+^g@z4&JK)-x}&O?T<Xj``nTvA(<Qpyj2$KE1?}
zUtEh8En>0~$PfKhOhh4}Ac5MIK$`{7@-17<fsP=y7V6f6gPsWmfY7yDH}QMz+BNyz
zf>p6B?Y^AtJN7iu^0OWrh}WOZn$MQ8)$G%^=drtv9>xC2m4YddnGcY2KLE%w^XJbm
zPy*-<1SL?r6*818odo2q!F2a(?D=6p^y*>uw=&+x=T1K;gGTNPh$6K15yS8w9~$89
z0Z!A}Qj|+E%y;`e!c0fYkFe(37PesChphMdJ=r%aSFzJi{RO-KzlIy<1pwGk0=VvY
z_8zF6=%u$8GOh!}c1Jt!yfa(2Y?*i;LXbd^K%oSD=K_E`uK?DqTbDl!q_Jx^ZvMk3
z5DBn%>DrY$2wPYSzZx4d;;$~qN?^S{+p>jASF!ar=*7NXv7BwvtFsmS05!GjS@1If
z{#o;uu=TgtJj0!T5seUxKQ$<TQ2B!dR0+^7K(qwd^jB6Cc?G~7e3`+62S=~G@`~{I
zx9~0jpBMluT=@Lq4}gWRFF%22%2Q7nhu~<!&%gmJ>LZMJ-W%ZHkDCo>0{`^pk1{Ol
zRuH2DnRCO34-yCxD3t^XW&%!`GDQIUkVA(?&rN+6Gyk|EXyE<+wQSI!L5v@Jo#Ehj
zN;?klY9wuDe_P8x?fUC@ehORrVE#LaKM>WS1hCfMH)z)aJo&_Ap$ItWafTjyinsW2
zXWsiJtfPm?j{vhj3;qy-1cC%yB;Yy?SdFXw_X7yafnC0Dpa~MtN+9ii0A30}cRrxc
zA-g{33p#)AOxO>=Syq9t<|OdxCqGDBCVonG+bDo077XbXnBhKP=e%k8tpzJkCSgB-
zWR>8+99xiIRm%@RwgouwJ9R4V?N6ROnGgEgLw?nt+Il;-<^}xO>BeoBr_{sFKb`^$
z<n<{50G@(;uakyJ0mxtz_q_FY1t93O{2p<bz8u#duGy&1j~_~1-xAQZ_SE|8l!0y(
zz=p6QvtAK*EIOeCc<}M?7sQ!UB0l`}T_Zy2>p}tqZq?M6!LREEs1|?@z$(~WT49+-
zI2s*6Pu2tFBUYi*#n%mm3=(jVfDYhbQ(J!dw`o&Q09bA9>6w@*Xb9>H@mn?hrQfEA
z@@eJLk$;EQ-=Q)DlKPT>41S$8VCn|goPbGyCinjftN`_M7%T$t=)h0xN%B-*H6fI?
zt|g#?U-k*;6hqu7fKiy_&6fy@9DfRPkwP$x2*~lMEx$|mqpmAJD14BBt>2G#E?t0F
zDbiVfIYM1uUG75AeO?L3X8{`GkinmiD>wmTKTRO0V+qIrH#r1l@dyhbrZp#eqeBkn
zylm3v?uGL&=S!eXMARX|IA4NnHN;sMb^O^w(d$_PXwg+ipUojCziZnNB<t8yTV0)8
z1)*&`o?2<y`KLMpHT<p)!FvAIq3l5dS_u?@S~KepOuBghIv;?|(PnkRxeWEW&}d3X
z&Ov$=oPhxdK>|4mxD5Xp=LzKPdv31N@E$<wIqyIJF$mzfK0e~f_5%!)e^g7rA>9D}
zQ1ycZEE0&D6eP2XE`SO;69@^cuJi<a+Z132z{~j!;15+lNWeh?E)GC}{g}SIF)7zM
z`Ekl5t}HeMA@UHG1ILLlysu#iU_St?>Ps5_KWW2ToZ>#R8vp<R07*qoM6N<$f<k9U
A`Tzg`

literal 16666
zcmYMcbzGC*|2}?i3`W;Lx{;xXv`CLeX;ea_kxoHEYLs*-(v5<?=tgoh3J6Gtq!Q8s
zWAyLl{rNr~zd!cay^Wo7_B`iV*LB@Q>1e5v5i=4406_LgO-T;`AmAkgAS3{vUcCBj
z13nSCsTp|y014ve0Rb|y=m7vV_()0qsZZ8Uc7XrWp4Mx*8WIkU4qyc@Qu=9_8=u;E
zh*%UE4dI)EXjroO7D)`}#&NVf-;3i^w=#pfG$p36r^Lr85h3WZ7fBHg&m;e_^F-T)
zz#!p_y6h-5!f!wJ5^6kz{k(oic>I_da(U<5ZmRAzoW7U!XnNSY?NEdF6MGmc-wm(F
zfpK6RG0%|g^e5`~-kxEk$NCSkfIt-$0wAxkaeBNhZVdi_Hu?TXh%i|j9iU-Gs8A$v
zwF=X#y=GoCS`RV|$6N5Q7r!TrO;(wNQz`H=M+)f;d!N1F6BZV(^gXlzF#Snfn%O{9
zA7LIOFR+VE!E-1UMa)YL5q@#5(E$B?yi3R!vS3=zoK%1ESXmh#A6-)3^!V?o@a7%;
zF+)ipL`wcnPXt@whA=`%{Ff(!{p4DS>(n1UjL#kq_#B7~W}%0Dss7jlcA;IAQ9r}S
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
ayeeOgPgu@z4*X{az$0ZXrE&%HkpB-7W%Skn


From 893e7a68da890631eda85e16a1af57fb2a6e3d4a Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Thu, 21 Sep 2023 07:51:17 -0700
Subject: [PATCH 08/22] appeng/client/gui: AEBaseGui.java: bind texture w/
 ResourceLocation

Before it was allocating a new ResourceLocation PER BIND, which happens
multiple times per draw frame in some GUIs.
---
 src/main/java/appeng/client/gui/AEBaseGui.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/main/java/appeng/client/gui/AEBaseGui.java b/src/main/java/appeng/client/gui/AEBaseGui.java
index 5f0594c593d..ccdd02a88d6 100644
--- a/src/main/java/appeng/client/gui/AEBaseGui.java
+++ b/src/main/java/appeng/client/gui/AEBaseGui.java
@@ -1015,6 +1015,10 @@ public void bindTexture(final String file) {
         this.mc.getTextureManager().bindTexture(loc);
     }
 
+    public void bindTexture(final ResourceLocation loc) {
+        mc.getTextureManager().bindTexture(loc);
+    }
+
     public void func_146977_a(final Slot s) {
         this.drawSlot(s);
     }

From ff006ebe769900dda93a6bb76ec9024b4b7e6aab Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Wed, 27 Sep 2023 08:03:31 -0700
Subject: [PATCH 09/22] appeng/client/gui/widgets: GuiScrollbar.java: Add
 visibility flag

Skip rendering if visible is false
---
 src/main/java/appeng/client/gui/widgets/GuiScrollbar.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/main/java/appeng/client/gui/widgets/GuiScrollbar.java b/src/main/java/appeng/client/gui/widgets/GuiScrollbar.java
index 3d85e05841e..a696a58e9ac 100644
--- a/src/main/java/appeng/client/gui/widgets/GuiScrollbar.java
+++ b/src/main/java/appeng/client/gui/widgets/GuiScrollbar.java
@@ -30,6 +30,7 @@ public class GuiScrollbar implements IScrollSource {
     private int maxScroll = 0;
     private int minScroll = 0;
     private int currentScroll = 0;
+    private boolean visible = true;
 
     public void setTexture(final String base, final String file, final int shiftX, final int shiftY) {
         txtBase = base;
@@ -39,6 +40,9 @@ public void setTexture(final String base, final String file, final int shiftX, f
     }
 
     public void draw(final AEBaseGui g) {
+        if (!visible) {
+            return;
+        }
         g.bindTexture(txtBase, txtFile);
         GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 
@@ -50,6 +54,10 @@ public void draw(final AEBaseGui g) {
         }
     }
 
+    public void setVisible(boolean visible) {
+        this.visible = visible;
+    }
+
     private int getRange() {
         return this.maxScroll - this.minScroll;
     }

From 6815d91dfe59dd35bbed0116f85ba5b7072ee9c5 Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Sat, 23 Sep 2023 18:17:50 -0700
Subject: [PATCH 10/22] appeng/client/gui: Add IGuiTooltipHandler

This interface is used to abstract NEI tooltip handling and getting the
hovered slot from GUIs.
---
 .../java/appeng/client/gui/AEBaseMEGui.java   |  3 ++-
 .../appeng/client/gui/IGuiTooltipHandler.java | 20 +++++++++++++++++++
 .../gui/implementations/GuiCraftConfirm.java  |  3 ++-
 .../gui/implementations/GuiCraftingCPU.java   |  4 +++-
 .../java/appeng/integration/modules/NEI.java  | 11 +++++-----
 5 files changed, 33 insertions(+), 8 deletions(-)
 create mode 100644 src/main/java/appeng/client/gui/IGuiTooltipHandler.java

diff --git a/src/main/java/appeng/client/gui/AEBaseMEGui.java b/src/main/java/appeng/client/gui/AEBaseMEGui.java
index 67ee5d698c0..ad0dff44a7a 100644
--- a/src/main/java/appeng/client/gui/AEBaseMEGui.java
+++ b/src/main/java/appeng/client/gui/AEBaseMEGui.java
@@ -25,12 +25,13 @@
 import appeng.core.localization.ButtonToolTips;
 import appeng.util.Platform;
 
-public abstract class AEBaseMEGui extends AEBaseGui {
+public abstract class AEBaseMEGui extends AEBaseGui implements IGuiTooltipHandler {
 
     public AEBaseMEGui(final Container container) {
         super(container);
     }
 
+    @Override
     public List<String> handleItemTooltip(final ItemStack stack, final int mouseX, final int mouseY,
             final List<String> currentToolTip) {
         if (stack != null) {
diff --git a/src/main/java/appeng/client/gui/IGuiTooltipHandler.java b/src/main/java/appeng/client/gui/IGuiTooltipHandler.java
new file mode 100644
index 00000000000..8101a867c41
--- /dev/null
+++ b/src/main/java/appeng/client/gui/IGuiTooltipHandler.java
@@ -0,0 +1,20 @@
+package appeng.client.gui;
+
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Interface for handling tooltips from NEIGuiContainerManager.
+ */
+public interface IGuiTooltipHandler {
+
+    default List<String> handleItemTooltip(final ItemStack stack, final int mouseX, final int mouseY,
+            final List<String> currentToolTip) {
+        return currentToolTip;
+    }
+
+    default ItemStack getHoveredStack() {
+        return null;
+    }
+}
diff --git a/src/main/java/appeng/client/gui/implementations/GuiCraftConfirm.java b/src/main/java/appeng/client/gui/implementations/GuiCraftConfirm.java
index f8875d610df..0da04e53d83 100644
--- a/src/main/java/appeng/client/gui/implementations/GuiCraftConfirm.java
+++ b/src/main/java/appeng/client/gui/implementations/GuiCraftConfirm.java
@@ -35,6 +35,7 @@
 import appeng.api.storage.data.IAEItemStack;
 import appeng.api.storage.data.IItemList;
 import appeng.client.gui.AEBaseGui;
+import appeng.client.gui.IGuiTooltipHandler;
 import appeng.client.gui.widgets.GuiCraftingCPUTable;
 import appeng.client.gui.widgets.GuiCraftingTree;
 import appeng.client.gui.widgets.GuiImgButton;
@@ -63,7 +64,7 @@
 import appeng.util.Platform;
 import appeng.util.ReadableNumberConverter;
 
-public class GuiCraftConfirm extends AEBaseGui implements ICraftingCPUTableHolder {
+public class GuiCraftConfirm extends AEBaseGui implements ICraftingCPUTableHolder, IGuiTooltipHandler {
 
     public static final int TREE_VIEW_TEXTURE_WIDTH = 238;
     public static final int TREE_VIEW_TEXTURE_HEIGHT = 238;
diff --git a/src/main/java/appeng/client/gui/implementations/GuiCraftingCPU.java b/src/main/java/appeng/client/gui/implementations/GuiCraftingCPU.java
index 4cc9c74db00..cc9677d27b2 100644
--- a/src/main/java/appeng/client/gui/implementations/GuiCraftingCPU.java
+++ b/src/main/java/appeng/client/gui/implementations/GuiCraftingCPU.java
@@ -38,6 +38,7 @@
 import appeng.api.util.DimensionalCoord;
 import appeng.api.util.WorldCoord;
 import appeng.client.gui.AEBaseGui;
+import appeng.client.gui.IGuiTooltipHandler;
 import appeng.client.gui.widgets.GuiScrollbar;
 import appeng.client.gui.widgets.ISortSource;
 import appeng.client.gui.widgets.ITooltip;
@@ -55,7 +56,7 @@
 import appeng.util.Platform;
 import appeng.util.ReadableNumberConverter;
 
-public class GuiCraftingCPU extends AEBaseGui implements ISortSource {
+public class GuiCraftingCPU extends AEBaseGui implements ISortSource, IGuiTooltipHandler {
 
     private static final int GUI_HEIGHT = 184;
     private static final int GUI_WIDTH = 238;
@@ -616,6 +617,7 @@ public Enum getSortDisplay() {
         return ViewItems.ALL;
     }
 
+    @Override
     public ItemStack getHoveredStack() {
         return hoveredStack;
     }
diff --git a/src/main/java/appeng/integration/modules/NEI.java b/src/main/java/appeng/integration/modules/NEI.java
index 7e5264a531a..cc415b886eb 100644
--- a/src/main/java/appeng/integration/modules/NEI.java
+++ b/src/main/java/appeng/integration/modules/NEI.java
@@ -22,7 +22,7 @@
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 
-import appeng.client.gui.AEBaseMEGui;
+import appeng.client.gui.IGuiTooltipHandler;
 import appeng.client.gui.implementations.GuiCraftConfirm;
 import appeng.client.gui.implementations.GuiCraftingCPU;
 import appeng.client.gui.implementations.GuiCraftingTerm;
@@ -210,8 +210,8 @@ public List<String> handleItemDisplayName(final GuiContainer arg0, final ItemSta
     @Override
     public List<String> handleItemTooltip(final GuiContainer guiScreen, final ItemStack stack, final int mouseX,
             final int mouseY, final List<String> currentToolTip) {
-        if (guiScreen instanceof AEBaseMEGui) {
-            return ((AEBaseMEGui) guiScreen).handleItemTooltip(stack, mouseX, mouseY, currentToolTip);
+        if (guiScreen instanceof IGuiTooltipHandler) {
+            return ((IGuiTooltipHandler) guiScreen).handleItemTooltip(stack, mouseX, mouseY, currentToolTip);
         }
 
         return currentToolTip;
@@ -228,8 +228,9 @@ public void load(GuiContainer gui) {}
 
     @Override
     public ItemStack getStackUnderMouse(GuiContainer gui, int mousex, int mousey) {
-        if (gui instanceof GuiCraftConfirm) return ((GuiCraftConfirm) gui).getHoveredStack();
-        else if (gui instanceof GuiCraftingCPU) return ((GuiCraftingCPU) gui).getHoveredStack();
+        if (gui instanceof IGuiTooltipHandler) {
+            return ((IGuiTooltipHandler) gui).getHoveredStack();
+        }
         return null;
     }
 

From 1157a4f0749f58509dec71de0ea327f1d357cf2f Mon Sep 17 00:00:00 2001
From: Firenoo <49818773+firenoo@users.noreply.github.com>
Date: Wed, 27 Sep 2023 08:34:34 -0700
Subject: [PATCH 11/22] appeng/client/gui/implementations: New Interface
 Terminal GUI

Adds the following to interface terminal:
* Interfaces are grouped by their name. Each group's name is pinned to the
top until the next name comes up.
* Viewport now supports smooth scrolling.
* SHIFT + scroll jumps from section to section
* CTRL + scroll jumps up/down the whole page.
* Search now filters out irrelevant patterns like NEI, graying them out.
---
 .../implementations/GuiInterfaceTerminal.java | 1311 ++++++++++++-----
 .../textures/guis/newinterfaceterminal.png    |  Bin 4082 -> 3350 bytes
 2 files changed, 977 insertions(+), 334 deletions(-)

diff --git a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
index ebb7587d7bf..f62667b2f52 100644
--- a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
+++ b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
@@ -11,26 +11,34 @@
 package appeng.client.gui.implementations;
 
 import java.util.ArrayList;
-import java.util.Collections;
+import java.util.Arrays;
+import java.util.Comparator;
 import java.util.HashMap;
-import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.WeakHashMap;
+import java.util.TreeMap;
+import java.util.TreeSet;
 
-import appeng.core.sync.packets.PacketIfaceTermUpdate;
+import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
 import net.minecraft.util.ChatComponentTranslation;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants.NBT;
 
+import org.lwjgl.input.Keyboard;
 import org.lwjgl.input.Mouse;
 import org.lwjgl.opengl.GL11;
-
-import com.google.common.collect.HashMultimap;
+import org.lwjgl.opengl.GL12;
 
 import appeng.api.AEApi;
 import appeng.api.config.ActionItems;
@@ -39,42 +47,59 @@
 import appeng.api.util.DimensionalCoord;
 import appeng.api.util.WorldCoord;
 import appeng.client.gui.AEBaseGui;
+import appeng.client.gui.IGuiTooltipHandler;
 import appeng.client.gui.widgets.GuiImgButton;
 import appeng.client.gui.widgets.GuiScrollbar;
 import appeng.client.gui.widgets.IDropToFillTextField;
 import appeng.client.gui.widgets.MEGuiTextField;
-import appeng.client.me.ClientDCInternalInv;
-import appeng.client.me.SlotDisconnected;
 import appeng.client.render.BlockPosHighlighter;
 import appeng.container.implementations.ContainerInterfaceTerminal;
 import appeng.container.slot.AppEngSlot;
 import appeng.core.AEConfig;
+import appeng.core.AppEng;
 import appeng.core.CommonHelper;
 import appeng.core.localization.ButtonToolTips;
 import appeng.core.localization.GuiColors;
 import appeng.core.localization.GuiText;
 import appeng.core.localization.PlayerMessages;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketIfaceTermUpdate;
+import appeng.core.sync.packets.PacketIfaceTermUpdate.PacketEntry;
+import appeng.core.sync.packets.PacketInventoryAction;
+import appeng.helpers.InventoryAction;
 import appeng.helpers.PatternHelper;
 import appeng.integration.IntegrationRegistry;
 import appeng.integration.IntegrationType;
+import appeng.items.misc.ItemEncodedPattern;
 import appeng.parts.reporting.PartInterfaceTerminal;
+import appeng.tile.inventory.AppEngInternalInventory;
 import appeng.util.Platform;
+import cpw.mods.fml.common.Loader;
+
+/**
+ * Interface Terminal GUI <br/>
+ * Most of the interface terminal has been rewritten. You may ask, why are you not using SLOTS? And I asked myself that
+ * too. I was about to go and rewrite it again until I realized that the interface terminal must support adding/removing
+ * entries dynamically. And finding the slots, removing them from the slot list - not exactly a huge fan, especially
+ * considering we are doing this first, and foremost, for performance gains. Also, the whole Z-level thing is very
+ * frustrating for me. Basically, I've gone rogue and taken the Thaumic Energistics route. <br/>
+ * The previous implementation did not use static slots either - instead, in generated new slots dynamically every
+ * render tick or when slots were clicked. Why do that, when you can write 500 extra lines of code to reimplement a
+ * version of slots specific to the interface terminal?
+ *
+ * @author firenoo
+ */
+public class GuiInterfaceTerminal extends AEBaseGui implements IDropToFillTextField, IGuiTooltipHandler {
 
-public class GuiInterfaceTerminal extends AEBaseGui implements IDropToFillTextField {
-
-    private static final int MAGIC_HEIGHT_NUMBER = 52 + 99;
-    private static final int offsetX = 21;
-
-    private final HashMap<Long, ClientDCInternalInv> byId = new HashMap<>();
-    private final HashMultimap<String, ClientDCInternalInv> byName = HashMultimap.create();
-    private final HashMap<ClientDCInternalInv, DimensionalCoord> blockPosHashMap = new HashMap<>();
-    private final HashMap<GuiButton, ClientDCInternalInv> guiButtonHashMap = new HashMap<>();
-    private final ArrayList<String> names = new ArrayList<>();
-    private final ArrayList<Object> lines = new ArrayList<>();
-    private final Set<Object> matchedStacks = new HashSet<>();
-
-    private final Map<String, Set<Object>> cachedSearches = new WeakHashMap<>();
+    public static final int HEADER_HEIGHT = 52;
+    public static final int INV_HEIGHT = 98;
+    public static final int VIEW_WIDTH = 174;
+    public static final int VIEW_LEFT = 10;
+    protected static final ResourceLocation BACKGROUND = new ResourceLocation(
+            AppEng.MOD_ID,
+            "textures/guis/newinterfaceterminal.png");
 
+    private final IfaceList masterList = new IfaceList();
     private final MEGuiTextField searchFieldOutputs;
     private final MEGuiTextField searchFieldInputs;
     private final MEGuiTextField searchFieldNames;
@@ -82,14 +107,23 @@ public class GuiInterfaceTerminal extends AEBaseGui implements IDropToFillTextFi
     private final GuiImgButton guiButtonAssemblersOnly;
     private final GuiImgButton guiButtonBrokenRecipes;
     private final GuiImgButton terminalStyleBox;
-    private boolean refreshList = false;
     private boolean onlyMolecularAssemblers = false;
     private boolean onlyBrokenRecipes = false;
-
-    // private final IConfigManager configSrc;
-    private int rows = 3;
-
-    private static final String MOLECULAR_ASSEMBLER = "tile.appliedenergistics2.BlockMolecularAssembler";
+    private boolean online;
+    /** The height of the viewport. */
+    private int viewHeight;
+    private final List<String> extraOptionsText;
+    private ItemStack tooltipStack;
+    private final boolean neiPresent;
+    /*
+     * Z-level Map (FLOATS) 0.0 - BACKGROUND 1.0 - ItemStacks 2.0 - Slot color overlays 20.0 - ItemStack overlays 21.0 -
+     * Slot mouse hover overlay 200.0 - Tooltips
+     */
+    private static final float ITEMSTACK_Z = 1.0f;
+    private static final float SLOT_Z = 0.5f;
+    private static final float ITEMSTACK_OVERLAY_Z = 20.0f;
+    private static final float SLOT_HOVER_Z = 31.0f;
+    private static final float TOOLTIP_Z = 200.0f;
 
     public GuiInterfaceTerminal(final InventoryPlayer inventoryPlayer, final PartInterfaceTerminal te) {
         super(new ContainerInterfaceTerminal(inventoryPlayer, te));
@@ -97,12 +131,13 @@ public GuiInterfaceTerminal(final InventoryPlayer inventoryPlayer, final PartInt
         this.setScrollBar(new GuiScrollbar());
         this.xSize = 208;
         this.ySize = 255;
+        this.neiPresent = Loader.isModLoaded("NotEnoughItems");
 
         searchFieldInputs = new MEGuiTextField(86, 12, ButtonToolTips.SearchFieldInputs.getLocal()) {
 
             @Override
             public void onTextChange(final String oldText) {
-                refreshList();
+                masterList.markDirty();
             }
         };
 
@@ -110,7 +145,7 @@ public void onTextChange(final String oldText) {
 
             @Override
             public void onTextChange(final String oldText) {
-                refreshList();
+                masterList.markDirty();
             }
         };
 
@@ -118,7 +153,7 @@ public void onTextChange(final String oldText) {
 
             @Override
             public void onTextChange(final String oldText) {
-                refreshList();
+                masterList.markDirty();
             }
         };
         searchFieldNames.setFocused(true);
@@ -128,46 +163,59 @@ public void onTextChange(final String oldText) {
         guiButtonBrokenRecipes = new GuiImgButton(0, 0, Settings.ACTIONS, null);
 
         terminalStyleBox = new GuiImgButton(0, 0, Settings.TERMINAL_STYLE, null);
+
+        this.extraOptionsText = new ArrayList<>(2);
+        extraOptionsText.add(ButtonToolTips.HighlightInterface.getLocal());
     }
 
     private void setScrollBar() {
-        this.getScrollBar().setTop(52).setLeft(189).setHeight(this.rows * 18 - 2);
-        this.getScrollBar().setRange(0, this.lines.size() - this.rows, 2);
+        int maxScroll = this.masterList.getHeight() - this.viewHeight - 1;
+        if (maxScroll <= 0) {
+            this.getScrollBar().setTop(52).setLeft(189).setHeight(this.viewHeight).setRange(0, 0, 1);
+        } else {
+            this.getScrollBar().setTop(52).setLeft(189).setHeight(this.viewHeight).setRange(0, maxScroll, 12);
+        }
     }
 
     @Override
     public void initGui() {
-        this.rows = calculateRowsCount();
-
         super.initGui();
 
-        this.ySize = MAGIC_HEIGHT_NUMBER + this.rows * 18;
+        this.buttonList.clear();
+        this.viewHeight = calculateViewHeight();
+        this.ySize = HEADER_HEIGHT + INV_HEIGHT + this.viewHeight;
+
         final int unusedSpace = this.height - this.ySize;
         this.guiTop = (int) Math.floor(unusedSpace / (unusedSpace < 0 ? 3.8f : 2.0f));
 
-        searchFieldInputs.x = guiLeft + Math.max(32, offsetX);
+        searchFieldInputs.x = guiLeft + Math.max(32, VIEW_LEFT);
         searchFieldInputs.y = guiTop + 25;
 
-        searchFieldOutputs.x = guiLeft + Math.max(32, offsetX);
+        searchFieldOutputs.x = guiLeft + Math.max(32, VIEW_LEFT);
         searchFieldOutputs.y = guiTop + 38;
 
-        searchFieldNames.x = guiLeft + Math.max(32, offsetX) + 99;
+        searchFieldNames.x = guiLeft + Math.max(32, VIEW_LEFT) + 99;
         searchFieldNames.y = guiTop + 38;
 
-        guiButtonAssemblersOnly.xPosition = guiLeft + Math.max(32, offsetX) + 99;
-        guiButtonAssemblersOnly.yPosition = guiTop + 20;
+        terminalStyleBox.xPosition = guiLeft - 18;
+        terminalStyleBox.yPosition = guiTop + 8;
 
-        guiButtonHideFull.xPosition = guiButtonAssemblersOnly.xPosition + 18;
-        guiButtonHideFull.yPosition = guiTop + 20;
+        guiButtonBrokenRecipes.xPosition = guiLeft - 18;
+        guiButtonBrokenRecipes.yPosition = terminalStyleBox.yPosition + 18;
 
-        guiButtonBrokenRecipes.xPosition = guiButtonHideFull.xPosition + 18;
-        guiButtonBrokenRecipes.yPosition = guiTop + 20;
+        guiButtonHideFull.xPosition = guiLeft - 18;
+        guiButtonHideFull.yPosition = guiButtonBrokenRecipes.yPosition + 18;
 
-        terminalStyleBox.xPosition = guiLeft - 18;
-        terminalStyleBox.yPosition = guiTop + 8;
+        guiButtonAssemblersOnly.xPosition = guiLeft - 18;
+        guiButtonAssemblersOnly.yPosition = guiButtonHideFull.yPosition + 18;
 
         this.setScrollBar();
         this.repositionSlots();
+
+        buttonList.add(guiButtonAssemblersOnly);
+        buttonList.add(guiButtonHideFull);
+        buttonList.add(guiButtonBrokenRecipes);
+        buttonList.add(terminalStyleBox);
     }
 
     protected void repositionSlots() {
@@ -178,13 +226,14 @@ protected void repositionSlots() {
         }
     }
 
-    protected int calculateRowsCount() {
-        final int maxRows = this.getMaxRows();
+    protected int calculateViewHeight() {
+        final int maxViewHeight = this.getMaxViewHeight();
         final boolean hasNEI = IntegrationRegistry.INSTANCE.isEnabled(IntegrationType.NEI);
         final int NEIPadding = hasNEI ? 22 /* input */ + 18 /* top panel */ : 0;
-        final int extraSpace = this.height - MAGIC_HEIGHT_NUMBER - NEIPadding;
+        final int availableSpace = this.height - HEADER_HEIGHT - INV_HEIGHT - NEIPadding;
 
-        return Math.max(3, Math.min(maxRows, extraSpace / 18));
+        // screen should use 95% of the space it can, 5% margins
+        return Math.min((int) (availableSpace * 0.95), maxViewHeight);
     }
 
     @Override
@@ -196,52 +245,16 @@ public void drawFG(final int offsetX, final int offsetY, final int mouseX, final
                 GuiColors.InterfaceTerminalTitle.getColor());
         fontRendererObj.drawString(
                 GuiText.inventory.getLocal(),
-                GuiInterfaceTerminal.offsetX + 2,
+                GuiInterfaceTerminal.VIEW_LEFT + 2,
                 this.ySize - 96,
                 GuiColors.InterfaceTerminalInventory.getColor());
-
-        int offset = 51;
-        final int ex = getScrollBar().getCurrentScroll();
-        for (int x = 0; x < this.rows && ex + x < this.lines.size(); x++) {
-            final Object lineObj = this.lines.get(ex + x);
-            if (lineObj instanceof ClientDCInternalInv inv) {
-                for (int z = 0; z < inv.getInventory().getSizeInventory(); z++) {
-                    if (this.matchedStacks.contains(inv.getInventory().getStackInSlot(z))) drawRect(
-                            z * 18 + 22,
-                            1 + offset,
-                            z * 18 + 22 + 16,
-                            1 + offset + 16,
-                            GuiColors.InterfaceTerminalMatch.getColor());
-                }
-            } else if (lineObj instanceof String name) {
-                final int rows = this.byName.get(name).size();
-                String postfix = "";
-
-                if (rows > 1) {
-                    postfix = " (" + rows + ')';
-                }
-
-                while (name.length() > 2 && this.fontRendererObj.getStringWidth(name + postfix) > 158) {
-                    name = name.substring(0, name.length() - 1);
-                }
-
-                this.fontRendererObj.drawString(
-                        name + postfix,
-                        GuiInterfaceTerminal.offsetX + 3,
-                        6 + offset,
-                        GuiColors.InterfaceTerminalName.getColor());
-            }
-
-            offset += 18;
+        if (!neiPresent && tooltipStack != null) {
+            renderToolTip(tooltipStack, mouseX, mouseY);
         }
     }
 
     @Override
     public void drawScreen(final int mouseX, final int mouseY, final float btn) {
-
-        buttonList.clear();
-        inventorySlots.inventorySlots.removeIf(slot -> slot instanceof SlotDisconnected);
-
         guiButtonAssemblersOnly.set(
                 onlyMolecularAssemblers ? ActionItems.MOLECULAR_ASSEMBLEERS_ON : ActionItems.MOLECULAR_ASSEMBLEERS_OFF);
         guiButtonHideFull.set(
@@ -254,34 +267,6 @@ public void drawScreen(final int mouseX, final int mouseY, final float btn) {
 
         terminalStyleBox.set(AEConfig.instance.settings.getSetting(Settings.TERMINAL_STYLE));
 
-        buttonList.add(guiButtonAssemblersOnly);
-        buttonList.add(guiButtonHideFull);
-        buttonList.add(guiButtonBrokenRecipes);
-
-        buttonList.add(terminalStyleBox);
-        guiButtonHashMap.clear();
-
-        int offset = 51;
-        final int ex = this.getScrollBar().getCurrentScroll();
-        for (int x = 0; x < this.rows && ex + x < this.lines.size(); x++) {
-            final Object lineObj = this.lines.get(ex + x);
-            if (lineObj instanceof ClientDCInternalInv inv) {
-                for (int z = 0; z < inv.getInventory().getSizeInventory(); z++) {
-                    inventorySlots.inventorySlots.add(new SlotDisconnected(inv, z, z * 18 + 22, 1 + offset));
-                }
-
-                GuiButton guiButton = new GuiImgButton(
-                        guiLeft + 4,
-                        guiTop + offset + 1,
-                        Settings.ACTIONS,
-                        ActionItems.HIGHLIGHT_INTERFACE);
-                guiButtonHashMap.put(guiButton, inv);
-                buttonList.add(guiButton);
-            }
-
-            offset += 18;
-        }
-
         super.drawScreen(mouseX, mouseY, btn);
 
         handleTooltip(mouseX, mouseY, searchFieldInputs);
@@ -295,43 +280,23 @@ protected void mouseClicked(final int xCoord, final int yCoord, final int btn) {
         searchFieldOutputs.mouseClicked(xCoord, yCoord, btn);
         searchFieldNames.mouseClicked(xCoord, yCoord, btn);
 
+        if (masterList.mouseClicked(xCoord - guiLeft - VIEW_LEFT, yCoord - guiTop - HEADER_HEIGHT, btn)) {
+            return;
+        }
         super.mouseClicked(xCoord, yCoord, btn);
     }
 
     @Override
     protected void actionPerformed(final GuiButton btn) {
-        if (guiButtonHashMap.containsKey(btn)) {
-            DimensionalCoord blockPos = blockPosHashMap.get(guiButtonHashMap.get(btn));
-            WorldCoord blockPos2 = new WorldCoord(
-                    (int) mc.thePlayer.posX,
-                    (int) mc.thePlayer.posY,
-                    (int) mc.thePlayer.posZ);
-            if (mc.theWorld.provider.dimensionId != blockPos.getDimension()) {
-                mc.thePlayer.addChatMessage(
-                        new ChatComponentTranslation(
-                                PlayerMessages.InterfaceInOtherDim.getName(),
-                                blockPos.getDimension()));
-            } else {
-                BlockPosHighlighter.highlightBlock(
-                        blockPos,
-                        System.currentTimeMillis() + 500 * WorldCoord.getTaxicabDistance(blockPos, blockPos2));
-                mc.thePlayer.addChatMessage(
-                        new ChatComponentTranslation(
-                                PlayerMessages.InterfaceHighlighted.getName(),
-                                blockPos.x,
-                                blockPos.y,
-                                blockPos.z));
-            }
-            mc.thePlayer.closeScreen();
+        if (btn == guiButtonAssemblersOnly) {
+            onlyMolecularAssemblers = !onlyMolecularAssemblers;
+            masterList.markDirty();
         } else if (btn == guiButtonHideFull) {
             AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal = !AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal;
-            this.refreshList();
-        } else if (btn == guiButtonAssemblersOnly) {
-            onlyMolecularAssemblers = !onlyMolecularAssemblers;
-            this.refreshList();
+            masterList.markDirty();
         } else if (btn == guiButtonBrokenRecipes) {
             onlyBrokenRecipes = !onlyBrokenRecipes;
-            this.refreshList();
+            masterList.markDirty();
         } else if (btn instanceof GuiImgButton iBtn) {
             if (iBtn.getSetting() != Settings.ACTIONS) {
                 final Enum cv = iBtn.getCurrentValue();
@@ -340,8 +305,7 @@ protected void actionPerformed(final GuiButton btn) {
 
                 if (btn == this.terminalStyleBox) {
                     AEConfig.instance.settings.putSetting(iBtn.getSetting(), next);
-
-                    this.reinitialize();
+                    initGui();
                 }
 
                 iBtn.set(next);
@@ -349,41 +313,374 @@ protected void actionPerformed(final GuiButton btn) {
         }
     }
 
-    private void reinitialize() {
-        this.buttonList.clear();
-        this.initGui();
-    }
-
     @Override
     public void drawBG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.bindTexture("guis/newinterfaceterminal.png");
-        this.drawTexturedModalRect(offsetX, offsetY, 0, 0, this.xSize, 53);
+        this.bindTexture(BACKGROUND);
+        /* Draws the top part. */
+        this.drawTexturedModalRect(offsetX, offsetY, 0, 0, xSize, HEADER_HEIGHT);
+        /* Draws the middle part. */
+        Tessellator.instance.startDrawingQuads();
+        addTexturedRectToTesselator(
+                offsetX,
+                offsetY + HEADER_HEIGHT,
+                offsetX + xSize,
+                offsetY + HEADER_HEIGHT + viewHeight + 1,
+                0.0f,
+                0.0f,
+                (HEADER_HEIGHT + IfaceSection.TITLE_HEIGHT + 1.0f) / 256.0f,
+                this.xSize / 256.0f,
+                (HEADER_HEIGHT + 106.0f) / 256.0f);
+        Tessellator.instance.draw();
+        /* Draw the bottom part */
+        this.drawTexturedModalRect(offsetX, offsetY + HEADER_HEIGHT + viewHeight, 0, 158, xSize, INV_HEIGHT);
+        if (online) {
+            GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
+            GL11.glEnable(GL11.GL_BLEND);
+            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+            /* (0,0) => viewPort's (0,0) */
+            GL11.glPushMatrix();
+            GL11.glTranslatef(offsetX + VIEW_LEFT, offsetY + HEADER_HEIGHT, 0);
+            tooltipStack = null;
+            masterList.hoveredEntry = null;
+            drawViewport(mouseX - offsetX - VIEW_LEFT, mouseY - offsetY - HEADER_HEIGHT - 1);
+            GL11.glPopMatrix();
+            GL11.glPopAttrib();
+        }
+        searchFieldInputs.drawTextBox();
+        searchFieldOutputs.drawTextBox();
+        searchFieldNames.drawTextBox();
+    }
+
+    /**
+     * Draws the viewport area
+     */
+    private void drawViewport(int relMouseX, int relMouseY) {
+        /* Viewport Magic */
+        final int scroll = this.getScrollBar().getCurrentScroll();
+        int viewY = -scroll; // current y in viewport coordinates
+        int entryIdx = 0;
+        List<IfaceSection> visibleSections = this.masterList.getVisibleSections();
+
+        final float guiScaleX = (float) mc.displayWidth / width;
+        final float guiScaleY = (float) mc.displayHeight / height;
+        GL11.glScissor(
+                (int) ((guiLeft + VIEW_LEFT) * guiScaleX),
+                (int) ((height - (guiTop + HEADER_HEIGHT + viewHeight)) * guiScaleY),
+                (int) (VIEW_WIDTH * guiScaleX),
+                (int) (this.viewHeight * guiScaleY));
+        GL11.glEnable(GL11.GL_SCISSOR_TEST);
+
+        /*
+         * Render each section
+         */
+        while (viewY < this.viewHeight && entryIdx < visibleSections.size()) {
+            IfaceSection section = visibleSections.get(entryIdx);
+            int sectionHeight = section.getHeight();
+
+            /* Is it viewable/in the viewport at all? */
+            if (viewY + sectionHeight < 0) {
+                entryIdx++;
+                viewY += sectionHeight;
+                section.visible = false;
+                continue;
+            }
 
-        int offset = 51;
-        final int ex = this.getScrollBar().getCurrentScroll();
+            section.visible = true;
+            int advanceY = drawSection(section, viewY, relMouseX, relMouseY);
+            viewY += advanceY;
+            entryIdx++;
+        }
+    }
+
+    /**
+     * Render the section (if it is visible)
+     *
+     * @param section   the section to render
+     * @param viewY     current y coordinate relative to gui
+     * @param relMouseX transformed mouse coords relative to viewport
+     * @param relMouseY transformed mouse coords relative to viewport
+     * @return the height of the section rendered in viewport coordinates, max of viewHeight.
+     */
+    private int drawSection(IfaceSection section, int viewY, int relMouseX, int relMouseY) {
+        int title;
+        int renderY = 0;
+        final int sectionBottom = viewY + section.getHeight() - 1;
+        final int fontColor = GuiColors.InterfaceTerminalInventory.getColor();
+        /*
+         * Render title
+         */
+        GL11.glTranslatef(0.0f, 0.0f, 50f);
+        bindTexture(BACKGROUND);
+        if (sectionBottom > 0 && sectionBottom < IfaceSection.TITLE_HEIGHT) {
+            /* Transition draw */
+            drawTexturedModalRect(
+                    0,
+                    0,
+                    VIEW_LEFT,
+                    HEADER_HEIGHT + IfaceSection.TITLE_HEIGHT - sectionBottom,
+                    VIEW_WIDTH,
+                    sectionBottom);
+            fontRendererObj.drawString(section.name, 2, sectionBottom - IfaceSection.TITLE_HEIGHT + 2, fontColor);
+            title = sectionBottom;
+        } else if (viewY < 0) {
+            /* Hidden title draw */
+            drawTexturedModalRect(0, 0, VIEW_LEFT, HEADER_HEIGHT, VIEW_WIDTH, IfaceSection.TITLE_HEIGHT);
+            fontRendererObj.drawString(section.name, 2, 2, fontColor);
+            title = 0;
+        } else {
+            /* Normal title draw */
+            drawTexturedModalRect(0, viewY, VIEW_LEFT, HEADER_HEIGHT, VIEW_WIDTH, IfaceSection.TITLE_HEIGHT);
+            fontRendererObj.drawString(section.name, 2, viewY + 2, fontColor);
+            title = 0;
+        }
+        GL11.glTranslatef(0.0f, 0.0f, -50f);
+        GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+
+        Iterator<IfaceEntry> visible = section.getVisible();
+        while (visible.hasNext()) {
+            if (viewY < viewHeight) {
+                renderY += drawEntry(
+                        visible.next(),
+                        viewY + IfaceSection.TITLE_HEIGHT + renderY,
+                        title,
+                        relMouseX,
+                        relMouseY);
+            } else {
+                IfaceEntry entry = visible.next();
+                entry.dispY = -9999;
+                entry.optionsButton.yPosition = -1;
+            }
+        }
+        return IfaceSection.TITLE_HEIGHT + renderY;
+    }
 
-        for (int x = 0; x < this.rows; x++) {
-            this.drawTexturedModalRect(offsetX, offsetY + 53 + x * 18, 0, 52, this.xSize, 18);
+    /**
+     * Draws the entry. In practice it just draws the slots + items.
+     *
+     * @param viewY the gui coordinate z
+     */
+    private int drawEntry(IfaceEntry entry, int viewY, int titleBottom, int relMouseX, int relMouseY) {
+        bindTexture(BACKGROUND);
+        Tessellator.instance.startDrawingQuads();
+        int relY = 0;
+        final int slotLeftMargin = (VIEW_WIDTH - entry.rowSize * 18);
+
+        entry.dispY = viewY;
+        /* PASS 1: BG */
+        for (int row = 0; row < entry.rows; ++row) {
+            final int rowYTop = row * 18;
+            final int rowYBot = rowYTop + 18;
+
+            relY += 18;
+            /* Is the slot row in view? */
+            if (viewY + rowYBot <= titleBottom) {
+                continue;
+            }
+            for (int col = 0; col < entry.rowSize; ++col) {
+                addTexturedRectToTesselator(
+                        col * 18 + slotLeftMargin,
+                        viewY + rowYTop,
+                        18 * col + 18 + slotLeftMargin,
+                        viewY + rowYBot,
+                        0,
+                        21 / 256f,
+                        173 / 256f,
+                        (21 + 18) / 256f,
+                        (173 + 18) / 256f);
+            }
+        }
+        Tessellator.instance.draw();
+        /* Draw button */
+        if (viewY + entry.optionsButton.height > 0 && viewY < viewHeight) {
+            entry.optionsButton.yPosition = viewY + 5;
+            entry.optionsButton.drawButton(mc, relMouseX, relMouseY);
+            if (entry.optionsButton.getMouseIn()
+                    && relMouseY >= Math.max(IfaceSection.TITLE_HEIGHT, entry.optionsButton.yPosition)) {
+                // draw a tooltip
+                GL11.glTranslatef(0f, 0f, TOOLTIP_Z);
+                GL11.glDisable(GL11.GL_SCISSOR_TEST);
+                drawHoveringText(extraOptionsText, relMouseX, relMouseY);
+                GL11.glTranslatef(0f, 0f, -TOOLTIP_Z);
+                GL11.glEnable(GL11.GL_SCISSOR_TEST);
+            }
+        } else {
+            entry.optionsButton.yPosition = -1;
         }
+        /* PASS 2: Items */
+        for (int row = 0; row < entry.rows; ++row) {
+            final int rowYTop = row * 18;
+            final int rowYBot = rowYTop + 18;
+            /* Is the slot row in view? */
+            if (viewY + rowYBot <= titleBottom) {
+                continue;
+            }
+            AppEngInternalInventory inv = entry.getInventory();
+
+            for (int col = 0; col < entry.rowSize; ++col) {
+                final int colLeft = col * 18 + slotLeftMargin + 1;
+                final int colRight = colLeft + 18 + 1;
+                final int slotIdx = row * entry.rowSize + col;
+                ItemStack stack = inv.getStackInSlot(slotIdx);
+
+                boolean tooltip = relMouseX > colLeft - 1 && relMouseX < colRight - 1
+                        && relMouseY >= Math.max(viewY + rowYTop, IfaceSection.TITLE_HEIGHT)
+                        && relMouseY < Math.min(viewY + rowYBot, viewHeight);
+                if (stack != null) {
+                    final ItemEncodedPattern iep = (ItemEncodedPattern) stack.getItem();
+                    final ItemStack toRender = iep.getOutput(stack);
+
+                    GL11.glPushMatrix();
+                    GL11.glTranslatef(colLeft, viewY + rowYTop + 1, ITEMSTACK_Z);
+                    GL11.glEnable(GL12.GL_RESCALE_NORMAL);
+                    RenderHelper.enableGUIStandardItemLighting();
+                    translatedRenderItem.zLevel = 3.0f - 50.0f;
+                    translatedRenderItem
+                            .renderItemAndEffectIntoGUI(fontRendererObj, mc.getTextureManager(), toRender, 0, 0);
+                    GL11.glTranslatef(0.0f, 0.0f, ITEMSTACK_OVERLAY_Z - ITEMSTACK_Z);
+                    aeRenderItem.renderItemOverlayIntoGUI(fontRendererObj, mc.getTextureManager(), toRender, 0, 0);
+                    aeRenderItem.zLevel = 0.0f;
+                    RenderHelper.disableStandardItemLighting();
+                    if (!tooltip) {
+                        if (entry.brokenRecipes[slotIdx]) {
+                            GL11.glTranslatef(0.0f, 0.0f, SLOT_Z - ITEMSTACK_OVERLAY_Z);
+                            drawRect(0, 0, 16, 16, GuiColors.ItemSlotOverlayInvalid.getColor());
+                        } else if (entry.filteredRecipes[slotIdx]) {
+                            GL11.glTranslatef(0.0f, 0.0f, ITEMSTACK_OVERLAY_Z);
+                            drawRect(0, 0, 16, 16, GuiColors.ItemSlotOverlayUnpowered.getColor());
+                        }
+                    } else {
+                        tooltipStack = stack;
+                    }
+                    GL11.glPopMatrix();
+                } else if (entry.filteredRecipes[slotIdx]) {
+                    GL11.glPushMatrix();
+                    GL11.glTranslatef(colLeft, viewY + rowYTop + 1, ITEMSTACK_OVERLAY_Z);
+                    drawRect(0, 0, 16, 16, GuiColors.ItemSlotOverlayUnpowered.getColor());
+                    GL11.glPopMatrix();
+                }
+                if (tooltip) {
+                    // overlay highlight
+                    GL11.glDisable(GL11.GL_LIGHTING);
+                    GL11.glTranslatef(0.0f, 0.0f, SLOT_HOVER_Z);
+                    drawRect(colLeft, viewY + 1 + rowYTop, -2 + colRight, viewY - 1 + rowYBot, 0x77FFFFFF);
+                    GL11.glTranslatef(0.0f, 0.0f, -SLOT_HOVER_Z);
+                    masterList.hoveredEntry = entry;
+                    entry.hoveredSlotIdx = slotIdx;
+                }
+                GL11.glDisable(GL11.GL_LIGHTING);
+            }
+        }
+        GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+        return relY + 1;
+    }
 
-        for (int x = 0; x < this.rows && ex + x < this.lines.size(); x++) {
+    @Override
+    public List<String> handleItemTooltip(ItemStack stack, int mouseX, int mouseY, List<String> currentToolTip) {
+        return currentToolTip;
+    }
 
-            final Object lineObj = this.lines.get(ex + x);
-            if (lineObj instanceof ClientDCInternalInv inv) {
+    @Override
+    public ItemStack getHoveredStack() {
+        return tooltipStack;
+    }
 
-                GL11.glColor4f(1, 1, 1, 1);
-                final int width = inv.getInventory().getSizeInventory() * 18;
-                this.drawTexturedModalRect(offsetX + 20, offsetY + offset, 20, 173, width, 18);
+    /**
+     * A copy of super method, but modified to allow for depth testing.
+     */
+    @Override
+    public void drawHoveringText(List<String> textLines, int x, int y, FontRenderer font) {
+        if (!textLines.isEmpty()) {
+            GL11.glDisable(GL12.GL_RESCALE_NORMAL);
+            RenderHelper.disableStandardItemLighting();
+            int maxStrWidth = 0;
+
+            // is this more efficient than doing 1 pass, then doing a translate before drawing the text?
+            for (String s : textLines) {
+                int width = font.getStringWidth(s);
+
+                if (width > maxStrWidth) {
+                    maxStrWidth = width;
+                }
             }
 
-            offset += 18;
-        }
+            // top left corner
+            int curX = x + 12;
+            int curY = y - 12;
+            int totalHeight = 8;
 
-        this.drawTexturedModalRect(offsetX, offsetY + 50 + this.rows * 18, 0, 158, this.xSize, 99);
+            if (textLines.size() > 1) {
+                totalHeight += 2 + (textLines.size() - 1) * 10;
+            }
 
-        searchFieldInputs.drawTextBox();
-        searchFieldOutputs.drawTextBox();
-        searchFieldNames.drawTextBox();
+            /* String is too long? Display on the left side */
+            if (curX + maxStrWidth > this.width) {
+                curX -= 28 + maxStrWidth;
+            }
+
+            /* String is too tall? move it up */
+            if (curY + totalHeight + 6 > this.height) {
+                curY = this.height - totalHeight - 6;
+            }
+
+            int borderColor = -267386864;
+            // drawing the border...
+            this.drawGradientRect(curX - 3, curY - 4, curX + maxStrWidth + 3, curY - 3, borderColor, borderColor);
+            this.drawGradientRect(
+                    curX - 3,
+                    curY + totalHeight + 3,
+                    curX + maxStrWidth + 3,
+                    curY + totalHeight + 4,
+                    borderColor,
+                    borderColor);
+            this.drawGradientRect(
+                    curX - 3,
+                    curY - 3,
+                    curX + maxStrWidth + 3,
+                    curY + totalHeight + 3,
+                    borderColor,
+                    borderColor);
+            this.drawGradientRect(curX - 4, curY - 3, curX - 3, curY + totalHeight + 3, borderColor, borderColor);
+            this.drawGradientRect(
+                    curX + maxStrWidth + 3,
+                    curY - 3,
+                    curX + maxStrWidth + 4,
+                    curY + totalHeight + 3,
+                    borderColor,
+                    borderColor);
+            int color1 = 1347420415;
+            int color2 = (color1 & 16711422) >> 1 | color1 & -16777216;
+            this.drawGradientRect(curX - 3, curY - 3 + 1, curX - 3 + 1, curY + totalHeight + 3 - 1, color1, color2);
+            this.drawGradientRect(
+                    curX + maxStrWidth + 2,
+                    curY - 3 + 1,
+                    curX + maxStrWidth + 3,
+                    curY + totalHeight + 3 - 1,
+                    color1,
+                    color2);
+            this.drawGradientRect(curX - 3, curY - 3, curX + maxStrWidth + 3, curY - 3 + 1, color1, color1);
+            this.drawGradientRect(
+                    curX - 3,
+                    curY + totalHeight + 2,
+                    curX + maxStrWidth + 3,
+                    curY + totalHeight + 3,
+                    color2,
+                    color2);
+
+            for (int i = 0; i < textLines.size(); ++i) {
+                String line = textLines.get(i);
+                font.drawStringWithShadow(line, curX, curY, -1);
+
+                if (i == 0) {
+                    // gap between name and lore text
+                    curY += 2;
+                }
+
+                curY += 10;
+            }
+
+            RenderHelper.enableGUIStandardItemLighting();
+            GL11.glEnable(GL12.GL_RESCALE_NORMAL);
+        }
     }
 
     @Override
@@ -394,18 +691,47 @@ protected void keyTyped(final char character, final int key) {
                         || (searchFieldOutputs.getText().isEmpty() && searchFieldOutputs.isFocused())
                         || (searchFieldNames.getText().isEmpty() && searchFieldNames.isFocused()))
                     return;
-            } else if (character == '\t') {
-                if (handleTab()) return;
+            } else if (character == '\t' && handleTab()) {
+                return;
             }
             if (searchFieldInputs.textboxKeyTyped(character, key) || searchFieldOutputs.textboxKeyTyped(character, key)
                     || searchFieldNames.textboxKeyTyped(character, key)) {
-                refreshList();
+                return;
+            }
+            // if (Character.isDigit(character) && character != '0') {
+            // // move hotbar to slot
+            // if (masterList.hoveredEntry != null && masterList.hoveredEntry.hoveredSlotIdx != -1) {
+            // }
+            // }
+            super.keyTyped(character, key);
+        }
+    }
+
+    @Override
+    protected boolean mouseWheelEvent(int mouseX, int mouseY, int wheel) {
+        boolean isMouseInViewport = isMouseInViewport(mouseX, mouseY);
+        GuiScrollbar scrollbar = getScrollBar();
+        if (isMouseInViewport && isCtrlKeyDown()) {
+            if (wheel < 0) {
+                scrollbar.setCurrentScroll(masterList.getHeight());
             } else {
-                super.keyTyped(character, key);
+                getScrollBar().setCurrentScroll(0);
             }
+            return true;
+        } else if (isMouseInViewport && isShiftKeyDown()) {
+            // advance to the next section
+            return masterList.scrollNextSection(wheel > 0);
+        } else {
+            return super.mouseWheelEvent(mouseX, mouseY, wheel);
         }
     }
 
+    private boolean isMouseInViewport(int mouseX, int mouseY) {
+        return mouseX > guiLeft + VIEW_LEFT && mouseX < guiLeft + VIEW_LEFT + VIEW_WIDTH
+                && mouseY > guiTop + HEADER_HEIGHT
+                && mouseY < guiTop + HEADER_HEIGHT + viewHeight;
+    }
+
     private boolean handleTab() {
         if (searchFieldInputs.isFocused()) {
             searchFieldInputs.setFocused(false);
@@ -426,139 +752,63 @@ private boolean handleTab() {
         return false;
     }
 
-    public void postUpdate(List<PacketIfaceTermUpdate.PacketEntry> updates) {
-
-    }
-
-    public void postUpdate(final NBTTagCompound in) {
-        if (in.getBoolean("clear")) {
-            this.byId.clear();
-            this.refreshList = true;
-        }
-
-        for (final Object oKey : in.func_150296_c()) {
-            final String key = (String) oKey;
-            if (key.startsWith("=")) {
-                try {
-                    final long id = Long.parseLong(key.substring(1), Character.MAX_RADIX);
-                    final NBTTagCompound invData = in.getCompoundTag(key);
-                    int size = invData.getInteger("size");
-                    final ClientDCInternalInv current = this
-                            .getById(id, invData.getLong("sortBy"), invData.getString("un"), size);
-                    int X = invData.getInteger("x");
-                    int Y = invData.getInteger("y");
-                    int Z = invData.getInteger("z");
-                    int dim = invData.getInteger("dim");
-                    blockPosHashMap.put(current, new DimensionalCoord(X, Y, Z, dim));
-
-                    for (int x = 0; x < current.getInventory().getSizeInventory(); x++) {
-                        final String which = Integer.toString(x);
-                        if (invData.hasKey(which)) {
-                            current.getInventory().setInventorySlotContents(
-                                    x,
-                                    ItemStack.loadItemStackFromNBT(invData.getCompoundTag(which)));
-                        }
-                    }
-                } catch (final NumberFormatException ignored) {}
-            }
+    public void postUpdate(List<PacketEntry> updates, int statusFlags) {
+        if ((statusFlags & PacketIfaceTermUpdate.CLEAR_ALL_BIT) == PacketIfaceTermUpdate.CLEAR_ALL_BIT) {
+            /* Should clear all client entries. */
+            this.masterList.list.clear();
         }
+        /* Should indicate disconnected, so the terminal turns dark. */
+        this.online = (statusFlags & PacketIfaceTermUpdate.DISCONNECT_BIT) != PacketIfaceTermUpdate.DISCONNECT_BIT;
 
-        if (this.refreshList) {
-            this.refreshList = false;
-            // invalid caches on refresh
-            this.cachedSearches.clear();
-            this.refreshList();
+        for (PacketIfaceTermUpdate.PacketEntry cmd : updates) {
+            parsePacketCmd(cmd);
         }
+        this.masterList.markDirty();
     }
 
-    /**
-     * Rebuilds the list of interfaces.
-     * <p>
-     * Respects a search term if present (ignores case) and adding only matching patterns.
-     */
-    private void refreshList() {
-        this.byName.clear();
-        this.buttonList.clear();
-        this.matchedStacks.clear();
-
-        final String searchFieldInputs = this.searchFieldInputs.getText().toLowerCase();
-        final String searchFieldOutputs = this.searchFieldOutputs.getText().toLowerCase();
-        final String searchFieldNames = this.searchFieldNames.getText().toLowerCase();
-
-        final Set<Object> cachedSearch = this.getCacheForSearchTerm(
-                "IN:" + searchFieldInputs
-                        + "OUT:"
-                        + searchFieldOutputs
-                        + "NAME:"
-                        + searchFieldNames
-                        + AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal
-                        + onlyMolecularAssemblers
-                        + onlyBrokenRecipes);
-        final boolean rebuild = cachedSearch.isEmpty();
-
-        for (final ClientDCInternalInv entry : this.byId.values()) {
-            // ignore inventory if not doing a full rebuild and cache already marks it as miss.
-            if (!rebuild && !cachedSearch.contains(entry)) {
-                continue;
+    private void parsePacketCmd(PacketIfaceTermUpdate.PacketEntry cmd) {
+        long id = cmd.entryId;
+        if (cmd instanceof PacketIfaceTermUpdate.PacketAdd addCmd) {
+            IfaceEntry entry = new IfaceEntry(id, addCmd.name, addCmd.rows, addCmd.rowSize, addCmd.online)
+                    .setLocation(addCmd.x, addCmd.y, addCmd.z, addCmd.dim).setIcons(addCmd.selfRep, addCmd.dispRep)
+                    .setItems(addCmd.items);
+            masterList.addEntry(entry);
+        } else if (cmd instanceof PacketIfaceTermUpdate.PacketRemove) {
+            masterList.removeEntry(id);
+        } else if (cmd instanceof PacketIfaceTermUpdate.PacketOverwrite owCmd) {
+            IfaceEntry entry = masterList.list.get(id);
+
+            if (entry == null) {
+                return;
             }
 
-            // Shortcut to skip any filter if search term is ""/empty
-            boolean found = searchFieldInputs.isEmpty() && searchFieldOutputs.isEmpty();
-            boolean interfaceHasFreeSlots = false;
-            boolean interfaceHasBrokenRecipes = false;
-
-            // Search if the current inventory holds a pattern containing the search term.
-            if (!found || AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal || onlyBrokenRecipes) {
-                for (final ItemStack itemStack : entry.getInventory()) {
-                    // If only Interfaces with empty slots should be shown, check that here
-                    if (itemStack == null) {
-                        interfaceHasFreeSlots = true;
-                        continue;
-                    }
-
-                    if (onlyBrokenRecipes && recipeIsBroken(itemStack)) {
-                        interfaceHasBrokenRecipes = true;
-                    }
+            if (owCmd.onlineValid) {
+                entry.online = owCmd.online;
+            }
 
-                    if ((!searchFieldInputs.isEmpty() && itemStackMatchesSearchTerm(itemStack, searchFieldInputs, 0))
-                            || (!searchFieldOutputs.isEmpty()
-                                    && itemStackMatchesSearchTerm(itemStack, searchFieldOutputs, 1))) {
-                        found = true;
-                        matchedStacks.add(itemStack);
-                    }
+            if (owCmd.itemsValid) {
+                if (owCmd.allItemUpdate) {
+                    entry.fullItemUpdate(owCmd.items, owCmd.validIndices.length);
+                } else {
+                    entry.partialItemUpdate(owCmd.items, owCmd.validIndices);
                 }
             }
-
-            if ((found && entry.getName().toLowerCase().contains(searchFieldNames))
-                    && (!onlyMolecularAssemblers || entry.getUnlocalizedName().contains(MOLECULAR_ASSEMBLER))
-                    && (!AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal || interfaceHasFreeSlots)
-                    && (!onlyBrokenRecipes || interfaceHasBrokenRecipes)) {
-                this.byName.put(entry.getName(), entry);
-                cachedSearch.add(entry);
-            } else {
-                cachedSearch.remove(entry);
+            masterList.isDirty = true;
+        } else if (cmd instanceof PacketIfaceTermUpdate.PacketRename renameCmd) {
+            IfaceEntry entry = masterList.list.get(id);
+
+            if (entry != null) {
+                if (StatCollector.canTranslate(renameCmd.newName)) {
+                    entry.dispName = StatCollector.translateToLocal(renameCmd.newName);
+                } else {
+                    entry.dispName = StatCollector.translateToFallback(renameCmd.newName);
+                }
             }
+            masterList.isDirty = true;
         }
-
-        this.names.clear();
-        this.names.addAll(this.byName.keySet());
-
-        Collections.sort(this.names);
-
-        this.lines.clear();
-        this.lines.ensureCapacity(this.names.size() + this.byId.size());
-
-        for (final String n : this.names) {
-            this.lines.add(n);
-            final ArrayList<ClientDCInternalInv> clientInventories = new ArrayList<>(this.byName.get(n));
-            Collections.sort(clientInventories);
-            this.lines.addAll(clientInventories);
-        }
-
-        this.setScrollBar();
     }
 
-    private boolean itemStackMatchesSearchTerm(final ItemStack itemStack, final String searchTerm, int pass) {
+    private static boolean itemStackMatchesSearchTerm(final ItemStack itemStack, final String searchTerm, boolean in) {
         if (itemStack == null) {
             return false;
         }
@@ -569,7 +819,7 @@ private boolean itemStackMatchesSearchTerm(final ItemStack itemStack, final Stri
             return false;
         }
 
-        final NBTTagList tags = encodedValue.getTagList(pass == 0 ? "in" : "out", 10);
+        final NBTTagList tags = encodedValue.getTagList(in ? "in" : "out", NBT.TAG_COMPOUND);
         final boolean containsInvalidDisplayName = GuiText.UnknownItem.getLocal().toLowerCase().contains(searchTerm);
 
         for (int i = 0; i < tags.tagCount(); i++) {
@@ -591,7 +841,6 @@ private boolean itemStackMatchesSearchTerm(final ItemStack itemStack, final Stri
     }
 
     private boolean recipeIsBroken(final ItemStack itemStack) {
-
         if (itemStack == null) {
             return false;
         }
@@ -614,61 +863,455 @@ private boolean recipeIsBroken(final ItemStack itemStack) {
         }
     }
 
+    private int getMaxViewHeight() {
+        return AEConfig.instance.getConfigManager().getSetting(Settings.TERMINAL_STYLE) == TerminalStyle.SMALL
+                ? AEConfig.instance.InterfaceTerminalSmallSize * 18
+                : Integer.MAX_VALUE;
+    }
+
+    public boolean isOverTextField(final int mousex, final int mousey) {
+        return searchFieldInputs.isMouseIn(mousex, mousey) || searchFieldOutputs.isMouseIn(mousex, mousey)
+                || searchFieldNames.isMouseIn(mousex, mousey);
+    }
+
+    public void setTextFieldValue(final String displayName, final int mousex, final int mousey, final ItemStack stack) {
+        if (searchFieldInputs.isMouseIn(mousex, mousey)) {
+            searchFieldInputs.setText(displayName);
+        } else if (searchFieldOutputs.isMouseIn(mousex, mousey)) {
+            searchFieldOutputs.setText(displayName);
+        } else if (searchFieldNames.isMouseIn(mousex, mousey)) {
+            searchFieldNames.setText(displayName);
+        }
+    }
+
     /**
-     * Tries to retrieve a cache for a with search term as keyword.
-     * <p>
-     * If this cache should be empty, it will populate it with an earlier cache if available or at least the cache for
-     * the empty string.
-     *
-     * @param searchTerm the corresponding search
-     * @return a Set matching a superset of the search term
+     * Tracks the list of entries.
      */
-    private Set<Object> getCacheForSearchTerm(final String searchTerm) {
-        if (!this.cachedSearches.containsKey(searchTerm)) {
-            this.cachedSearches.put(searchTerm, new HashSet<>());
+    private class IfaceList {
+
+        private final Map<Long, IfaceEntry> list = new HashMap<>();
+        private final Map<String, IfaceSection> sections = new TreeMap<>();
+        private final List<IfaceSection> visibleSections = new ArrayList<>();
+        private boolean isDirty;
+        private int height;
+        private IfaceEntry hoveredEntry;
+
+        IfaceList() {
+            this.isDirty = true;
         }
 
-        final Set<Object> cache = this.cachedSearches.get(searchTerm);
+        /**
+         * Performs a full update.
+         */
+        private void update() {
+            height = 0;
+            visibleSections.clear();
+
+            for (IfaceSection section : sections.values()) {
+                String query = GuiInterfaceTerminal.this.searchFieldNames.getText();
+                if (!query.isEmpty() && !section.name.toLowerCase().contains(query.toLowerCase())) {
+                    continue;
+                }
 
-        if (cache.isEmpty() && searchTerm.length() > 1) {
-            cache.addAll(this.getCacheForSearchTerm(searchTerm.substring(0, searchTerm.length() - 1)));
-            return cache;
+                section.isDirty = true;
+                if (section.getVisible().hasNext()) {
+                    height += section.getHeight();
+                    visibleSections.add(section);
+                }
+            }
+            isDirty = false;
         }
 
-        return cache;
-    }
+        public void markDirty() {
+            this.isDirty = true;
+            setScrollBar();
+        }
 
-    private int getMaxRows() {
-        return AEConfig.instance.getConfigManager().getSetting(Settings.TERMINAL_STYLE) == TerminalStyle.SMALL
-                ? AEConfig.instance.InterfaceTerminalSmallSize
-                : Integer.MAX_VALUE;
-    }
+        public int getHeight() {
+            if (isDirty) {
+                update();
+            }
+            return height;
+        }
 
-    private ClientDCInternalInv getById(final long id, final long sortBy, final String unlocalizedName,
-            final int sizeInit) {
-        ClientDCInternalInv o = this.byId.get(id);
+        /**
+         * Jump between sections.
+         */
+        private boolean scrollNextSection(boolean up) {
+            GuiScrollbar scrollbar = getScrollBar();
+            int viewY = scrollbar.getCurrentScroll();
+            var sections = getVisibleSections();
+            boolean result = false;
+
+            if (up) {
+                int y = masterList.getHeight();
+                int i = sections.size() - 1;
+
+                while (y > 0 && i >= 0) {
+                    y -= sections.get(i).getHeight();
+                    i -= 1;
+                    if (y < viewY) {
+                        result = true;
+                        scrollbar.setCurrentScroll(y);
+                        break;
+                    }
+                }
+            } else {
+                int y = 0;
+
+                for (IfaceSection section : sections) {
+                    if (y > viewY) {
+                        result = true;
+                        scrollbar.setCurrentScroll(y);
+                        break;
+                    }
+                    y += section.getHeight();
+                }
+            }
+            return result;
+        }
+
+        public void addEntry(IfaceEntry entry) {
+            IfaceSection section = sections.get(entry.dispName);
+
+            if (section == null) {
+                section = new IfaceSection(entry.dispName);
+                sections.put(entry.dispName, section);
+            }
+            section.addEntry(entry);
+            list.put(entry.id, entry);
+            isDirty = true;
+        }
+
+        public void removeEntry(long id) {
+            IfaceEntry entry = list.remove(id);
 
-        if (o == null) {
-            this.byId.put(id, o = new ClientDCInternalInv(sizeInit, id, sortBy, unlocalizedName));
-            this.refreshList = true;
+            if (entry != null) {
+                entry.section.removeEntry(entry);
+            }
         }
 
-        return o;
+        public List<IfaceSection> getVisibleSections() {
+            if (isDirty) {
+                update();
+            }
+            return visibleSections;
+        }
+
+        /**
+         * Mouse button click.
+         *
+         * @param relMouseX viewport coords mouse X
+         * @param relMouseY viewport coords mouse Y
+         * @param btn       button code
+         */
+        public boolean mouseClicked(int relMouseX, int relMouseY, int btn) {
+            if (relMouseX < 0 || relMouseX >= VIEW_WIDTH || relMouseY < 0 || relMouseY >= viewHeight) {
+                return false;
+            }
+            for (IfaceSection section : getVisibleSections()) {
+                if (section.mouseClicked(relMouseX, relMouseY, btn)) {
+                    return true;
+                }
+            }
+            return false;
+        }
     }
 
-    public boolean isOverTextField(final int mousex, final int mousey) {
-        return searchFieldInputs.isMouseIn(mousex, mousey) || searchFieldOutputs.isMouseIn(mousex, mousey)
-                || searchFieldNames.isMouseIn(mousex, mousey);
+    /**
+     * A section holds all the interface entries with the same name.
+     */
+    private class IfaceSection {
+
+        public static final int TITLE_HEIGHT = 12;
+
+        String name;
+        List<IfaceEntry> entries = new ArrayList<>();
+        Set<IfaceEntry> visibleEntries = new TreeSet<>(Comparator.comparing(e -> {
+            if (e.dispRep != null) {
+                return e.dispRep.getDisplayName() + e.id;
+            } else {
+                return String.valueOf(e.id);
+            }
+        }));
+        int height;
+        private boolean isDirty = true;
+        boolean visible = false;
+
+        IfaceSection(String name) {
+            this.name = name;
+        }
+
+        /**
+         * Gets the height. Includes title.
+         */
+        public int getHeight() {
+            if (isDirty) {
+                update();
+            }
+            return height;
+        }
+
+        private void update() {
+            refreshVisible();
+            if (visibleEntries.isEmpty()) {
+                height = 0;
+            } else {
+                height = TITLE_HEIGHT;
+                for (IfaceEntry entry : visibleEntries) {
+                    height += entry.guiHeight;
+                }
+            }
+            isDirty = false;
+        }
+
+        public void refreshVisible() {
+            visibleEntries.clear();
+            String input = GuiInterfaceTerminal.this.searchFieldInputs.getText().toLowerCase();
+            String output = GuiInterfaceTerminal.this.searchFieldOutputs.getText().toLowerCase();
+
+            for (IfaceEntry entry : entries) {
+                var moleAss = AEApi.instance().definitions().blocks().molecularAssembler().maybeStack(1);
+                entry.dispY = -9999;
+                if (onlyMolecularAssemblers
+                        && (!moleAss.isPresent() || !Platform.isSameItem(moleAss.get(), entry.dispRep))) {
+                    continue;
+                }
+                if (AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal
+                        && entry.numItems == entry.rows * entry.rowSize) {
+                    continue;
+                }
+                if (onlyBrokenRecipes && entry.numBrokenRecipes == 0) {
+                    continue;
+                }
+                // Find search terms
+                if (!input.isEmpty() || !output.isEmpty()) {
+                    AppEngInternalInventory inv = entry.inv;
+                    boolean shouldAdd = false;
+
+                    for (int i = 0; i < inv.getSizeInventory(); ++i) {
+                        ItemStack stack = inv.getStackInSlot(i);
+                        if (itemStackMatchesSearchTerm(stack, input, true)
+                                && itemStackMatchesSearchTerm(stack, output, false)) {
+                            shouldAdd = true;
+                            entry.filteredRecipes[i] = false;
+                        } else {
+                            entry.filteredRecipes[i] = true;
+                        }
+                    }
+                    if (!shouldAdd) {
+                        continue;
+                    }
+                } else {
+                    Arrays.fill(entry.filteredRecipes, false);
+                }
+                visibleEntries.add(entry);
+            }
+        }
+
+        public void addEntry(IfaceEntry entry) {
+            this.entries.add(entry);
+            entry.section = this;
+            this.isDirty = true;
+        }
+
+        public void removeEntry(IfaceEntry entry) {
+            this.entries.remove(entry);
+            entry.section = null;
+            this.isDirty = true;
+        }
+
+        public Iterator<IfaceEntry> getVisible() {
+            if (isDirty) {
+                update();
+            }
+            return visibleEntries.iterator();
+        }
+
+        public boolean mouseClicked(int relMouseX, int relMouseY, int btn) {
+            Iterator<IfaceEntry> it = getVisible();
+            boolean ret = false;
+
+            while (it.hasNext() && !ret) {
+                ret = it.next().mouseClicked(relMouseX, relMouseY, btn);
+            }
+
+            return ret;
+        }
     }
 
-    public void setTextFieldValue(final String displayName, final int mousex, final int mousey, final ItemStack stack) {
+    /**
+     * This class keeps track of an entry and its widgets.
+     */
+    private class IfaceEntry {
+
+        String dispName;
+        AppEngInternalInventory inv;
+        GuiImgButton optionsButton;
+        /** Nullable - icon that represents the interface */
+        ItemStack selfRep;
+        /** Nullable - icon that represents the interface's "target" */
+        ItemStack dispRep;
+        IfaceSection section;
+        long id;
+        int x, y, z, dim;
+        int rows, rowSize;
+        int guiHeight;
+        int dispY = -9999;
+        boolean online;
+        int numBrokenRecipes;
+        boolean[] brokenRecipes;
+        int numItems = 0;
+        /** Should recipe be filtered out/grayed out? */
+        boolean[] filteredRecipes;
+        private int hoveredSlotIdx = -1;
+
+        IfaceEntry(long id, String name, int rows, int rowSize, boolean online) {
+            this.id = id;
+            if (StatCollector.canTranslate(name)) {
+                this.dispName = StatCollector.translateToLocal(name);
+            } else {
+                String fallback = name + ".name"; // its whatever. save some bytes on network but looks ugly
+                if (StatCollector.canTranslate(fallback)) {
+                    this.dispName = StatCollector.translateToLocal(fallback);
+                } else {
+                    this.dispName = StatCollector.translateToFallback(name);
+                }
+            }
+            this.inv = new AppEngInternalInventory(null, rows * rowSize, 1);
+            this.rows = rows;
+            this.rowSize = rowSize;
+            this.online = online;
+            this.optionsButton = new GuiImgButton(2, 0, Settings.ACTIONS, ActionItems.HIGHLIGHT_INTERFACE);
+            this.optionsButton.setHalfSize(true);
+            this.guiHeight = 18 * rows + 1;
+            this.brokenRecipes = new boolean[rows * rowSize];
+            this.filteredRecipes = new boolean[rows * rowSize];
+        }
 
-        if (searchFieldInputs.isMouseIn(mousex, mousey)) {
-            searchFieldInputs.setText(displayName);
-        } else if (searchFieldOutputs.isMouseIn(mousex, mousey)) {
-            searchFieldOutputs.setText(displayName);
-        } else if (searchFieldNames.isMouseIn(mousex, mousey)) {
-            searchFieldNames.setText(displayName);
+        IfaceEntry setLocation(int x, int y, int z, int dim) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            this.dim = dim;
+
+            return this;
+        }
+
+        IfaceEntry setIcons(ItemStack selfRep, ItemStack dispRep) {
+            // Kotlin would make this pretty easy :(
+            this.selfRep = selfRep;
+            this.dispRep = dispRep;
+
+            return this;
+        }
+
+        public void fullItemUpdate(NBTTagList items, int newSize) {
+            inv = new AppEngInternalInventory(null, newSize);
+            rows = newSize / rowSize;
+            brokenRecipes = new boolean[newSize];
+            numItems = 0;
+
+            for (int i = 0; i < inv.getSizeInventory(); ++i) {
+                setItemInSlot(ItemStack.loadItemStackFromNBT(items.getCompoundTagAt(i)), i);
+            }
+            this.guiHeight = 18 * rows + 4;
+        }
+
+        IfaceEntry setItems(NBTTagList items) {
+            assert items.tagCount() == inv.getSizeInventory();
+
+            for (int i = 0; i < items.tagCount(); ++i) {
+                setItemInSlot(ItemStack.loadItemStackFromNBT(items.getCompoundTagAt(i)), i);
+            }
+            return this;
+        }
+
+        public void partialItemUpdate(NBTTagList items, int[] validIndices) {
+            for (int i = 0; i < validIndices.length; ++i) {
+                setItemInSlot(ItemStack.loadItemStackFromNBT(items.getCompoundTagAt(i)), validIndices[i]);
+            }
+        }
+
+        private void setItemInSlot(ItemStack stack, int idx) {
+            final int oldBroke = brokenRecipes[idx] ? 1 : 0;
+            final int newBroke = recipeIsBroken(stack) ? 1 : 0;
+            final int oldHasItem = inv.getStackInSlot(idx) != null ? 1 : 0;
+            final int newHasItem = stack != null ? 1 : 0;
+
+            // Update broken recipe count
+            numBrokenRecipes += newBroke - oldBroke;
+            brokenRecipes[idx] = newBroke == 1;
+            inv.setInventorySlotContents(idx, stack);
+            assert numBrokenRecipes >= 0;
+            // Update item count
+            numItems += newHasItem - oldHasItem;
+            assert numItems >= 0;
+        }
+
+        public AppEngInternalInventory getInventory() {
+            return inv;
+        }
+
+        public boolean mouseClicked(int mouseX, int mouseY, int btn) {
+            if (!section.visible || btn < 0 || btn > 2) {
+                return false;
+            }
+            if (mouseX >= optionsButton.xPosition && mouseX < 2 + optionsButton.width
+                    && mouseY > Math.max(optionsButton.yPosition, IfaceSection.TITLE_HEIGHT)
+                    && mouseY <= Math.min(optionsButton.yPosition + optionsButton.height, viewHeight)) {
+                optionsButton.func_146113_a(mc.getSoundHandler());
+                DimensionalCoord blockPos = new DimensionalCoord(x, y, z, dim);
+                /* View in world */
+                WorldCoord blockPos2 = new WorldCoord(
+                        (int) mc.thePlayer.posX,
+                        (int) mc.thePlayer.posY,
+                        (int) mc.thePlayer.posZ);
+                if (mc.theWorld.provider.dimensionId != dim) {
+                    mc.thePlayer.addChatMessage(
+                            new ChatComponentTranslation(PlayerMessages.InterfaceInOtherDim.getName(), dim));
+                } else {
+                    BlockPosHighlighter.highlightBlock(
+                            blockPos,
+                            System.currentTimeMillis() + 500 * WorldCoord.getTaxicabDistance(blockPos, blockPos2));
+                    mc.thePlayer.addChatMessage(
+                            new ChatComponentTranslation(
+                                    PlayerMessages.InterfaceHighlighted.getName(),
+                                    blockPos.x,
+                                    blockPos.y,
+                                    blockPos.z));
+                }
+                mc.thePlayer.closeScreen();
+                return true;
+            }
+
+            int offsetY = mouseY - dispY;
+            int offsetX = mouseX - (VIEW_WIDTH - rowSize * 18) - 1;
+            if (offsetX >= 0 && offsetX < (rowSize * 18)
+                    && mouseY > Math.max(dispY, IfaceSection.TITLE_HEIGHT)
+                    && offsetY < Math.min(viewHeight - dispY, guiHeight)) {
+                final int col = offsetX / 18;
+                final int row = offsetY / 18;
+                final int slotIdx = row * rowSize + col;
+
+                // send packet to server, request an update
+                // TODO: Client prediction.
+                PacketInventoryAction packet;
+
+                if (Keyboard.isKeyDown(Keyboard.KEY_SPACE)) {
+                    packet = new PacketInventoryAction(InventoryAction.MOVE_REGION, 0, id);
+                } else if (isShiftKeyDown() && (btn == 0 || btn == 1)) {
+                    packet = new PacketInventoryAction(InventoryAction.SHIFT_CLICK, slotIdx, id);
+                } else if (btn == 0 || btn == 1) {
+                    packet = new PacketInventoryAction(InventoryAction.PICKUP_OR_SET_DOWN, slotIdx, id);
+                } else {
+                    packet = new PacketInventoryAction(InventoryAction.CREATIVE_DUPLICATE, slotIdx, id);
+                }
+                NetworkHandler.instance.sendToServer(packet);
+                return true;
+            }
+
+            return false;
         }
     }
 }
diff --git a/src/main/resources/assets/appliedenergistics2/textures/guis/newinterfaceterminal.png b/src/main/resources/assets/appliedenergistics2/textures/guis/newinterfaceterminal.png
index 187e3d02a6d0f39d46f086652260dd80ee24bab9..6dd010c5ae7bbdae6190a34eb7c1b1860f471a67 100644
GIT binary patch
literal 3350
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
Q=y4mkJ9{}*Y^A3E4RqdDn*aa+

literal 4082
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
NS`w1uw~UxH<KN>UaNz&|


From 1e51d194fe646bce301e280ce6a3636d124e2844 Mon Sep 17 00:00:00 2001
From: Andrei Antropov <q.laiff@gmail.com>
Date: Sat, 14 Oct 2023 12:55:10 +0300
Subject: [PATCH 12/22] Add interface compatibility to use in `ae2fc` (#404)

---
 .../implementations/ContainerInterfaceTerminal.java   | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java b/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
index 2b9dbb6c1ca..600c6edf538 100644
--- a/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
+++ b/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
@@ -33,6 +33,7 @@
 
 import appeng.api.networking.IGrid;
 import appeng.api.networking.IGridNode;
+import appeng.api.networking.security.IActionHost;
 import appeng.api.util.DimensionalCoord;
 import appeng.api.util.IIfaceTermViewable;
 import appeng.container.AEBaseContainer;
@@ -56,13 +57,13 @@ public final class ContainerInterfaceTerminal extends AEBaseContainer {
     private PacketIfaceTermUpdate dirty;
     private boolean isDirty;
     private IGrid grid;
-    private PartInterfaceTerminal partRef;
+    private IActionHost anchor;
     private boolean wasOff;
 
-    public ContainerInterfaceTerminal(final InventoryPlayer ip, final PartInterfaceTerminal anchor) {
+    public ContainerInterfaceTerminal(final InventoryPlayer ip, final IActionHost anchor) {
         super(ip, anchor);
         assert anchor != null;
-        this.partRef = anchor;
+        this.anchor = anchor;
         if (Platform.isServer()) {
             this.grid = anchor.getActionableNode().getGrid();
             dirty = this.updateList();
@@ -88,7 +89,7 @@ public void detectAndSendChanges() {
             return;
         }
 
-        final IGridNode agn = this.partRef.getActionableNode();
+        final IGridNode agn = this.anchor.getActionableNode();
 
         if (!agn.isActive()) {
             /*
@@ -107,7 +108,7 @@ public void detectAndSendChanges() {
         }
         this.wasOff = false;
 
-        if (this.partRef.needsUpdate()) {
+        if (anchor instanceof PartInterfaceTerminal terminal && terminal.needsUpdate()) {
             PacketIfaceTermUpdate update = this.updateList();
             if (update != null) {
                 update.encode();

From 0f3a7eb6067ff47fe533a6009c3f4a0466495bce Mon Sep 17 00:00:00 2001
From: Andrei Antropov <q.laiff@gmail.com>
Date: Sat, 14 Oct 2023 15:36:39 +0300
Subject: [PATCH 13/22] Add interface compatibility to use in `ae2fc` and
 direction tracking (#405)

---
 .../gui/IInterfaceTerminalPostUpdate.java      | 16 ++++++++++++++++
 .../implementations/GuiInterfaceTerminal.java  |  5 ++++-
 .../ContainerInterfaceTerminal.java            | 18 +++++-------------
 .../sync/packets/PacketIfaceTermUpdate.java    | 15 +++++++++------
 4 files changed, 34 insertions(+), 20 deletions(-)
 create mode 100644 src/main/java/appeng/client/gui/IInterfaceTerminalPostUpdate.java

diff --git a/src/main/java/appeng/client/gui/IInterfaceTerminalPostUpdate.java b/src/main/java/appeng/client/gui/IInterfaceTerminalPostUpdate.java
new file mode 100644
index 00000000000..8b35d136a42
--- /dev/null
+++ b/src/main/java/appeng/client/gui/IInterfaceTerminalPostUpdate.java
@@ -0,0 +1,16 @@
+package appeng.client.gui;
+
+import java.util.List;
+
+import appeng.core.sync.packets.PacketIfaceTermUpdate.PacketEntry;
+
+public interface IInterfaceTerminalPostUpdate {
+
+    /**
+     * Interface to handle updates inside interface terminal
+     *
+     * @param updates     List of updates
+     * @param statusFlags status bitflags
+     */
+    void postUpdate(List<PacketEntry> updates, int statusFlags);
+}
diff --git a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
index f62667b2f52..27d3e46a742 100644
--- a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
+++ b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
@@ -48,6 +48,7 @@
 import appeng.api.util.WorldCoord;
 import appeng.client.gui.AEBaseGui;
 import appeng.client.gui.IGuiTooltipHandler;
+import appeng.client.gui.IInterfaceTerminalPostUpdate;
 import appeng.client.gui.widgets.GuiImgButton;
 import appeng.client.gui.widgets.GuiScrollbar;
 import appeng.client.gui.widgets.IDropToFillTextField;
@@ -89,7 +90,8 @@
  *
  * @author firenoo
  */
-public class GuiInterfaceTerminal extends AEBaseGui implements IDropToFillTextField, IGuiTooltipHandler {
+public class GuiInterfaceTerminal extends AEBaseGui
+        implements IDropToFillTextField, IGuiTooltipHandler, IInterfaceTerminalPostUpdate {
 
     public static final int HEADER_HEIGHT = 52;
     public static final int INV_HEIGHT = 98;
@@ -752,6 +754,7 @@ private boolean handleTab() {
         return false;
     }
 
+    @Override
     public void postUpdate(List<PacketEntry> updates, int statusFlags) {
         if ((statusFlags & PacketIfaceTermUpdate.CLEAR_ALL_BIT) == PacketIfaceTermUpdate.CLEAR_ALL_BIT) {
             /* Should clear all client entries. */
diff --git a/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java b/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
index 600c6edf538..8a0dac36113 100644
--- a/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
+++ b/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
@@ -42,6 +42,7 @@
 import appeng.core.sync.packets.PacketIfaceTermUpdate;
 import appeng.helpers.InventoryAction;
 import appeng.items.misc.ItemEncodedPattern;
+import appeng.parts.AEBasePart;
 import appeng.parts.reporting.PartInterfaceTerminal;
 import appeng.util.InventoryAdaptor;
 import appeng.util.Platform;
@@ -305,7 +306,8 @@ private PacketIfaceTermUpdate updateList() {
                     /* Add a new entry */
                     if (update == null) update = new PacketIfaceTermUpdate();
                     InvTracker entry = new InvTracker(nextId++, machine, node.isActive());
-                    update.addNewEntry(entry.id, entry.name, entry.online).setLoc(entry.x, entry.y, entry.z, entry.dim)
+                    update.addNewEntry(entry.id, entry.name, entry.online)
+                            .setLoc(entry.x, entry.y, entry.z, entry.dim, entry.side.ordinal())
                             .setItems(entry.rows, entry.rowSize, entry.invNbt)
                             .setReps(machine.getSelfRep(), machine.getDisplayRep());
                     tracked.put(machine, entry);
@@ -355,6 +357,7 @@ private static class InvTracker {
         private final int y;
         private final int z;
         private final int dim;
+        private final ForgeDirection side;
         private boolean online;
         private NBTTagList invNbt;
 
@@ -370,6 +373,7 @@ private static class InvTracker {
             this.y = location.y;
             this.z = location.z;
             this.dim = location.getDimension();
+            this.side = machine instanceof AEBasePart hasSide ? hasSide.getSide() : ForgeDirection.UNKNOWN;
             this.online = online;
             this.invNbt = new NBTTagList();
             updateNBT();
@@ -409,16 +413,4 @@ private void updateNBT() {
             }
         }
     }
-    //
-    // private static class PatternInvSlot extends WrapperInvSlot {
-    //
-    // public PatternInvSlot(final IInventory inv) {
-    // super(inv);
-    // }
-    //
-    // @Override
-    // public boolean isItemValid(final ItemStack itemstack) {
-    // return itemstack != null && itemstack.getItem() instanceof ItemEncodedPattern;
-    // }
-    // }
 }
diff --git a/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java b/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java
index e7c5e6b585c..627005dbcbd 100644
--- a/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java
+++ b/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java
@@ -13,7 +13,7 @@
 import net.minecraft.nbt.NBTTagList;
 import net.minecraftforge.common.util.Constants.NBT;
 
-import appeng.client.gui.implementations.GuiInterfaceTerminal;
+import appeng.client.gui.IInterfaceTerminalPostUpdate;
 import appeng.core.AELog;
 import appeng.core.sync.AppEngPacket;
 import appeng.core.sync.network.INetworkInfo;
@@ -103,7 +103,7 @@ public void setDisconnect() {
 
     /**
      * Adds a new entry. Fill out the rest of the command using the {@link PacketAdd#setItems(int, int, NBTTagList)} and
-     * {@link PacketAdd#setLoc(int, int, int, int)}.
+     * {@link PacketAdd#setLoc(int, int, int, int, int)}.
      *
      * @return the packet, which needs to have information filled out.
      */
@@ -143,8 +143,8 @@ public PacketOverwrite addOverwriteEntry(long id) {
     public void clientPacketData(final INetworkInfo network, final AppEngPacket packet, final EntityPlayer player) {
         final GuiScreen gs = Minecraft.getMinecraft().currentScreen;
 
-        if (gs instanceof GuiInterfaceTerminal) {
-            ((GuiInterfaceTerminal) gs).postUpdate(this.commands, this.statusFlags);
+        if (gs instanceof IInterfaceTerminalPostUpdate hasPostUpdate) {
+            hasPostUpdate.postUpdate(this.commands, this.statusFlags);
         }
     }
 
@@ -198,7 +198,7 @@ protected PacketEntry(ByteBuf buf) throws IOException {
     public static class PacketAdd extends PacketEntry {
 
         public String name;
-        public int x, y, z, dim;
+        public int x, y, z, dim, side;
         public int rows, rowSize;
         public boolean online;
         public ItemStack selfRep, dispRep;
@@ -214,11 +214,12 @@ public static class PacketAdd extends PacketEntry {
             super(buf);
         }
 
-        public PacketAdd setLoc(int x, int y, int z, int dim) {
+        public PacketAdd setLoc(int x, int y, int z, int dim, int side) {
             this.x = x;
             this.y = y;
             this.z = z;
             this.dim = dim;
+            this.side = side;
             return this;
         }
 
@@ -252,6 +253,7 @@ protected void write(ByteBuf buf) throws IOException {
             buf.writeInt(y);
             buf.writeInt(z);
             buf.writeInt(dim);
+            buf.writeInt(side);
             buf.writeInt(rows);
             buf.writeInt(rowSize);
 
@@ -284,6 +286,7 @@ protected void read(ByteBuf buf) throws IOException {
             this.y = buf.readInt();
             this.z = buf.readInt();
             this.dim = buf.readInt();
+            this.side = buf.readInt();
             this.rows = buf.readInt();
             this.rowSize = buf.readInt();
             int payloadSize = buf.readInt();

From 3d3af96509fd01b0e20a6d78c0571ec898c058ac Mon Sep 17 00:00:00 2001
From: Andrei Laiff <q.laiff@gmail.com>
Date: Sun, 15 Oct 2023 13:14:44 +0300
Subject: [PATCH 14/22] Fix rendering inside `InterfaceTerminal` AEStack should
 be correctly set

---
 .../appeng/client/gui/implementations/GuiInterfaceTerminal.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
index 27d3e46a742..66a370d852a 100644
--- a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
+++ b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
@@ -75,6 +75,7 @@
 import appeng.parts.reporting.PartInterfaceTerminal;
 import appeng.tile.inventory.AppEngInternalInventory;
 import appeng.util.Platform;
+import appeng.util.item.AEItemStack;
 import cpw.mods.fml.common.Loader;
 
 /**
@@ -539,6 +540,7 @@ private int drawEntry(IfaceEntry entry, int viewY, int titleBottom, int relMouse
                     translatedRenderItem
                             .renderItemAndEffectIntoGUI(fontRendererObj, mc.getTextureManager(), toRender, 0, 0);
                     GL11.glTranslatef(0.0f, 0.0f, ITEMSTACK_OVERLAY_Z - ITEMSTACK_Z);
+                    aeRenderItem.setAeStack(AEItemStack.create(toRender));
                     aeRenderItem.renderItemOverlayIntoGUI(fontRendererObj, mc.getTextureManager(), toRender, 0, 0);
                     aeRenderItem.zLevel = 0.0f;
                     RenderHelper.disableStandardItemLighting();

From 38ceda920071bc38d85cf98a40c88fda0fe89c89 Mon Sep 17 00:00:00 2001
From: Andrei Laiff <q.laiff@gmail.com>
Date: Sun, 15 Oct 2023 14:36:00 +0300
Subject: [PATCH 15/22] Fix `zLevel` in `TranslatedRenderItem` for durability
 bar

---
 src/main/java/appeng/client/render/TranslatedRenderItem.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main/java/appeng/client/render/TranslatedRenderItem.java b/src/main/java/appeng/client/render/TranslatedRenderItem.java
index 19784fdceac..028b513cb8d 100644
--- a/src/main/java/appeng/client/render/TranslatedRenderItem.java
+++ b/src/main/java/appeng/client/render/TranslatedRenderItem.java
@@ -29,6 +29,7 @@ public void renderItemOverlayIntoGUI(FontRenderer font, TextureManager texManage
             }
 
             if (stack.getItem().showDurabilityBar(stack)) {
+                GL11.glTranslatef(0.0f, 0.0f, this.zLevel - 1f);
                 double health = stack.getItem().getDurabilityForDisplay(stack);
                 int j1 = (int) Math.round(13.0D - health * 13.0D);
                 int k = (int) Math.round(255.0D - health * 255.0D);
@@ -48,6 +49,7 @@ public void renderItemOverlayIntoGUI(FontRenderer font, TextureManager texManage
                 GL11.glEnable(GL11.GL_TEXTURE_2D);
                 GL11.glEnable(GL11.GL_LIGHTING);
                 GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+                GL11.glTranslatef(0.0f, 0.0f, -(this.zLevel - 1f));
             }
             GL11.glPopMatrix();
         }

From c493a4f081485d07d9de89d97ba1ef1be2dfc192 Mon Sep 17 00:00:00 2001
From: Andrei Laiff <q.laiff@gmail.com>
Date: Sun, 15 Oct 2023 14:47:10 +0300
Subject: [PATCH 16/22] Fix `TranslatedRenderItem` integrate `POST_HOOKS` to
 support DuraDisplay

---
 .../client/render/TranslatedRenderItem.java   | 21 +++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/main/java/appeng/client/render/TranslatedRenderItem.java b/src/main/java/appeng/client/render/TranslatedRenderItem.java
index 028b513cb8d..122e3c9747f 100644
--- a/src/main/java/appeng/client/render/TranslatedRenderItem.java
+++ b/src/main/java/appeng/client/render/TranslatedRenderItem.java
@@ -1,5 +1,7 @@
 package appeng.client.render;
 
+import static appeng.client.render.AppEngRenderItem.POST_HOOKS;
+
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.client.renderer.entity.RenderItem;
@@ -8,6 +10,8 @@
 
 import org.lwjgl.opengl.GL11;
 
+import appeng.api.storage.IItemDisplayRegistry.ItemRenderHook;
+
 /**
  * Uses translations instead of depth test to perform rendering.
  */
@@ -17,8 +21,21 @@ public class TranslatedRenderItem extends RenderItem {
     public void renderItemOverlayIntoGUI(FontRenderer font, TextureManager texManager, ItemStack stack, int x, int y,
             String customText) {
         if (stack != null) {
+            boolean skip = false;
+            boolean showDurabilitybar = true;
+            boolean showStackSize = true;
+            boolean showCraftLabelText = true;
+            for (ItemRenderHook hook : POST_HOOKS) {
+                skip |= hook.renderOverlay(font, texManager, stack, x, y);
+                showDurabilitybar &= hook.showDurability(stack);
+                showStackSize &= hook.showStackSize(stack);
+                showCraftLabelText &= hook.showCraftLabelText(stack);
+            }
+            if (skip) {
+                return;
+            }
             GL11.glPushMatrix();
-            if (stack.stackSize > 1 || customText != null) {
+            if ((showStackSize && stack.stackSize > 1) || (showCraftLabelText && customText != null)) {
                 GL11.glTranslatef(0.0f, 0.0f, this.zLevel);
                 String s1 = customText == null ? String.valueOf(stack.stackSize) : customText;
                 GL11.glDisable(GL11.GL_LIGHTING);
@@ -28,7 +45,7 @@ public void renderItemOverlayIntoGUI(FontRenderer font, TextureManager texManage
                 GL11.glTranslatef(0.0f, 0.0f, -this.zLevel);
             }
 
-            if (stack.getItem().showDurabilityBar(stack)) {
+            if (showDurabilitybar && stack.getItem().showDurabilityBar(stack)) {
                 GL11.glTranslatef(0.0f, 0.0f, this.zLevel - 1f);
                 double health = stack.getItem().getDurabilityForDisplay(stack);
                 int j1 = (int) Math.round(13.0D - health * 13.0D);

From 0a366d69d47d09e0b7666e364c685a934b231ee4 Mon Sep 17 00:00:00 2001
From: Andrei Laiff <q.laiff@gmail.com>
Date: Sat, 21 Oct 2023 00:46:06 +0300
Subject: [PATCH 17/22] Fix buffer read write inconsistency

---
 .../ContainerInterfaceTerminal.java           |   1 -
 .../sync/packets/PacketIfaceTermUpdate.java   | 177 +++++++++++++++---
 2 files changed, 156 insertions(+), 22 deletions(-)

diff --git a/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java b/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
index 8a0dac36113..85f7ab71637 100644
--- a/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
+++ b/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
@@ -69,7 +69,6 @@ public ContainerInterfaceTerminal(final InventoryPlayer ip, final IActionHost an
             this.grid = anchor.getActionableNode().getGrid();
             dirty = this.updateList();
             if (dirty != null) {
-                dirty.encode();
                 this.isDirty = true;
             } else {
                 dirty = new PacketIfaceTermUpdate();
diff --git a/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java b/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java
index 627005dbcbd..f150ad318c9 100644
--- a/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java
+++ b/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java
@@ -2,7 +2,9 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiScreen;
@@ -12,9 +14,12 @@
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
 import net.minecraftforge.common.util.Constants.NBT;
+import net.minecraftforge.common.util.ForgeDirection;
 
 import appeng.client.gui.IInterfaceTerminalPostUpdate;
+import appeng.core.AEConfig;
 import appeng.core.AELog;
+import appeng.core.features.AEFeature;
 import appeng.core.sync.AppEngPacket;
 import appeng.core.sync.network.INetworkInfo;
 import appeng.helpers.Reflected;
@@ -50,9 +55,8 @@ private void decode(ByteBuf buf) {
         int numEntries = buf.readInt();
 
         for (int i = 0; i < numEntries; ++i) {
-            int packetType = -1;
             try {
-                packetType = buf.readByte();
+                int packetType = buf.readByte();
                 PacketType type = PacketType.valueOf(packetType);
                 switch (type) {
                     case ADD -> this.commands.add(new PacketAdd(buf));
@@ -61,17 +65,49 @@ private void decode(ByteBuf buf) {
                     case RENAME -> this.commands.add(new PacketRename(buf));
                 }
             } catch (ArrayIndexOutOfBoundsException e) {
-                AELog.error("Unknown packet type of type %d (-1 = uninitialized)", packetType);
-                break;
+                if (AEConfig.instance.isFeatureEnabled(AEFeature.PacketLogging)) {
+                    AELog.info(
+                            "Corrupted packet commands: (" + i
+                                    + ") of ("
+                                    + numEntries
+                                    + ") -> "
+                                    + this.commands.size()
+                                    + " : "
+                                    + this.commands.stream().map(packetEntry -> packetEntry.getClass().getSimpleName())
+                                            .collect(Collectors.groupingBy(String::new, Collectors.counting())));
+                    if (AEConfig.instance.isFeatureEnabled(AEFeature.DebugLogging)) {
+                        AELog.info(" <- Parsed content: " + this.commands);
+                    }
+                }
+                AELog.debug(e);
+                return;
             } catch (IOException e) {
                 AELog.error(e);
                 break;
             }
         }
+        if (AEConfig.instance.isFeatureEnabled(AEFeature.PacketLogging)) {
+            AELog.info(
+                    " <- Received commands " + this.commands.size()
+                            + " : "
+                            + this.commands.stream().map(packetEntry -> packetEntry.getClass().getSimpleName())
+                                    .collect(Collectors.groupingBy(String::new, Collectors.counting())));
+        }
     }
 
     public void encode() {
         try {
+            if (AEConfig.instance.isFeatureEnabled(AEFeature.PacketLogging)) {
+                AELog.info(
+                        " -> Sent commands " + this.commands.size()
+                                + " : "
+                                + this.commands.stream().map(packetEntry -> packetEntry.getClass().getSimpleName())
+                                        .collect(Collectors.groupingBy(String::new, Collectors.counting())));
+                if (AEConfig.instance.isFeatureEnabled(AEFeature.DebugLogging)) {
+                    AELog.info(" -> Sent commands: " + this.commands);
+                }
+            }
+
             ByteBuf buf = Unpooled.buffer(2048);
             buf.writeInt(this.getPacketID());
             buf.writeByte(this.statusFlags);
@@ -257,21 +293,21 @@ protected void write(ByteBuf buf) throws IOException {
             buf.writeInt(rows);
             buf.writeInt(rowSize);
 
-            ByteBuf tempBuf = Unpooled.buffer(256);
-            try (ByteBufOutputStream stream = new ByteBufOutputStream(tempBuf)) {
+            ByteBuf tempBuf = Unpooled.directBuffer(256);
+            try {
+                try (ByteBufOutputStream stream = new ByteBufOutputStream(tempBuf)) {
 
-                NBTTagCompound wrapper = new NBTTagCompound();
+                    NBTTagCompound wrapper = new NBTTagCompound();
 
-                if (selfRep != null) {
-                    wrapper.setTag("self", selfRep.writeToNBT(new NBTTagCompound()));
-                }
-                if (dispRep != null) {
-                    wrapper.setTag("disp", dispRep.writeToNBT(new NBTTagCompound()));
+                    if (selfRep != null) {
+                        wrapper.setTag("self", selfRep.writeToNBT(new NBTTagCompound()));
+                    }
+                    if (dispRep != null) {
+                        wrapper.setTag("disp", dispRep.writeToNBT(new NBTTagCompound()));
+                    }
+                    wrapper.setTag("data", items);
+                    CompressedStreamTools.writeCompressed(wrapper, stream);
                 }
-                wrapper.setTag("data", items);
-                CompressedStreamTools.writeCompressed(wrapper, stream);
-            }
-            try {
                 buf.writeInt(tempBuf.readableBytes());
                 buf.writeBytes(tempBuf);
             } finally {
@@ -292,6 +328,27 @@ protected void read(ByteBuf buf) throws IOException {
             int payloadSize = buf.readInt();
             try (ByteBufInputStream stream = new ByteBufInputStream(buf, payloadSize)) {
                 NBTTagCompound payload = CompressedStreamTools.readCompressed(stream);
+                int available = stream.available();
+                if (available > 0) {
+                    byte[] left = new byte[available];
+                    int read = stream.read(left);
+                    if (AEConfig.instance.isFeatureEnabled(AEFeature.PacketLogging)) {
+                        AELog.info(
+                                "Unread bytes detected (" + read
+                                        + "): "
+                                        + Arrays.toString(left)
+                                        + " at "
+                                        + dim
+                                        + "#("
+                                        + x
+                                        + ":"
+                                        + y
+                                        + ":"
+                                        + z
+                                        + ")@"
+                                        + ForgeDirection.getOrientation(side));
+                    }
+                }
                 if (payload.hasKey("self", NBT.TAG_COMPOUND)) {
                     this.selfRep = ItemStack.loadItemStackFromNBT(payload.getCompoundTag("self"));
                 }
@@ -303,6 +360,38 @@ protected void read(ByteBuf buf) throws IOException {
                 this.items = payload.getTagList("data", NBT.TAG_COMPOUND);
             }
         }
+
+        @Override
+        public String toString() {
+            return "PacketAdd{" + "name='"
+                    + name
+                    + '\''
+                    + ", x="
+                    + x
+                    + ", y="
+                    + y
+                    + ", z="
+                    + z
+                    + ", dim="
+                    + dim
+                    + ", side="
+                    + side
+                    + ", rows="
+                    + rows
+                    + ", rowSize="
+                    + rowSize
+                    + ", online="
+                    + online
+                    + ", selfRep="
+                    + selfRep
+                    + ", dispRep="
+                    + dispRep
+                    + ", items="
+                    + items
+                    + ", entryId="
+                    + entryId
+                    + '}';
+        }
     }
 
     public static class PacketRemove extends PacketEntry {
@@ -323,6 +412,11 @@ protected void write(ByteBuf buf) {
 
         @Override
         protected void read(ByteBuf buf) {}
+
+        @Override
+        public String toString() {
+            return "PacketRemove{" + "entryId=" + entryId + '}';
+        }
     }
 
     /**
@@ -387,13 +481,21 @@ protected void write(ByteBuf buf) throws IOException {
                         buf.writeInt(validIndex);
                     }
                 }
-                try (ByteBufOutputStream stream = new ByteBufOutputStream(buf)) {
+                ByteBuf tempBuf = Unpooled.directBuffer(256);
+                try {
+                    try (ByteBufOutputStream stream = new ByteBufOutputStream(tempBuf)) {
 
-                    NBTTagCompound wrapper = new NBTTagCompound();
+                        NBTTagCompound wrapper = new NBTTagCompound();
 
-                    wrapper.setTag("data", items);
-                    CompressedStreamTools.writeCompressed(wrapper, stream);
+                        wrapper.setTag("data", items);
+                        CompressedStreamTools.writeCompressed(wrapper, stream);
+                    }
+                    buf.writeInt(tempBuf.readableBytes());
+                    buf.writeBytes(tempBuf);
+                } finally {
+                    tempBuf.release();
                 }
+
             } else {
                 buf.writeByte(flags);
             }
@@ -421,11 +523,39 @@ protected void read(ByteBuf buf) throws IOException {
                     }
                 }
 
-                try (ByteBufInputStream stream = new ByteBufInputStream(buf)) {
+                int payloadSize = buf.readInt();
+                try (ByteBufInputStream stream = new ByteBufInputStream(buf, payloadSize)) {
                     this.items = CompressedStreamTools.readCompressed(stream).getTagList("data", NBT.TAG_COMPOUND);
+                    int available = stream.available();
+                    if (available > 0) {
+                        byte[] left = new byte[available];
+                        int read = stream.read(left);
+                        if (AEConfig.instance.isFeatureEnabled(AEFeature.PacketLogging)) {
+                            AELog.info("Unread bytes detected (" + read + "): " + Arrays.toString(left));
+                        }
+                    }
                 }
             }
         }
+
+        @Override
+        public String toString() {
+            return "PacketOverwrite{" + "onlineValid="
+                    + onlineValid
+                    + ", online="
+                    + online
+                    + ", itemsValid="
+                    + itemsValid
+                    + ", allItemUpdate="
+                    + allItemUpdate
+                    + ", validIndices="
+                    + Arrays.toString(validIndices)
+                    + ", items="
+                    + items
+                    + ", entryId="
+                    + entryId
+                    + '}';
+        }
     }
 
     /**
@@ -455,5 +585,10 @@ protected void write(ByteBuf buf) {
         protected void read(ByteBuf buf) {
             newName = ByteBufUtils.readUTF8String(buf);
         }
+
+        @Override
+        public String toString() {
+            return "PacketRename{" + "newName='" + newName + '\'' + ", entryId=" + entryId + '}';
+        }
     }
 }

From ef031955fc05a72be5141846529cf76e5b7f8622 Mon Sep 17 00:00:00 2001
From: Andrei Laiff <q.laiff@gmail.com>
Date: Sun, 22 Oct 2023 22:13:29 +0300
Subject: [PATCH 18/22] Fix `zIndexes` for compatability with `DuraDisplay`

---
 dependencies.gradle                           |   2 +
 ...y.java => IInterfaceTerminalRegistry.java} |   6 +-
 .../api/features/IRegistryContainer.java      |   2 +-
 ...mViewable.java => IInterfaceViewable.java} |   2 +-
 .../gui/IInterfaceTerminalPostUpdate.java     |   2 +-
 .../implementations/GuiInterfaceTerminal.java | 195 ++++++++++--------
 .../ContainerInterfaceTerminal.java           |  44 ++--
 ...ry.java => InterfaceTerminalRegistry.java} |  18 +-
 .../registries/RegistryContainer.java         |   8 +-
 .../core/sync/AppEngPacketHandlerBase.java    |   4 +-
 ...ava => PacketInterfaceTerminalUpdate.java} |   6 +-
 .../java/appeng/helpers/IInterfaceHost.java   |   4 +-
 .../helpers/IInterfaceTerminalSupport.java    |   3 +-
 13 files changed, 162 insertions(+), 134 deletions(-)
 rename src/main/java/appeng/api/features/{IIfaceTermRegistry.java => IInterfaceTerminalRegistry.java} (54%)
 rename src/main/java/appeng/api/util/{IIfaceTermViewable.java => IInterfaceViewable.java} (94%)
 rename src/main/java/appeng/core/features/registries/{IfaceTermRegistry.java => InterfaceTerminalRegistry.java} (61%)
 rename src/main/java/appeng/core/sync/packets/{PacketIfaceTermUpdate.java => PacketInterfaceTerminalUpdate.java} (99%)

diff --git a/dependencies.gradle b/dependencies.gradle
index 41bd5d8d032..ccbd52f6fd6 100644
--- a/dependencies.gradle
+++ b/dependencies.gradle
@@ -27,4 +27,6 @@ dependencies {
     functionalTestImplementation('com.github.GTNewHorizons:GT5-Unofficial:5.09.44.26:dev') {
         exclude module: "Applied-Energistics-2-Unofficial"
     }
+
+    runtimeOnlyNonPublishable("com.github.GTNewHorizons:DuraDisplay:1.1.7:dev")
 }
diff --git a/src/main/java/appeng/api/features/IIfaceTermRegistry.java b/src/main/java/appeng/api/features/IInterfaceTerminalRegistry.java
similarity index 54%
rename from src/main/java/appeng/api/features/IIfaceTermRegistry.java
rename to src/main/java/appeng/api/features/IInterfaceTerminalRegistry.java
index 7f9baf4c64c..f950c51faf4 100644
--- a/src/main/java/appeng/api/features/IIfaceTermRegistry.java
+++ b/src/main/java/appeng/api/features/IInterfaceTerminalRegistry.java
@@ -1,14 +1,14 @@
 package appeng.api.features;
 
-import appeng.api.util.IIfaceTermViewable;
+import appeng.api.util.IInterfaceViewable;
 
 /**
  * Registry for interface terminal support.
  */
-public interface IIfaceTermRegistry {
+public interface IInterfaceTerminalRegistry {
 
     /**
      * Registers a class to be considered supported in interface terminals.
      */
-    void register(Class<? extends IIfaceTermViewable> clazz);
+    void register(Class<? extends IInterfaceViewable> clazz);
 }
diff --git a/src/main/java/appeng/api/features/IRegistryContainer.java b/src/main/java/appeng/api/features/IRegistryContainer.java
index 8dc002fd598..9e47f66808f 100644
--- a/src/main/java/appeng/api/features/IRegistryContainer.java
+++ b/src/main/java/appeng/api/features/IRegistryContainer.java
@@ -73,7 +73,7 @@ public interface IRegistryContainer {
      */
     IInscriberRegistry inscriber();
 
-    IIfaceTermRegistry ifaceTerm();
+    IInterfaceTerminalRegistry interfaceTerminal();
 
     /**
      * get access to the locatable registry
diff --git a/src/main/java/appeng/api/util/IIfaceTermViewable.java b/src/main/java/appeng/api/util/IInterfaceViewable.java
similarity index 94%
rename from src/main/java/appeng/api/util/IIfaceTermViewable.java
rename to src/main/java/appeng/api/util/IInterfaceViewable.java
index 0ae440cf72f..1eb536b99d9 100644
--- a/src/main/java/appeng/api/util/IIfaceTermViewable.java
+++ b/src/main/java/appeng/api/util/IInterfaceViewable.java
@@ -9,7 +9,7 @@
 /**
  * Replacement for {@code IInterfaceTerminalSupport} in API.
  */
-public interface IIfaceTermViewable extends IGridHost {
+public interface IInterfaceViewable extends IGridHost {
 
     DimensionalCoord getLocation();
 
diff --git a/src/main/java/appeng/client/gui/IInterfaceTerminalPostUpdate.java b/src/main/java/appeng/client/gui/IInterfaceTerminalPostUpdate.java
index 8b35d136a42..753b2ef337e 100644
--- a/src/main/java/appeng/client/gui/IInterfaceTerminalPostUpdate.java
+++ b/src/main/java/appeng/client/gui/IInterfaceTerminalPostUpdate.java
@@ -2,7 +2,7 @@
 
 import java.util.List;
 
-import appeng.core.sync.packets.PacketIfaceTermUpdate.PacketEntry;
+import appeng.core.sync.packets.PacketInterfaceTerminalUpdate.PacketEntry;
 
 public interface IInterfaceTerminalPostUpdate {
 
diff --git a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
index 66a370d852a..493bb8798e9 100644
--- a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
+++ b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
@@ -64,8 +64,8 @@
 import appeng.core.localization.GuiText;
 import appeng.core.localization.PlayerMessages;
 import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketIfaceTermUpdate;
-import appeng.core.sync.packets.PacketIfaceTermUpdate.PacketEntry;
+import appeng.core.sync.packets.PacketInterfaceTerminalUpdate;
+import appeng.core.sync.packets.PacketInterfaceTerminalUpdate.PacketEntry;
 import appeng.core.sync.packets.PacketInventoryAction;
 import appeng.helpers.InventoryAction;
 import appeng.helpers.PatternHelper;
@@ -102,7 +102,7 @@ public class GuiInterfaceTerminal extends AEBaseGui
             AppEng.MOD_ID,
             "textures/guis/newinterfaceterminal.png");
 
-    private final IfaceList masterList = new IfaceList();
+    private final InterfaceTerminalList masterList = new InterfaceTerminalList();
     private final MEGuiTextField searchFieldOutputs;
     private final MEGuiTextField searchFieldInputs;
     private final MEGuiTextField searchFieldNames;
@@ -122,11 +122,13 @@ public class GuiInterfaceTerminal extends AEBaseGui
      * Z-level Map (FLOATS) 0.0 - BACKGROUND 1.0 - ItemStacks 2.0 - Slot color overlays 20.0 - ItemStack overlays 21.0 -
      * Slot mouse hover overlay 200.0 - Tooltips
      */
-    private static final float ITEMSTACK_Z = 1.0f;
+    private static final float ITEM_STACK_Z = 100.0f;
     private static final float SLOT_Z = 0.5f;
-    private static final float ITEMSTACK_OVERLAY_Z = 20.0f;
-    private static final float SLOT_HOVER_Z = 31.0f;
-    private static final float TOOLTIP_Z = 200.0f;
+    private static final float ITEM_STACK_OVERLAY_Z = 200.0f;
+    private static final float SLOT_HOVER_Z = 310.0f;
+    private static final float TOOLTIP_Z = 210.0f;
+    private static final float STEP_Z = 10.0f;
+    private static final float MAGIC_RENDER_ITEM_Z = 50.0f;
 
     public GuiInterfaceTerminal(final InventoryPlayer inventoryPlayer, final PartInterfaceTerminal te) {
         super(new ContainerInterfaceTerminal(inventoryPlayer, te));
@@ -330,7 +332,7 @@ public void drawBG(final int offsetX, final int offsetY, final int mouseX, final
                 offsetY + HEADER_HEIGHT + viewHeight + 1,
                 0.0f,
                 0.0f,
-                (HEADER_HEIGHT + IfaceSection.TITLE_HEIGHT + 1.0f) / 256.0f,
+                (HEADER_HEIGHT + InterfaceSection.TITLE_HEIGHT + 1.0f) / 256.0f,
                 this.xSize / 256.0f,
                 (HEADER_HEIGHT + 106.0f) / 256.0f);
         Tessellator.instance.draw();
@@ -362,7 +364,7 @@ private void drawViewport(int relMouseX, int relMouseY) {
         final int scroll = this.getScrollBar().getCurrentScroll();
         int viewY = -scroll; // current y in viewport coordinates
         int entryIdx = 0;
-        List<IfaceSection> visibleSections = this.masterList.getVisibleSections();
+        List<InterfaceSection> visibleSections = this.masterList.getVisibleSections();
 
         final float guiScaleX = (float) mc.displayWidth / width;
         final float guiScaleY = (float) mc.displayHeight / height;
@@ -377,7 +379,7 @@ private void drawViewport(int relMouseX, int relMouseY) {
          * Render each section
          */
         while (viewY < this.viewHeight && entryIdx < visibleSections.size()) {
-            IfaceSection section = visibleSections.get(entryIdx);
+            InterfaceSection section = visibleSections.get(entryIdx);
             int sectionHeight = section.getHeight();
 
             /* Is it viewable/in the viewport at all? */
@@ -404,7 +406,7 @@ private void drawViewport(int relMouseX, int relMouseY) {
      * @param relMouseY transformed mouse coords relative to viewport
      * @return the height of the section rendered in viewport coordinates, max of viewHeight.
      */
-    private int drawSection(IfaceSection section, int viewY, int relMouseX, int relMouseY) {
+    private int drawSection(InterfaceSection section, int viewY, int relMouseX, int relMouseY) {
         int title;
         int renderY = 0;
         final int sectionBottom = viewY + section.getHeight() - 1;
@@ -412,57 +414,74 @@ private int drawSection(IfaceSection section, int viewY, int relMouseX, int relM
         /*
          * Render title
          */
-        GL11.glTranslatef(0.0f, 0.0f, 50f);
         bindTexture(BACKGROUND);
-        if (sectionBottom > 0 && sectionBottom < IfaceSection.TITLE_HEIGHT) {
+        GL11.glTranslatef(0.0f, 0.0f, ITEM_STACK_OVERLAY_Z + ITEM_STACK_Z + STEP_Z);
+        if (sectionBottom > 0 && sectionBottom < InterfaceSection.TITLE_HEIGHT) {
             /* Transition draw */
-            drawTexturedModalRect(
-                    0,
-                    0,
-                    VIEW_LEFT,
-                    HEADER_HEIGHT + IfaceSection.TITLE_HEIGHT - sectionBottom,
-                    VIEW_WIDTH,
-                    sectionBottom);
-            fontRendererObj.drawString(section.name, 2, sectionBottom - IfaceSection.TITLE_HEIGHT + 2, fontColor);
             title = sectionBottom;
         } else if (viewY < 0) {
             /* Hidden title draw */
-            drawTexturedModalRect(0, 0, VIEW_LEFT, HEADER_HEIGHT, VIEW_WIDTH, IfaceSection.TITLE_HEIGHT);
-            fontRendererObj.drawString(section.name, 2, 2, fontColor);
             title = 0;
         } else {
             /* Normal title draw */
-            drawTexturedModalRect(0, viewY, VIEW_LEFT, HEADER_HEIGHT, VIEW_WIDTH, IfaceSection.TITLE_HEIGHT);
-            fontRendererObj.drawString(section.name, 2, viewY + 2, fontColor);
             title = 0;
         }
-        GL11.glTranslatef(0.0f, 0.0f, -50f);
+        GL11.glTranslatef(0.0f, 0.0f, -(ITEM_STACK_OVERLAY_Z + ITEM_STACK_Z + STEP_Z));
         GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 
-        Iterator<IfaceEntry> visible = section.getVisible();
+        Iterator<InterfaceTerminalEntry> visible = section.getVisible();
         while (visible.hasNext()) {
             if (viewY < viewHeight) {
                 renderY += drawEntry(
                         visible.next(),
-                        viewY + IfaceSection.TITLE_HEIGHT + renderY,
+                        viewY + InterfaceSection.TITLE_HEIGHT + renderY,
                         title,
                         relMouseX,
                         relMouseY);
             } else {
-                IfaceEntry entry = visible.next();
+                InterfaceTerminalEntry entry = visible.next();
                 entry.dispY = -9999;
                 entry.optionsButton.yPosition = -1;
             }
         }
-        return IfaceSection.TITLE_HEIGHT + renderY;
+        /*
+         * Render title
+         */
+        bindTexture(BACKGROUND);
+        GL11.glTranslatef(0.0f, 0.0f, ITEM_STACK_OVERLAY_Z + ITEM_STACK_Z + STEP_Z);
+        if (sectionBottom > 0 && sectionBottom < InterfaceSection.TITLE_HEIGHT) {
+            /* Transition draw */
+            drawTexturedModalRect(
+                    0,
+                    0,
+                    VIEW_LEFT,
+                    HEADER_HEIGHT + InterfaceSection.TITLE_HEIGHT - sectionBottom,
+                    VIEW_WIDTH,
+                    sectionBottom);
+            fontRendererObj.drawString(section.name, 2, sectionBottom - InterfaceSection.TITLE_HEIGHT + 2, fontColor);
+        } else if (viewY < 0) {
+            /* Hidden title draw */
+            GL11.glDisable(GL11.GL_DEPTH_TEST);
+            GL11.glTranslatef(0.0f, 0.0f, 100f);
+            drawTexturedModalRect(0, 0, VIEW_LEFT, HEADER_HEIGHT, VIEW_WIDTH, InterfaceSection.TITLE_HEIGHT);
+            fontRendererObj.drawString(section.name, 2, 2, fontColor);
+            GL11.glEnable(GL11.GL_DEPTH_TEST);
+        } else {
+            /* Normal title draw */
+            drawTexturedModalRect(0, viewY, VIEW_LEFT, HEADER_HEIGHT, VIEW_WIDTH, InterfaceSection.TITLE_HEIGHT);
+            fontRendererObj.drawString(section.name, 2, viewY + 2, fontColor);
+        }
+        GL11.glTranslatef(0.0f, 0.0f, -(ITEM_STACK_OVERLAY_Z + ITEM_STACK_Z + STEP_Z));
+
+        return InterfaceSection.TITLE_HEIGHT + renderY;
     }
 
     /**
-     * Draws the entry. In practice it just draws the slots + items.
+     * Draws the entry. In practice, it just draws the slots + items.
      *
      * @param viewY the gui coordinate z
      */
-    private int drawEntry(IfaceEntry entry, int viewY, int titleBottom, int relMouseX, int relMouseY) {
+    private int drawEntry(InterfaceTerminalEntry entry, int viewY, int titleBottom, int relMouseX, int relMouseY) {
         bindTexture(BACKGROUND);
         Tessellator.instance.startDrawingQuads();
         int relY = 0;
@@ -498,7 +517,7 @@ private int drawEntry(IfaceEntry entry, int viewY, int titleBottom, int relMouse
             entry.optionsButton.yPosition = viewY + 5;
             entry.optionsButton.drawButton(mc, relMouseX, relMouseY);
             if (entry.optionsButton.getMouseIn()
-                    && relMouseY >= Math.max(IfaceSection.TITLE_HEIGHT, entry.optionsButton.yPosition)) {
+                    && relMouseY >= Math.max(InterfaceSection.TITLE_HEIGHT, entry.optionsButton.yPosition)) {
                 // draw a tooltip
                 GL11.glTranslatef(0f, 0f, TOOLTIP_Z);
                 GL11.glDisable(GL11.GL_SCISSOR_TEST);
@@ -526,30 +545,30 @@ private int drawEntry(IfaceEntry entry, int viewY, int titleBottom, int relMouse
                 ItemStack stack = inv.getStackInSlot(slotIdx);
 
                 boolean tooltip = relMouseX > colLeft - 1 && relMouseX < colRight - 1
-                        && relMouseY >= Math.max(viewY + rowYTop, IfaceSection.TITLE_HEIGHT)
+                        && relMouseY >= Math.max(viewY + rowYTop, InterfaceSection.TITLE_HEIGHT)
                         && relMouseY < Math.min(viewY + rowYBot, viewHeight);
                 if (stack != null) {
                     final ItemEncodedPattern iep = (ItemEncodedPattern) stack.getItem();
                     final ItemStack toRender = iep.getOutput(stack);
 
                     GL11.glPushMatrix();
-                    GL11.glTranslatef(colLeft, viewY + rowYTop + 1, ITEMSTACK_Z);
+                    GL11.glTranslatef(colLeft, viewY + rowYTop + 1, ITEM_STACK_Z);
                     GL11.glEnable(GL12.GL_RESCALE_NORMAL);
                     RenderHelper.enableGUIStandardItemLighting();
-                    translatedRenderItem.zLevel = 3.0f - 50.0f;
+                    translatedRenderItem.zLevel = ITEM_STACK_Z - MAGIC_RENDER_ITEM_Z;
                     translatedRenderItem
                             .renderItemAndEffectIntoGUI(fontRendererObj, mc.getTextureManager(), toRender, 0, 0);
-                    GL11.glTranslatef(0.0f, 0.0f, ITEMSTACK_OVERLAY_Z - ITEMSTACK_Z);
+                    GL11.glTranslatef(0.0f, 0.0f, ITEM_STACK_OVERLAY_Z - ITEM_STACK_Z);
                     aeRenderItem.setAeStack(AEItemStack.create(toRender));
                     aeRenderItem.renderItemOverlayIntoGUI(fontRendererObj, mc.getTextureManager(), toRender, 0, 0);
                     aeRenderItem.zLevel = 0.0f;
                     RenderHelper.disableStandardItemLighting();
                     if (!tooltip) {
                         if (entry.brokenRecipes[slotIdx]) {
-                            GL11.glTranslatef(0.0f, 0.0f, SLOT_Z - ITEMSTACK_OVERLAY_Z);
+                            GL11.glTranslatef(0.0f, 0.0f, SLOT_Z - ITEM_STACK_OVERLAY_Z);
                             drawRect(0, 0, 16, 16, GuiColors.ItemSlotOverlayInvalid.getColor());
                         } else if (entry.filteredRecipes[slotIdx]) {
-                            GL11.glTranslatef(0.0f, 0.0f, ITEMSTACK_OVERLAY_Z);
+                            GL11.glTranslatef(0.0f, 0.0f, ITEM_STACK_OVERLAY_Z);
                             drawRect(0, 0, 16, 16, GuiColors.ItemSlotOverlayUnpowered.getColor());
                         }
                     } else {
@@ -558,7 +577,7 @@ private int drawEntry(IfaceEntry entry, int viewY, int titleBottom, int relMouse
                     GL11.glPopMatrix();
                 } else if (entry.filteredRecipes[slotIdx]) {
                     GL11.glPushMatrix();
-                    GL11.glTranslatef(colLeft, viewY + rowYTop + 1, ITEMSTACK_OVERLAY_Z);
+                    GL11.glTranslatef(colLeft, viewY + rowYTop + 1, ITEM_STACK_OVERLAY_Z);
                     drawRect(0, 0, 16, 16, GuiColors.ItemSlotOverlayUnpowered.getColor());
                     GL11.glPopMatrix();
                 }
@@ -758,30 +777,36 @@ private boolean handleTab() {
 
     @Override
     public void postUpdate(List<PacketEntry> updates, int statusFlags) {
-        if ((statusFlags & PacketIfaceTermUpdate.CLEAR_ALL_BIT) == PacketIfaceTermUpdate.CLEAR_ALL_BIT) {
+        if ((statusFlags & PacketInterfaceTerminalUpdate.CLEAR_ALL_BIT)
+                == PacketInterfaceTerminalUpdate.CLEAR_ALL_BIT) {
             /* Should clear all client entries. */
             this.masterList.list.clear();
         }
         /* Should indicate disconnected, so the terminal turns dark. */
-        this.online = (statusFlags & PacketIfaceTermUpdate.DISCONNECT_BIT) != PacketIfaceTermUpdate.DISCONNECT_BIT;
+        this.online = (statusFlags & PacketInterfaceTerminalUpdate.DISCONNECT_BIT)
+                != PacketInterfaceTerminalUpdate.DISCONNECT_BIT;
 
-        for (PacketIfaceTermUpdate.PacketEntry cmd : updates) {
+        for (PacketInterfaceTerminalUpdate.PacketEntry cmd : updates) {
             parsePacketCmd(cmd);
         }
         this.masterList.markDirty();
     }
 
-    private void parsePacketCmd(PacketIfaceTermUpdate.PacketEntry cmd) {
+    private void parsePacketCmd(PacketInterfaceTerminalUpdate.PacketEntry cmd) {
         long id = cmd.entryId;
-        if (cmd instanceof PacketIfaceTermUpdate.PacketAdd addCmd) {
-            IfaceEntry entry = new IfaceEntry(id, addCmd.name, addCmd.rows, addCmd.rowSize, addCmd.online)
-                    .setLocation(addCmd.x, addCmd.y, addCmd.z, addCmd.dim).setIcons(addCmd.selfRep, addCmd.dispRep)
-                    .setItems(addCmd.items);
+        if (cmd instanceof PacketInterfaceTerminalUpdate.PacketAdd addCmd) {
+            InterfaceTerminalEntry entry = new InterfaceTerminalEntry(
+                    id,
+                    addCmd.name,
+                    addCmd.rows,
+                    addCmd.rowSize,
+                    addCmd.online).setLocation(addCmd.x, addCmd.y, addCmd.z, addCmd.dim)
+                            .setIcons(addCmd.selfRep, addCmd.dispRep).setItems(addCmd.items);
             masterList.addEntry(entry);
-        } else if (cmd instanceof PacketIfaceTermUpdate.PacketRemove) {
+        } else if (cmd instanceof PacketInterfaceTerminalUpdate.PacketRemove) {
             masterList.removeEntry(id);
-        } else if (cmd instanceof PacketIfaceTermUpdate.PacketOverwrite owCmd) {
-            IfaceEntry entry = masterList.list.get(id);
+        } else if (cmd instanceof PacketInterfaceTerminalUpdate.PacketOverwrite owCmd) {
+            InterfaceTerminalEntry entry = masterList.list.get(id);
 
             if (entry == null) {
                 return;
@@ -799,8 +824,8 @@ private void parsePacketCmd(PacketIfaceTermUpdate.PacketEntry cmd) {
                 }
             }
             masterList.isDirty = true;
-        } else if (cmd instanceof PacketIfaceTermUpdate.PacketRename renameCmd) {
-            IfaceEntry entry = masterList.list.get(id);
+        } else if (cmd instanceof PacketInterfaceTerminalUpdate.PacketRename renameCmd) {
+            InterfaceTerminalEntry entry = masterList.list.get(id);
 
             if (entry != null) {
                 if (StatCollector.canTranslate(renameCmd.newName)) {
@@ -892,16 +917,16 @@ public void setTextFieldValue(final String displayName, final int mousex, final
     /**
      * Tracks the list of entries.
      */
-    private class IfaceList {
+    private class InterfaceTerminalList {
 
-        private final Map<Long, IfaceEntry> list = new HashMap<>();
-        private final Map<String, IfaceSection> sections = new TreeMap<>();
-        private final List<IfaceSection> visibleSections = new ArrayList<>();
+        private final Map<Long, InterfaceTerminalEntry> list = new HashMap<>();
+        private final Map<String, InterfaceSection> sections = new TreeMap<>();
+        private final List<InterfaceSection> visibleSections = new ArrayList<>();
         private boolean isDirty;
         private int height;
-        private IfaceEntry hoveredEntry;
+        private InterfaceTerminalEntry hoveredEntry;
 
-        IfaceList() {
+        InterfaceTerminalList() {
             this.isDirty = true;
         }
 
@@ -912,7 +937,7 @@ private void update() {
             height = 0;
             visibleSections.clear();
 
-            for (IfaceSection section : sections.values()) {
+            for (InterfaceSection section : sections.values()) {
                 String query = GuiInterfaceTerminal.this.searchFieldNames.getText();
                 if (!query.isEmpty() && !section.name.toLowerCase().contains(query.toLowerCase())) {
                     continue;
@@ -964,7 +989,7 @@ private boolean scrollNextSection(boolean up) {
             } else {
                 int y = 0;
 
-                for (IfaceSection section : sections) {
+                for (InterfaceSection section : sections) {
                     if (y > viewY) {
                         result = true;
                         scrollbar.setCurrentScroll(y);
@@ -976,11 +1001,11 @@ private boolean scrollNextSection(boolean up) {
             return result;
         }
 
-        public void addEntry(IfaceEntry entry) {
-            IfaceSection section = sections.get(entry.dispName);
+        public void addEntry(InterfaceTerminalEntry entry) {
+            InterfaceSection section = sections.get(entry.dispName);
 
             if (section == null) {
-                section = new IfaceSection(entry.dispName);
+                section = new InterfaceSection(entry.dispName);
                 sections.put(entry.dispName, section);
             }
             section.addEntry(entry);
@@ -989,14 +1014,14 @@ public void addEntry(IfaceEntry entry) {
         }
 
         public void removeEntry(long id) {
-            IfaceEntry entry = list.remove(id);
+            InterfaceTerminalEntry entry = list.remove(id);
 
             if (entry != null) {
                 entry.section.removeEntry(entry);
             }
         }
 
-        public List<IfaceSection> getVisibleSections() {
+        public List<InterfaceSection> getVisibleSections() {
             if (isDirty) {
                 update();
             }
@@ -1014,7 +1039,7 @@ public boolean mouseClicked(int relMouseX, int relMouseY, int btn) {
             if (relMouseX < 0 || relMouseX >= VIEW_WIDTH || relMouseY < 0 || relMouseY >= viewHeight) {
                 return false;
             }
-            for (IfaceSection section : getVisibleSections()) {
+            for (InterfaceSection section : getVisibleSections()) {
                 if (section.mouseClicked(relMouseX, relMouseY, btn)) {
                     return true;
                 }
@@ -1026,13 +1051,13 @@ public boolean mouseClicked(int relMouseX, int relMouseY, int btn) {
     /**
      * A section holds all the interface entries with the same name.
      */
-    private class IfaceSection {
+    private class InterfaceSection {
 
         public static final int TITLE_HEIGHT = 12;
 
         String name;
-        List<IfaceEntry> entries = new ArrayList<>();
-        Set<IfaceEntry> visibleEntries = new TreeSet<>(Comparator.comparing(e -> {
+        List<InterfaceTerminalEntry> entries = new ArrayList<>();
+        Set<InterfaceTerminalEntry> visibleEntries = new TreeSet<>(Comparator.comparing(e -> {
             if (e.dispRep != null) {
                 return e.dispRep.getDisplayName() + e.id;
             } else {
@@ -1043,7 +1068,7 @@ private class IfaceSection {
         private boolean isDirty = true;
         boolean visible = false;
 
-        IfaceSection(String name) {
+        InterfaceSection(String name) {
             this.name = name;
         }
 
@@ -1063,7 +1088,7 @@ private void update() {
                 height = 0;
             } else {
                 height = TITLE_HEIGHT;
-                for (IfaceEntry entry : visibleEntries) {
+                for (InterfaceTerminalEntry entry : visibleEntries) {
                     height += entry.guiHeight;
                 }
             }
@@ -1075,7 +1100,7 @@ public void refreshVisible() {
             String input = GuiInterfaceTerminal.this.searchFieldInputs.getText().toLowerCase();
             String output = GuiInterfaceTerminal.this.searchFieldOutputs.getText().toLowerCase();
 
-            for (IfaceEntry entry : entries) {
+            for (InterfaceTerminalEntry entry : entries) {
                 var moleAss = AEApi.instance().definitions().blocks().molecularAssembler().maybeStack(1);
                 entry.dispY = -9999;
                 if (onlyMolecularAssemblers
@@ -1114,19 +1139,19 @@ && itemStackMatchesSearchTerm(stack, output, false)) {
             }
         }
 
-        public void addEntry(IfaceEntry entry) {
+        public void addEntry(InterfaceTerminalEntry entry) {
             this.entries.add(entry);
             entry.section = this;
             this.isDirty = true;
         }
 
-        public void removeEntry(IfaceEntry entry) {
+        public void removeEntry(InterfaceTerminalEntry entry) {
             this.entries.remove(entry);
             entry.section = null;
             this.isDirty = true;
         }
 
-        public Iterator<IfaceEntry> getVisible() {
+        public Iterator<InterfaceTerminalEntry> getVisible() {
             if (isDirty) {
                 update();
             }
@@ -1134,7 +1159,7 @@ public Iterator<IfaceEntry> getVisible() {
         }
 
         public boolean mouseClicked(int relMouseX, int relMouseY, int btn) {
-            Iterator<IfaceEntry> it = getVisible();
+            Iterator<InterfaceTerminalEntry> it = getVisible();
             boolean ret = false;
 
             while (it.hasNext() && !ret) {
@@ -1148,7 +1173,7 @@ public boolean mouseClicked(int relMouseX, int relMouseY, int btn) {
     /**
      * This class keeps track of an entry and its widgets.
      */
-    private class IfaceEntry {
+    private class InterfaceTerminalEntry {
 
         String dispName;
         AppEngInternalInventory inv;
@@ -1157,7 +1182,7 @@ private class IfaceEntry {
         ItemStack selfRep;
         /** Nullable - icon that represents the interface's "target" */
         ItemStack dispRep;
-        IfaceSection section;
+        InterfaceSection section;
         long id;
         int x, y, z, dim;
         int rows, rowSize;
@@ -1171,7 +1196,7 @@ private class IfaceEntry {
         boolean[] filteredRecipes;
         private int hoveredSlotIdx = -1;
 
-        IfaceEntry(long id, String name, int rows, int rowSize, boolean online) {
+        InterfaceTerminalEntry(long id, String name, int rows, int rowSize, boolean online) {
             this.id = id;
             if (StatCollector.canTranslate(name)) {
                 this.dispName = StatCollector.translateToLocal(name);
@@ -1194,7 +1219,7 @@ private class IfaceEntry {
             this.filteredRecipes = new boolean[rows * rowSize];
         }
 
-        IfaceEntry setLocation(int x, int y, int z, int dim) {
+        InterfaceTerminalEntry setLocation(int x, int y, int z, int dim) {
             this.x = x;
             this.y = y;
             this.z = z;
@@ -1203,7 +1228,7 @@ IfaceEntry setLocation(int x, int y, int z, int dim) {
             return this;
         }
 
-        IfaceEntry setIcons(ItemStack selfRep, ItemStack dispRep) {
+        InterfaceTerminalEntry setIcons(ItemStack selfRep, ItemStack dispRep) {
             // Kotlin would make this pretty easy :(
             this.selfRep = selfRep;
             this.dispRep = dispRep;
@@ -1223,7 +1248,7 @@ public void fullItemUpdate(NBTTagList items, int newSize) {
             this.guiHeight = 18 * rows + 4;
         }
 
-        IfaceEntry setItems(NBTTagList items) {
+        InterfaceTerminalEntry setItems(NBTTagList items) {
             assert items.tagCount() == inv.getSizeInventory();
 
             for (int i = 0; i < items.tagCount(); ++i) {
@@ -1263,7 +1288,7 @@ public boolean mouseClicked(int mouseX, int mouseY, int btn) {
                 return false;
             }
             if (mouseX >= optionsButton.xPosition && mouseX < 2 + optionsButton.width
-                    && mouseY > Math.max(optionsButton.yPosition, IfaceSection.TITLE_HEIGHT)
+                    && mouseY > Math.max(optionsButton.yPosition, InterfaceSection.TITLE_HEIGHT)
                     && mouseY <= Math.min(optionsButton.yPosition + optionsButton.height, viewHeight)) {
                 optionsButton.func_146113_a(mc.getSoundHandler());
                 DimensionalCoord blockPos = new DimensionalCoord(x, y, z, dim);
@@ -1293,7 +1318,7 @@ public boolean mouseClicked(int mouseX, int mouseY, int btn) {
             int offsetY = mouseY - dispY;
             int offsetX = mouseX - (VIEW_WIDTH - rowSize * 18) - 1;
             if (offsetX >= 0 && offsetX < (rowSize * 18)
-                    && mouseY > Math.max(dispY, IfaceSection.TITLE_HEIGHT)
+                    && mouseY > Math.max(dispY, InterfaceSection.TITLE_HEIGHT)
                     && offsetY < Math.min(viewHeight - dispY, guiHeight)) {
                 final int col = offsetX / 18;
                 final int row = offsetY / 18;
diff --git a/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java b/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
index 85f7ab71637..339b372f229 100644
--- a/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
+++ b/src/main/java/appeng/container/implementations/ContainerInterfaceTerminal.java
@@ -35,11 +35,11 @@
 import appeng.api.networking.IGridNode;
 import appeng.api.networking.security.IActionHost;
 import appeng.api.util.DimensionalCoord;
-import appeng.api.util.IIfaceTermViewable;
+import appeng.api.util.IInterfaceViewable;
 import appeng.container.AEBaseContainer;
-import appeng.core.features.registries.IfaceTermRegistry;
+import appeng.core.features.registries.InterfaceTerminalRegistry;
 import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketIfaceTermUpdate;
+import appeng.core.sync.packets.PacketInterfaceTerminalUpdate;
 import appeng.helpers.InventoryAction;
 import appeng.items.misc.ItemEncodedPattern;
 import appeng.parts.AEBasePart;
@@ -53,9 +53,9 @@ public final class ContainerInterfaceTerminal extends AEBaseContainer {
 
     private int nextId = 0;
 
-    private final Map<IIfaceTermViewable, InvTracker> tracked = new HashMap<>();
+    private final Map<IInterfaceViewable, InvTracker> tracked = new HashMap<>();
     private final Map<Long, InvTracker> trackedById = new HashMap<>();
-    private PacketIfaceTermUpdate dirty;
+    private PacketInterfaceTerminalUpdate dirty;
     private boolean isDirty;
     private IGrid grid;
     private IActionHost anchor;
@@ -71,7 +71,7 @@ public ContainerInterfaceTerminal(final InventoryPlayer ip, final IActionHost an
             if (dirty != null) {
                 this.isDirty = true;
             } else {
-                dirty = new PacketIfaceTermUpdate();
+                dirty = new PacketInterfaceTerminalUpdate();
             }
         }
         this.bindPlayerInventory(ip, 14, 3);
@@ -98,7 +98,7 @@ public void detectAndSendChanges() {
              * updates. This prevents DoSing the player if their network is flickering.
              */
             if (!this.wasOff) {
-                PacketIfaceTermUpdate update = new PacketIfaceTermUpdate();
+                PacketInterfaceTerminalUpdate update = new PacketInterfaceTerminalUpdate();
 
                 update.setDisconnect();
                 this.wasOff = true;
@@ -109,7 +109,7 @@ public void detectAndSendChanges() {
         this.wasOff = false;
 
         if (anchor instanceof PartInterfaceTerminal terminal && terminal.needsUpdate()) {
-            PacketIfaceTermUpdate update = this.updateList();
+            PacketInterfaceTerminalUpdate update = this.updateList();
             if (update != null) {
                 update.encode();
                 NetworkHandler.instance.sendTo(update, (EntityPlayerMP) this.getPlayerInv().player);
@@ -117,7 +117,7 @@ public void detectAndSendChanges() {
         } else if (isDirty) {
             this.dirty.encode();
             NetworkHandler.instance.sendTo(this.dirty, (EntityPlayerMP) this.getPlayerInv().player);
-            this.dirty = new PacketIfaceTermUpdate();
+            this.dirty = new PacketInterfaceTerminalUpdate();
             this.isDirty = false;
         }
     }
@@ -264,14 +264,14 @@ private ItemStack mergeToPlayerInventory(InventoryAdaptor playerInv, ItemStack s
     /**
      * Finds out whether any updates are needed, and if so, incrementally updates the list.
      */
-    private PacketIfaceTermUpdate updateList() {
-        PacketIfaceTermUpdate update = null;
-        var supported = IfaceTermRegistry.instance().getSupportedClasses();
-        Set<IIfaceTermViewable> visited = new HashSet<>();
+    private PacketInterfaceTerminalUpdate updateList() {
+        PacketInterfaceTerminalUpdate update = null;
+        var supported = InterfaceTerminalRegistry.instance().getSupportedClasses();
+        Set<IInterfaceViewable> visited = new HashSet<>();
 
-        for (Class<? extends IIfaceTermViewable> c : supported) {
+        for (Class<? extends IInterfaceViewable> c : supported) {
             for (IGridNode node : grid.getMachines(c)) {
-                IIfaceTermViewable machine = (IIfaceTermViewable) node.getMachine();
+                IInterfaceViewable machine = (IInterfaceViewable) node.getMachine();
                 /* First check if we are already tracking this node */
                 if (tracked.containsKey(machine)) {
                     /* Check for updates */
@@ -281,7 +281,7 @@ private PacketIfaceTermUpdate updateList() {
                     String name = machine.getName();
 
                     if (!Objects.equals(known.name, name)) {
-                        if (update == null) update = new PacketIfaceTermUpdate();
+                        if (update == null) update = new PacketInterfaceTerminalUpdate();
                         update.addRenamedEntry(known.id, name);
                         known.name = name;
                     }
@@ -292,18 +292,18 @@ private PacketIfaceTermUpdate updateList() {
                     if (!known.online && isActive) {
                         /* Node offline -> online */
                         known.online = true;
-                        if (update == null) update = new PacketIfaceTermUpdate();
+                        if (update == null) update = new PacketInterfaceTerminalUpdate();
                         known.updateNBT();
                         update.addOverwriteEntry(known.id).setOnline(true).setItems(new int[0], known.invNbt);
                     } else if (known.online && !isActive) {
                         /* Node online -> offline */
                         known.online = false;
-                        if (update == null) update = new PacketIfaceTermUpdate();
+                        if (update == null) update = new PacketInterfaceTerminalUpdate();
                         update.addOverwriteEntry(known.id).setOnline(false);
                     }
                 } else {
                     /* Add a new entry */
-                    if (update == null) update = new PacketIfaceTermUpdate();
+                    if (update == null) update = new PacketInterfaceTerminalUpdate();
                     InvTracker entry = new InvTracker(nextId++, machine, node.isActive());
                     update.addNewEntry(entry.id, entry.name, entry.online)
                             .setLoc(entry.x, entry.y, entry.z, entry.dim, entry.side.ordinal())
@@ -317,14 +317,14 @@ private PacketIfaceTermUpdate updateList() {
         }
 
         /* Now find any entries that we need to remove */
-        Iterator<Entry<IIfaceTermViewable, InvTracker>> it = tracked.entrySet().iterator();
+        Iterator<Entry<IInterfaceViewable, InvTracker>> it = tracked.entrySet().iterator();
         while (it.hasNext()) {
             var entry = it.next();
             if (visited.contains(entry.getKey())) {
                 continue;
             }
 
-            if (update == null) update = new PacketIfaceTermUpdate();
+            if (update == null) update = new PacketInterfaceTerminalUpdate();
 
             trackedById.remove(entry.getValue().id);
             it.remove();
@@ -360,7 +360,7 @@ private static class InvTracker {
         private boolean online;
         private NBTTagList invNbt;
 
-        InvTracker(long id, IIfaceTermViewable machine, boolean online) {
+        InvTracker(long id, IInterfaceViewable machine, boolean online) {
             DimensionalCoord location = machine.getLocation();
 
             this.id = id;
diff --git a/src/main/java/appeng/core/features/registries/IfaceTermRegistry.java b/src/main/java/appeng/core/features/registries/InterfaceTerminalRegistry.java
similarity index 61%
rename from src/main/java/appeng/core/features/registries/IfaceTermRegistry.java
rename to src/main/java/appeng/core/features/registries/InterfaceTerminalRegistry.java
index 846fdb8127f..4bd4f280044 100644
--- a/src/main/java/appeng/core/features/registries/IfaceTermRegistry.java
+++ b/src/main/java/appeng/core/features/registries/InterfaceTerminalRegistry.java
@@ -3,8 +3,8 @@
 import java.util.HashSet;
 import java.util.Set;
 
-import appeng.api.features.IIfaceTermRegistry;
-import appeng.api.util.IIfaceTermViewable;
+import appeng.api.features.IInterfaceTerminalRegistry;
+import appeng.api.util.IInterfaceViewable;
 import appeng.parts.misc.PartInterface;
 import appeng.parts.p2p.PartP2PInterface;
 import appeng.tile.misc.TileInterface;
@@ -12,15 +12,15 @@
 /**
  * Interface Terminal Registry impl for registering viewable instances.
  */
-public class IfaceTermRegistry implements IIfaceTermRegistry {
+public class InterfaceTerminalRegistry implements IInterfaceTerminalRegistry {
 
-    private final Set<Class<? extends IIfaceTermViewable>> supportedClasses = new HashSet<>();
-    private static IfaceTermRegistry INSTANCE;
+    private final Set<Class<? extends IInterfaceViewable>> supportedClasses = new HashSet<>();
+    private static InterfaceTerminalRegistry INSTANCE;
 
     /**
      * Singleton, do not instantiate more than once.
      */
-    public IfaceTermRegistry() {
+    public InterfaceTerminalRegistry() {
         supportedClasses.add(TileInterface.class);
         supportedClasses.add(PartInterface.class);
         supportedClasses.add(PartP2PInterface.class);
@@ -30,16 +30,16 @@ public IfaceTermRegistry() {
     /**
      * Get all supported classes that were registered during startup
      */
-    public Set<Class<? extends IIfaceTermViewable>> getSupportedClasses() {
+    public Set<Class<? extends IInterfaceViewable>> getSupportedClasses() {
         return supportedClasses;
     }
 
     @Override
-    public void register(Class<? extends IIfaceTermViewable> clazz) {
+    public void register(Class<? extends IInterfaceViewable> clazz) {
         supportedClasses.add(clazz);
     }
 
-    public static IfaceTermRegistry instance() {
+    public static InterfaceTerminalRegistry instance() {
         return INSTANCE;
     }
 }
diff --git a/src/main/java/appeng/core/features/registries/RegistryContainer.java b/src/main/java/appeng/core/features/registries/RegistryContainer.java
index 506bb73c0ec..6561d49b176 100644
--- a/src/main/java/appeng/core/features/registries/RegistryContainer.java
+++ b/src/main/java/appeng/core/features/registries/RegistryContainer.java
@@ -11,8 +11,8 @@
 package appeng.core.features.registries;
 
 import appeng.api.features.IGrinderRegistry;
-import appeng.api.features.IIfaceTermRegistry;
 import appeng.api.features.IInscriberRegistry;
+import appeng.api.features.IInterfaceTerminalRegistry;
 import appeng.api.features.ILocatableRegistry;
 import appeng.api.features.IMatterCannonAmmoRegistry;
 import appeng.api.features.IP2PTunnelRegistry;
@@ -43,7 +43,7 @@ public class RegistryContainer implements IRegistryContainer {
     private final IExternalStorageRegistry storage = new ExternalStorageRegistry();
     private final ICellRegistry cell = new CellRegistry();
     private final IItemDisplayRegistry itemDisplay = new ItemDisplayRegistry();
-    private final IIfaceTermRegistry ifaceTerm = new IfaceTermRegistry();
+    private final IInterfaceTerminalRegistry interfaceTerminalRegistry = new InterfaceTerminalRegistry();
     private final ILocatableRegistry locatable = new LocatableRegistry();
     private final ISpecialComparisonRegistry comparison = new SpecialComparisonRegistry();
     private final IWirelessTermRegistry wireless = new WirelessRegistry();
@@ -100,8 +100,8 @@ public IInscriberRegistry inscriber() {
     }
 
     @Override
-    public IIfaceTermRegistry ifaceTerm() {
-        return this.ifaceTerm;
+    public IInterfaceTerminalRegistry interfaceTerminal() {
+        return this.interfaceTerminalRegistry;
     }
 
     @Override
diff --git a/src/main/java/appeng/core/sync/AppEngPacketHandlerBase.java b/src/main/java/appeng/core/sync/AppEngPacketHandlerBase.java
index e3d5c17922c..b5af54ce0ca 100644
--- a/src/main/java/appeng/core/sync/AppEngPacketHandlerBase.java
+++ b/src/main/java/appeng/core/sync/AppEngPacketHandlerBase.java
@@ -26,7 +26,7 @@
 import appeng.core.sync.packets.PacketCraftingItemInterface;
 import appeng.core.sync.packets.PacketCraftingRemainingOperations;
 import appeng.core.sync.packets.PacketCraftingTreeData;
-import appeng.core.sync.packets.PacketIfaceTermUpdate;
+import appeng.core.sync.packets.PacketInterfaceTerminalUpdate;
 import appeng.core.sync.packets.PacketInventoryAction;
 import appeng.core.sync.packets.PacketLightning;
 import appeng.core.sync.packets.PacketMEInventoryUpdate;
@@ -112,7 +112,7 @@ public enum PacketTypes {
         PACKET_CRAFTING_ITEM_INTERFACE(PacketCraftingItemInterface.class),
         PACKET_CRAFTING_TREE_DATA(PacketCraftingTreeData.class),
         PACKET_NEI_BOOKMARK(PacketNEIBookmark.class),
-        PACKET_IFACE_TERMINAL_UPDATE(PacketIfaceTermUpdate.class),;
+        PACKET_INTERFACE_TERMINAL_UPDATE(PacketInterfaceTerminalUpdate.class),;
 
         private final Class<? extends AppEngPacket> packetClass;
         private final Constructor<? extends AppEngPacket> packetConstructor;
diff --git a/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java b/src/main/java/appeng/core/sync/packets/PacketInterfaceTerminalUpdate.java
similarity index 99%
rename from src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java
rename to src/main/java/appeng/core/sync/packets/PacketInterfaceTerminalUpdate.java
index f150ad318c9..08fbe1ee81c 100644
--- a/src/main/java/appeng/core/sync/packets/PacketIfaceTermUpdate.java
+++ b/src/main/java/appeng/core/sync/packets/PacketInterfaceTerminalUpdate.java
@@ -35,7 +35,7 @@
  * Packet used for interface terminal updates. Packet allows the server to send an array of command packets, which are
  * then processed in order. This allows for chaining commands to produce the desired update.
  */
-public class PacketIfaceTermUpdate extends AppEngPacket {
+public class PacketInterfaceTerminalUpdate extends AppEngPacket {
 
     public static final int CLEAR_ALL_BIT = 1;
     public static final int DISCONNECT_BIT = 2;
@@ -44,11 +44,11 @@ public class PacketIfaceTermUpdate extends AppEngPacket {
     private int statusFlags;
 
     @Reflected
-    public PacketIfaceTermUpdate(final ByteBuf buf) throws IOException {
+    public PacketInterfaceTerminalUpdate(final ByteBuf buf) throws IOException {
         decode(buf);
     }
 
-    public PacketIfaceTermUpdate() {}
+    public PacketInterfaceTerminalUpdate() {}
 
     private void decode(ByteBuf buf) {
         this.statusFlags = buf.readByte();
diff --git a/src/main/java/appeng/helpers/IInterfaceHost.java b/src/main/java/appeng/helpers/IInterfaceHost.java
index e5db9ca329b..acf0525656c 100644
--- a/src/main/java/appeng/helpers/IInterfaceHost.java
+++ b/src/main/java/appeng/helpers/IInterfaceHost.java
@@ -23,9 +23,9 @@
 import appeng.api.implementations.IUpgradeableHost;
 import appeng.api.networking.crafting.ICraftingProvider;
 import appeng.api.networking.crafting.ICraftingRequester;
-import appeng.api.util.IIfaceTermViewable;
+import appeng.api.util.IInterfaceViewable;
 
-public interface IInterfaceHost extends ICraftingProvider, IUpgradeableHost, ICraftingRequester, IIfaceTermViewable {
+public interface IInterfaceHost extends ICraftingProvider, IUpgradeableHost, ICraftingRequester, IInterfaceViewable {
 
     DualityInterface getInterfaceDuality();
 
diff --git a/src/main/java/appeng/helpers/IInterfaceTerminalSupport.java b/src/main/java/appeng/helpers/IInterfaceTerminalSupport.java
index 9b4c7a9b5df..40d3aa78cff 100644
--- a/src/main/java/appeng/helpers/IInterfaceTerminalSupport.java
+++ b/src/main/java/appeng/helpers/IInterfaceTerminalSupport.java
@@ -5,11 +5,12 @@
 
 import appeng.api.networking.IGridHost;
 import appeng.api.util.DimensionalCoord;
+import appeng.api.util.IInterfaceViewable;
 
 /**
  * Refactoring this class into API, and renaming.
  *
- * @see appeng.api.util.IIfaceTermViewable
+ * @see IInterfaceViewable
  */
 @Deprecated
 public interface IInterfaceTerminalSupport extends IGridHost {

From eb785326b84d5f78985a36394c01801382b00709 Mon Sep 17 00:00:00 2001
From: Andrei Laiff <q.laiff@gmail.com>
Date: Mon, 23 Oct 2023 00:35:58 +0300
Subject: [PATCH 19/22] Use `IInterfaceViewable` to decide crafting location

---
 .../me/cluster/implementations/CraftingCPUCluster.java      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/appeng/me/cluster/implementations/CraftingCPUCluster.java b/src/main/java/appeng/me/cluster/implementations/CraftingCPUCluster.java
index 9c5ec725d07..317ceba6707 100644
--- a/src/main/java/appeng/me/cluster/implementations/CraftingCPUCluster.java
+++ b/src/main/java/appeng/me/cluster/implementations/CraftingCPUCluster.java
@@ -66,6 +66,7 @@
 import appeng.api.storage.data.IAEStack;
 import appeng.api.storage.data.IItemList;
 import appeng.api.util.DimensionalCoord;
+import appeng.api.util.IInterfaceViewable;
 import appeng.api.util.WorldCoord;
 import appeng.container.ContainerNull;
 import appeng.core.AELog;
@@ -75,7 +76,6 @@
 import appeng.crafting.CraftingWatcher;
 import appeng.crafting.MECraftingInventory;
 import appeng.helpers.DualityInterface;
-import appeng.helpers.IInterfaceTerminalSupport;
 import appeng.me.cache.CraftingGridCache;
 import appeng.me.cluster.IAECluster;
 import appeng.tile.AEBaseTile;
@@ -1243,8 +1243,8 @@ private TileEntity getTile(ICraftingMedium craftingProvider) {
             return ((DualityInterface) craftingProvider).getHost().getTile();
         } else if (craftingProvider instanceof AEBaseTile) {
             return ((AEBaseTile) craftingProvider).getTile();
-        } else if (craftingProvider instanceof IInterfaceTerminalSupport interfaceTerminalSupport) {
-            return interfaceTerminalSupport.getTileEntity();
+        } else if (craftingProvider instanceof IInterfaceViewable interfaceViewable) {
+            return interfaceViewable.getTileEntity();
         }
         try {
             Method method = craftingProvider.getClass().getMethod("getTile");

From 7fe498149ca88aef4bc91d2fc9663489608b441b Mon Sep 17 00:00:00 2001
From: Andrei Laiff <q.laiff@gmail.com>
Date: Mon, 23 Oct 2023 16:29:42 +0300
Subject: [PATCH 20/22] Fix tooltip zIndex

---
 .../appeng/client/gui/implementations/GuiInterfaceTerminal.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
index 493bb8798e9..5b979432c49 100644
--- a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
+++ b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
@@ -126,7 +126,7 @@ public class GuiInterfaceTerminal extends AEBaseGui
     private static final float SLOT_Z = 0.5f;
     private static final float ITEM_STACK_OVERLAY_Z = 200.0f;
     private static final float SLOT_HOVER_Z = 310.0f;
-    private static final float TOOLTIP_Z = 210.0f;
+    private static final float TOOLTIP_Z = 410.0f;
     private static final float STEP_Z = 10.0f;
     private static final float MAGIC_RENDER_ITEM_Z = 50.0f;
 

From 56629f42d308431b91e47d7b966934bd395ba456 Mon Sep 17 00:00:00 2001
From: Andrei Laiff <q.laiff@gmail.com>
Date: Mon, 23 Oct 2023 16:35:06 +0300
Subject: [PATCH 21/22] Replace `ForgeDirection` serialization with `byte`

---
 .../core/sync/packets/PacketInterfaceTerminalUpdate.java      | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/appeng/core/sync/packets/PacketInterfaceTerminalUpdate.java b/src/main/java/appeng/core/sync/packets/PacketInterfaceTerminalUpdate.java
index 08fbe1ee81c..b884d836b5c 100644
--- a/src/main/java/appeng/core/sync/packets/PacketInterfaceTerminalUpdate.java
+++ b/src/main/java/appeng/core/sync/packets/PacketInterfaceTerminalUpdate.java
@@ -289,7 +289,7 @@ protected void write(ByteBuf buf) throws IOException {
             buf.writeInt(y);
             buf.writeInt(z);
             buf.writeInt(dim);
-            buf.writeInt(side);
+            buf.writeByte(side);
             buf.writeInt(rows);
             buf.writeInt(rowSize);
 
@@ -323,7 +323,7 @@ protected void read(ByteBuf buf) throws IOException {
             this.z = buf.readInt();
             this.dim = buf.readInt();
             this.side = buf.readInt();
-            this.rows = buf.readInt();
+            this.rows = buf.readByte();
             this.rowSize = buf.readInt();
             int payloadSize = buf.readInt();
             try (ByteBufInputStream stream = new ByteBufInputStream(buf, payloadSize)) {

From f35c5af9a440203c7d13f038c393a2d99f61784d Mon Sep 17 00:00:00 2001
From: Andrei Laiff <q.laiff@gmail.com>
Date: Thu, 26 Oct 2023 16:43:24 +0300
Subject: [PATCH 22/22] Code cleanup after review

---
 .../gui/implementations/GuiInterfaceTerminal.java      |  5 -----
 .../appeng/core/sync/packets/PacketCompressedNBT.java  | 10 +---------
 2 files changed, 1 insertion(+), 14 deletions(-)

diff --git a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
index 5b979432c49..56eec5fe361 100644
--- a/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
+++ b/src/main/java/appeng/client/gui/implementations/GuiInterfaceTerminal.java
@@ -721,11 +721,6 @@ protected void keyTyped(final char character, final int key) {
                     || searchFieldNames.textboxKeyTyped(character, key)) {
                 return;
             }
-            // if (Character.isDigit(character) && character != '0') {
-            // // move hotbar to slot
-            // if (masterList.hoveredEntry != null && masterList.hoveredEntry.hoveredSlotIdx != -1) {
-            // }
-            // }
             super.keyTyped(character, key);
         }
     }
diff --git a/src/main/java/appeng/core/sync/packets/PacketCompressedNBT.java b/src/main/java/appeng/core/sync/packets/PacketCompressedNBT.java
index 7a59fddfd6f..b551814008b 100644
--- a/src/main/java/appeng/core/sync/packets/PacketCompressedNBT.java
+++ b/src/main/java/appeng/core/sync/packets/PacketCompressedNBT.java
@@ -18,8 +18,6 @@
 import java.util.zip.GZIPInputStream;
 import java.util.zip.GZIPOutputStream;
 
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.nbt.CompressedStreamTools;
 import net.minecraft.nbt.NBTTagCompound;
@@ -85,11 +83,5 @@ public void write(final int value) throws IOException {
 
     @Override
     @SideOnly(Side.CLIENT)
-    public void clientPacketData(final INetworkInfo network, final AppEngPacket packet, final EntityPlayer player) {
-        final GuiScreen gs = Minecraft.getMinecraft().currentScreen;
-
-        // if (gs instanceof GuiInterfaceTerminal) {
-        // ((GuiInterfaceTerminal) gs).postUpdate(this.in);
-        // }
-    }
+    public void clientPacketData(final INetworkInfo network, final AppEngPacket packet, final EntityPlayer player) {}
 }