1.1.3

16 files changed, 1897 insertions, 1022 deletions

diff --git a/src/main/java/io/github/moulberry/notenoughupdates/GuiTextures.java b/src/main/java/io/github/moulberry/notenoughupdates/GuiTextures.java
index 1f87018b..9fcb218f 100644
--- a/src/main/java/io/github/moulberry/notenoughupdates/GuiTextures.java
+++ b/src/main/java/io/github/moulberry/notenoughupdates/GuiTextures.java
@@ -24,6 +24,12 @@ public class GuiTextures {
     public static final ResourceLocation item_mask = new ResourceLocation("notenoughupdates:item_mask.png");
     public static final ResourceLocation button_tex = new ResourceLocation("notenoughupdates:button.png");
 
+    public static final ResourceLocation gamemodes = new ResourceLocation("notenoughupdates:gamemodes.png");
+    public static final ResourceLocation radial_square_off = new ResourceLocation("notenoughupdates:radial_square_off.png");
+    public static final ResourceLocation radial_square_on = new ResourceLocation("notenoughupdates:radial_square_on.png");
+    public static final ResourceLocation radial_circle_off = new ResourceLocation("notenoughupdates:radial_circle_off.png");
+    public static final ResourceLocation radial_circle_on = new ResourceLocation("notenoughupdates:radial_circle_on.png");
+
     public static final ResourceLocation dungeon_chest_worth = new ResourceLocation("notenoughupdates:dungeon_chest_worth.png");
 
     public static final ResourceLocation auction_view = new ResourceLocation("notenoughupdates:auction_view.png");
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/NEUEventListener.java b/src/main/java/io/github/moulberry/notenoughupdates/NEUEventListener.java
new file mode 100644
index 00000000..fc7db07b
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/NEUEventListener.java
@@ -0,0 +1,1006 @@
+package io.github.moulberry.notenoughupdates;
+
+import com.google.gson.JsonObject;
+import io.github.moulberry.notenoughupdates.auction.CustomAHGui;
+import io.github.moulberry.notenoughupdates.gamemodes.SBGamemodes;
+import io.github.moulberry.notenoughupdates.profileviewer.GuiProfileViewer;
+import io.github.moulberry.notenoughupdates.profileviewer.ProfileViewer;
+import io.github.moulberry.notenoughupdates.questing.SBScoreboardData;
+import io.github.moulberry.notenoughupdates.util.Utils;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.Gui;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.client.gui.inventory.GuiChest;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.gui.inventory.GuiCrafting;
+import net.minecraft.client.gui.inventory.GuiEditSign;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.event.ClickEvent;
+import net.minecraft.init.Blocks;
+import net.minecraft.inventory.ContainerChest;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.client.event.*;
+import net.minecraftforge.event.entity.player.ItemTooltipEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.opengl.GL11;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.datatransfer.StringSelection;
+import java.io.File;
+import java.io.IOException;
+import java.text.NumberFormat;
+import java.util.*;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static io.github.moulberry.notenoughupdates.GuiTextures.dungeon_chest_worth;
+
+public class NEUEventListener {
+
+    private NotEnoughUpdates neu;
+
+    private boolean hoverInv = false;
+    private boolean focusInv = false;
+
+    private boolean joinedSB = false;
+
+    public NEUEventListener(NotEnoughUpdates neu) {
+        this.neu = neu;
+    }
+
+    private void displayUpdateMessageIfOutOfDate() {
+        File repo = neu.manager.repoLocation;
+        if(repo.exists()) {
+            File updateJson = new File(repo, "update.json");
+            try {
+                JsonObject o = neu.manager.getJsonFromFile(updateJson);
+
+                String version = o.get("version").getAsString();
+
+                if(!neu.VERSION.equalsIgnoreCase(version)) {
+                    String update_msg = o.get("update_msg").getAsString();
+                    String discord_link = o.get("discord_link").getAsString();
+                    String youtube_link = o.get("youtube_link").getAsString();
+                    String update_link = o.get("update_link").getAsString();
+                    String github_link = o.get("github_link").getAsString();
+                    String other_text = o.get("other_text").getAsString();
+                    String other_link = o.get("other_link").getAsString();
+
+                    int first_len = -1;
+                    for(String line : update_msg.split("\n")) {
+                        FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;
+                        int len = fr.getStringWidth(line);
+                        if(first_len == -1) {
+                            first_len = len;
+                        }
+                        int missing_len = first_len-len;
+                        if(missing_len > 0) {
+                            StringBuilder sb = new StringBuilder(line);
+                            for(int i=0; i<missing_len/8; i++) {
+                                sb.insert(0, " ");
+                            }
+                            line = sb.toString();
+                        }
+                        line = line.replaceAll("\\{version}", version);
+                        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(line));
+                    }
+
+                    neu.displayLinks(o);
+
+                    Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(""));
+
+                }
+            } catch(Exception ignored) {}
+        }
+    }
+
+    /**
+     * 1)Will send the cached message from #sendChatMessage when at least 200ms has passed since the last message.
+     * This is used in order to prevent the mod spamming messages.
+     * 2)Adds unique items to the collection log
+     */
+    private HashMap<String, Long> newItemAddMap = new HashMap<>();
+    private long lastLongUpdate = 0;
+    private long lastSkyblockScoreboard = 0;
+    @SubscribeEvent
+    public void onTick(TickEvent.ClientTickEvent event) {
+        if(event.phase != TickEvent.Phase.START) return;
+
+        boolean longUpdate = false;
+        long currentTime = System.currentTimeMillis();
+        if(currentTime - lastLongUpdate > 1000) {
+            longUpdate = true;
+            lastLongUpdate = currentTime;
+        }
+        if(longUpdate) {
+            neu.updateSkyblockScoreboard();
+            if(neu.hasSkyblockScoreboard()) {
+                lastSkyblockScoreboard = currentTime;
+                if(!joinedSB) {
+                    joinedSB = true;
+
+                    SBGamemodes.loadFromFile();
+
+                    if(neu.manager.config.showUpdateMsg.value) {
+                        displayUpdateMessageIfOutOfDate();
+                    }
+
+                    if(!neu.manager.config.loadedModBefore.value) {
+                        neu.manager.config.loadedModBefore.value = true;
+                        try { neu.manager.saveConfig(); } catch(IOException e) {}
+
+                        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(""));
+                        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(
+                                EnumChatFormatting.BLUE+"It seems this is your first time using NotEnoughUpdates."));
+                        ChatComponentText clickText = new ChatComponentText(
+                                EnumChatFormatting.YELLOW+"Click this message if you would like to view a short tutorial.");
+                        clickText.setChatStyle(Utils.createClickStyle(ClickEvent.Action.RUN_COMMAND, "/neututorial"));
+                        Minecraft.getMinecraft().thePlayer.addChatMessage(clickText);
+                        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(""));
+                    }
+                }
+                SBScoreboardData.getInstance().tick();
+                //GuiQuestLine.questLine.tick();
+            }
+            if(currentTime - lastSkyblockScoreboard < 5*60*1000) { //5 minutes
+                neu.manager.auctionManager.tick();
+            } else {
+                neu.manager.auctionManager.markNeedsUpdate();
+            }
+            //ItemRarityHalo.resetItemHaloCache();
+        }
+        if(longUpdate && neu.hasSkyblockScoreboard()) {
+            if(neu.manager.getCurrentProfile() == null || neu.manager.getCurrentProfile().length() == 0) {
+                ProfileViewer.Profile profile = neu.profileViewer.getProfile(
+                        Minecraft.getMinecraft().thePlayer.getUniqueID().toString().replace("-", ""), (json) -> {});
+                if(profile != null) {
+                    String latest = profile.getLatestProfile();
+                    if(latest != null) {
+                        neu.manager.setCurrentProfileBackup(profile.getLatestProfile());
+                    }
+                }
+            }
+            if(neu.manager.getCurrentProfile() != null && neu.manager.getCurrentProfile().length() > 0) {
+                HashSet<String> newItem = new HashSet<>();
+                if(Minecraft.getMinecraft().currentScreen instanceof GuiContainer &&
+                        !(Minecraft.getMinecraft().currentScreen instanceof GuiCrafting)) {
+                    boolean usableContainer = true;
+                    for(ItemStack stack : Minecraft.getMinecraft().thePlayer.openContainer.getInventory()) {
+                        if(stack == null) {
+                            continue;
+                        }
+                        if(stack.hasTagCompound()) {
+                            NBTTagCompound tag = stack.getTagCompound();
+                            if(tag.hasKey("ExtraAttributes", 10)) {
+                                continue;
+                            }
+                        }
+                        usableContainer = false;
+                        break;
+                    }
+                    if(!usableContainer) {
+                        if(Minecraft.getMinecraft().currentScreen instanceof GuiChest) {
+                            GuiChest chest = (GuiChest) Minecraft.getMinecraft().currentScreen;
+                            ContainerChest container = (ContainerChest) chest.inventorySlots;
+                            String containerName = container.getLowerChestInventory().getDisplayName().getUnformattedText();
+
+                            if(containerName.equals("Accessory Bag") || containerName.startsWith("Wardrobe")) {
+                                usableContainer = true;
+                            }
+                        }
+                    }
+                    if(usableContainer) {
+                        for(ItemStack stack : Minecraft.getMinecraft().thePlayer.inventory.mainInventory) {
+                            processUniqueStack(stack, newItem);
+                        }
+                        for(ItemStack stack : Minecraft.getMinecraft().thePlayer.openContainer.getInventory()) {
+                            processUniqueStack(stack, newItem);
+                        }
+                    }
+                } else {
+                    for(ItemStack stack : Minecraft.getMinecraft().thePlayer.inventory.mainInventory) {
+                        processUniqueStack(stack, newItem);
+                    }
+                }
+                newItemAddMap.keySet().retainAll(newItem);
+            }
+        }
+    }
+
+    private void processUniqueStack(ItemStack stack, HashSet<String> newItem) {
+        if(stack != null && stack.hasTagCompound()) {
+            String internalname = neu.manager.getInternalNameForItem(stack);
+            if(internalname != null) {
+                ArrayList<String> log = neu.manager.config.collectionLog.value.computeIfAbsent(
+                        neu.manager.getCurrentProfile(), k -> new ArrayList<>());
+                if(!log.contains(internalname)) {
+                    newItem.add(internalname);
+                    if(newItemAddMap.containsKey(internalname)) {
+                        if(System.currentTimeMillis() - newItemAddMap.get(internalname) > 1000) {
+                            log.add(internalname);
+                            try { neu.manager.saveConfig(); } catch(IOException ignored) {}
+                        }
+                    } else {
+                        newItemAddMap.put(internalname, System.currentTimeMillis());
+                    }
+                }
+            }
+        }
+    }
+
+    @SubscribeEvent(priority= EventPriority.HIGHEST)
+    public void onRenderEntitySpecials(RenderLivingEvent.Specials.Pre event) {
+        if(Minecraft.getMinecraft().currentScreen instanceof GuiProfileViewer) {
+            if(((GuiProfileViewer)Minecraft.getMinecraft().currentScreen).getEntityPlayer() == event.entity) {
+                event.setCanceled(true);
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void onRenderGameOverlay(RenderGameOverlayEvent event) {
+        if(event.type != null && event.type.equals(RenderGameOverlayEvent.ElementType.BOSSHEALTH) &&
+                Minecraft.getMinecraft().currentScreen instanceof GuiContainer && neu.overlay.isUsingMobsFilter()) {
+            event.setCanceled(true);
+        }
+    }
+
+    /**
+     * When opening a GuiContainer, will reset the overlay and load the config.
+     * When closing a GuiContainer, will save the config.
+     * Also includes a dev feature used for automatically acquiring crafting information from the "Crafting Table" GUI.
+     */
+    AtomicBoolean missingRecipe = new AtomicBoolean(false);
+    @SubscribeEvent
+    public void onGuiOpen(GuiOpenEvent event) {
+        neu.manager.auctionManager.customAH.lastGuiScreenSwitch = System.currentTimeMillis();
+
+        if(event.gui == null && neu.manager.auctionManager.customAH.isRenderOverAuctionView() &&
+                !(Minecraft.getMinecraft().currentScreen instanceof CustomAHGui)) {
+            event.gui = new CustomAHGui();
+        }
+
+        if(!(event.gui instanceof GuiChest || event.gui instanceof GuiEditSign)) {
+            neu.manager.auctionManager.customAH.setRenderOverAuctionView(false);
+        } else if(event.gui instanceof GuiChest && (neu.manager.auctionManager.customAH.isRenderOverAuctionView() ||
+                Minecraft.getMinecraft().currentScreen instanceof CustomAHGui)){
+            GuiChest chest = (GuiChest) event.gui;
+            ContainerChest container = (ContainerChest) chest.inventorySlots;
+            String containerName = container.getLowerChestInventory().getDisplayName().getUnformattedText();
+
+            neu.manager.auctionManager.customAH.setRenderOverAuctionView(containerName.trim().equals("Auction View") ||
+                    containerName.trim().equals("BIN Auction View") || containerName.trim().equals("Confirm Bid") ||
+                    containerName.trim().equals("Confirm Purchase"));
+        }
+
+        //OPEN
+        if(Minecraft.getMinecraft().currentScreen == null
+                && event.gui instanceof GuiContainer) {
+            neu.overlay.reset();
+            neu.manager.loadConfig();
+        }
+        //CLOSE
+        if(Minecraft.getMinecraft().currentScreen instanceof GuiContainer
+                && event.gui == null) {
+            try {
+                neu.manager.saveConfig();
+            } catch(IOException e) {}
+        }
+        if(event.gui != null && neu.manager.config.dev.value) {
+            if(event.gui instanceof GuiChest) {
+                GuiChest eventGui = (GuiChest) event.gui;
+                ContainerChest cc = (ContainerChest) eventGui.inventorySlots;
+                IInventory lower = cc.getLowerChestInventory();
+                ses.schedule(() -> {
+                    if(Minecraft.getMinecraft().currentScreen != event.gui) {
+                        return;
+                    }
+                    if(lower.getStackInSlot(23).getDisplayName().endsWith("Crafting Table")) {
+                        try {
+                            ItemStack res = lower.getStackInSlot(25);
+                            String resInternalname = neu.manager.getInternalNameForItem(res);
+
+                            if(lower.getStackInSlot(48) != null) {
+                                String backName = null;
+                                NBTTagCompound tag = lower.getStackInSlot(48).getTagCompound();
+                                if(tag.hasKey("display", 10)) {
+                                    NBTTagCompound nbttagcompound = tag.getCompoundTag("display");
+                                    if(nbttagcompound.getTagId("Lore") == 9){
+                                        NBTTagList nbttaglist1 = nbttagcompound.getTagList("Lore", 8);
+                                        backName = nbttaglist1.getStringTagAt(0);
+                                    }
+                                }
+
+                                if(backName != null) {
+                                    String[] split = backName.split(" ");
+                                    if(split[split.length-1].contains("Rewards")) {
+                                        String col = backName.substring(split[0].length()+1,
+                                                backName.length()-split[split.length-1].length()-1);
+
+                                        JsonObject json = neu.manager.getItemInformation().get(resInternalname);
+                                        json.addProperty("crafttext", "Requires: " + col);
+
+                                        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("Added: " + resInternalname));
+                                        neu.manager.writeJsonDefaultDir(json, resInternalname+".json");
+                                        neu.manager.loadItem(resInternalname);
+                                    }
+                                }
+                            }
+
+                            /*JsonArray arr = null;
+                            File f = new File(neu.manager.configLocation, "missing.json");
+                            try(InputStream instream = new FileInputStream(f)) {
+                                BufferedReader reader = new BufferedReader(new InputStreamReader(instream, StandardCharsets.UTF_8));
+                                JsonObject json = neu.manager.gson.fromJson(reader, JsonObject.class);
+                                arr = json.getAsJsonArray("missing");
+                            } catch(IOException e) {}
+                            try {
+                                JsonObject json = new JsonObject();
+                                JsonArray newArr = new JsonArray();
+                                for(JsonElement e : arr) {
+                                    if(!e.getAsString().equals(resInternalname)) {
+                                        newArr.add(e);
+                                    }
+                                }
+                                json.add("missing", newArr);
+                                neu.manager.writeJson(json, f);
+                            } catch(IOException e) {}*/
+
+
+
+                            /*JsonObject recipe = new JsonObject();
+
+                            String[] x = {"1","2","3"};
+                            String[] y = {"A","B","C"};
+
+                            for(int i=0; i<=18; i+=9) {
+                                for(int j=0; j<3; j++) {
+                                    ItemStack stack = lower.getStackInSlot(10+i+j);
+                                    String internalname = "";
+                                    if(stack != null) {
+                                        internalname = neu.manager.getInternalNameForItem(stack);
+                                        if(!neu.manager.getItemInformation().containsKey(internalname)) {
+                                            neu.manager.writeItemToFile(stack);
+                                        }
+                                        internalname += ":"+stack.stackSize;
+                                    }
+                                    recipe.addProperty(y[i/9]+x[j], internalname);
+                                }
+                            }
+
+                            JsonObject json = neu.manager.getJsonForItem(res);
+                            json.add("recipe", recipe);
+                            json.addProperty("internalname", resInternalname);
+                            json.addProperty("clickcommand", "viewrecipe");
+                            json.addProperty("modver", NotEnoughUpdates.VERSION);
+
+                            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("Added: " + resInternalname));
+                            neu.manager.writeJsonDefaultDir(json, resInternalname+".json");
+                            neu.manager.loadItem(resInternalname);*/
+                        } catch(Exception e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }, 200, TimeUnit.MILLISECONDS);
+                return;
+            }
+        }
+    }
+
+    /**
+     * 1) When receiving "You are playing on profile" messages, will set the current profile.
+     * 2) When a /viewrecipe command fails (i.e. player does not have recipe unlocked, will open the custom recipe GUI)
+     * 3) Replaces lobby join notifications when streamer mode is active
+     */
+    @SubscribeEvent(priority = EventPriority.LOW)
+    public void onGuiChat(ClientChatReceivedEvent e) {
+        String r = null;
+        String unformatted = Utils.cleanColour(e.message.getUnformattedText());
+        if(unformatted.startsWith("You are playing on profile: ")) {
+            neu.manager.setCurrentProfile(unformatted.substring("You are playing on profile: ".length()).split(" ")[0].trim());
+        } else if(unformatted.startsWith("Your profile was changed to: ")) {//Your profile was changed to:
+            neu.manager.setCurrentProfile(unformatted.substring("Your profile was changed to: ".length()).split(" ")[0].trim());
+        } else if(unformatted.startsWith("Your new API key is ")) {
+            neu.manager.config.apiKey.value = unformatted.substring("Your new API key is ".length());
+            try { neu.manager.saveConfig(); } catch(IOException ioe) {}
+        }
+        if(e.message.getFormattedText().equals(EnumChatFormatting.RESET.toString()+
+                EnumChatFormatting.RED+"You haven't unlocked this recipe!"+EnumChatFormatting.RESET)) {
+            r =  EnumChatFormatting.RED+"You haven't unlocked this recipe!";
+        } else if(e.message.getFormattedText().startsWith(EnumChatFormatting.RESET.toString()+
+                EnumChatFormatting.RED+"Invalid recipe ")) {
+            r = "";
+        }
+        if(r != null) {
+            if(neu.manager.failViewItem(r)) {
+                e.setCanceled(true);
+            }
+            missingRecipe.set(true);
+        }
+        //System.out.println(e.message);
+        if(unformatted.startsWith("Sending to server") &&
+                neu.isOnSkyblock() && neu.manager.config.streamerMode.value && e.message instanceof ChatComponentText) {
+            String m = e.message.getFormattedText();
+            String m2 = StreamerMode.filterChat(e.message.getFormattedText());
+            if(!m.equals(m2)) {
+                e.message = new ChatComponentText(m2);
+            }
+        }
+    }
+
+    /**
+     * Sets hoverInv and focusInv variables, representing whether the NEUOverlay should render behind the inventory when
+     * (hoverInv == true) and whether mouse/kbd inputs shouldn't be sent to NEUOverlay (focusInv == true).
+     *
+     * If hoverInv is true, will render the overlay immediately (resulting in the inventory being drawn over the GUI)
+     * If hoverInv is false, the overlay will render in #onGuiScreenDraw (resulting in the GUI being drawn over the inv)
+     *
+     * All of this only matters if players are using gui scale auto which may result in the inventory being drawn
+     * over the various panes.
+     * @param event
+     */
+    @SubscribeEvent
+    public void onGuiBackgroundDraw(GuiScreenEvent.BackgroundDrawnEvent event) {
+        if((shouldRenderOverlay(event.gui) || event.gui instanceof CustomAHGui) && neu.isOnSkyblock()) {
+            ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+            int width = scaledresolution.getScaledWidth();
+
+            boolean hoverPane = event.getMouseX() < width*neu.overlay.getInfoPaneOffsetFactor() ||
+                    event.getMouseX() > width*neu.overlay.getItemPaneOffsetFactor();
+
+            if(event.gui instanceof GuiContainer) {
+                try {
+                    int xSize = (int) Utils.getField(GuiContainer.class, event.gui, "xSize", "field_146999_f");
+                    int ySize = (int) Utils.getField(GuiContainer.class, event.gui, "ySize", "field_147000_g");
+                    int guiLeft = (int) Utils.getField(GuiContainer.class, event.gui, "guiLeft", "field_147003_i");
+                    int guiTop = (int) Utils.getField(GuiContainer.class, event.gui, "guiTop", "field_147009_r");
+
+                    hoverInv = event.getMouseX() > guiLeft && event.getMouseX() < guiLeft + xSize &&
+                            event.getMouseY() > guiTop && event.getMouseY() < guiTop + ySize;
+
+                    if(hoverPane) {
+                        if(!hoverInv) focusInv = false;
+                    } else {
+                        focusInv = true;
+                    }
+                } catch(NullPointerException npe) {
+                    npe.printStackTrace();
+                    focusInv = !hoverPane;
+                }
+            }
+            if(event.gui instanceof GuiItemRecipe) {
+                GuiItemRecipe guiItemRecipe = ((GuiItemRecipe)event.gui);
+                hoverInv = event.getMouseX() > guiItemRecipe.guiLeft && event.getMouseX() < guiItemRecipe.guiLeft + guiItemRecipe.xSize &&
+                        event.getMouseY() > guiItemRecipe.guiTop && event.getMouseY() < guiItemRecipe.guiTop + guiItemRecipe.ySize;
+
+                if(hoverPane) {
+                    if(!hoverInv) focusInv = false;
+                } else {
+                    focusInv = true;
+                }
+            }
+            if(focusInv) {
+                try {
+                    neu.overlay.render(event.getMouseX(), event.getMouseY(), hoverInv && focusInv);
+                } catch(ConcurrentModificationException e) {e.printStackTrace();}
+                GL11.glTranslatef(0, 0, 10);
+            }
+        }
+
+        if(shouldRenderOverlay(event.gui) && neu.isOnSkyblock()) {
+            renderDungeonChestOverlay(event.gui);
+        }
+    }
+
+    @SubscribeEvent
+    public void onGuiScreenDrawPre(GuiScreenEvent.DrawScreenEvent.Pre event) {
+        if(event.gui instanceof CustomAHGui || neu.manager.auctionManager.customAH.isRenderOverAuctionView()) {
+            event.setCanceled(true);
+
+            ScaledResolution scaledResolution = new ScaledResolution(Minecraft.getMinecraft());
+            int width = scaledResolution.getScaledWidth();
+            int height = scaledResolution.getScaledHeight();
+
+            //Dark background
+            Utils.drawGradientRect(0, 0, width, height, -1072689136, -804253680);
+
+            if(event.mouseX < width*neu.overlay.getWidthMult()/3 || event.mouseX > width-width*neu.overlay.getWidthMult()/3) {
+                neu.manager.auctionManager.customAH.drawScreen(event.mouseX, event.mouseY);
+                neu.overlay.render(event.mouseX, event.mouseY, false);
+            } else {
+                neu.overlay.render(event.mouseX, event.mouseY, false);
+                neu.manager.auctionManager.customAH.drawScreen(event.mouseX, event.mouseY);
+            }
+        }
+    }
+
+    private static boolean shouldRenderOverlay(Gui gui) {
+        boolean validGui = gui instanceof GuiContainer || gui instanceof GuiItemRecipe;
+        if(gui instanceof GuiChest) {
+            GuiChest eventGui = (GuiChest) gui;
+            ContainerChest cc = (ContainerChest) eventGui.inventorySlots;
+            String containerName = cc.getLowerChestInventory().getDisplayName().getUnformattedText();
+            if(containerName.trim().equals("Fast Travel")) {
+                validGui = false;
+            }
+        }
+        return validGui;
+    }
+
+    /**
+     * Will draw the NEUOverlay over the inventory if focusInv == false. (z-translation of 300 is so that NEUOverlay
+     * will draw over Items in the inventory (which render at a z value of about 250))
+     * @param event
+     */
+    @SubscribeEvent
+    public void onGuiScreenDrawPost(GuiScreenEvent.DrawScreenEvent.Post event) {
+        if(!(event.gui instanceof CustomAHGui || neu.manager.auctionManager.customAH.isRenderOverAuctionView())) {
+            if(shouldRenderOverlay(event.gui) && neu.isOnSkyblock()) {
+                if(!focusInv) {
+                    GL11.glTranslatef(0, 0, 300);
+                    neu.overlay.render(event.mouseX, event.mouseY, hoverInv && focusInv);
+                    GL11.glTranslatef(0, 0, -300);
+                }
+                neu.overlay.renderOverlay(event.mouseX, event.mouseY);
+            }
+        }
+    }
+
+    private void renderDungeonChestOverlay(GuiScreen gui) {
+        if(gui instanceof GuiChest && neu.manager.auctionManager.activeAuctions > 0) {
+            try {
+                int xSize = (int) Utils.getField(GuiContainer.class, gui, "xSize", "field_146999_f");
+                int ySize = (int) Utils.getField(GuiContainer.class, gui, "ySize", "field_147000_g");
+                int guiLeft = (int) Utils.getField(GuiContainer.class, gui, "guiLeft", "field_147003_i");
+                int guiTop = (int) Utils.getField(GuiContainer.class, gui, "guiTop", "field_147009_r");
+
+                GuiChest eventGui = (GuiChest) gui;
+                ContainerChest cc = (ContainerChest) eventGui.inventorySlots;
+                IInventory lower = cc.getLowerChestInventory();
+
+                ItemStack rew