path: root/src/main/java/me/Danker/TheMod.java

package me.Danker;

import java.awt.Image;
import java.awt.SystemTray;
import java.awt.Toolkit;
import java.awt.TrayIcon;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Pattern;

import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;

import com.google.gson.JsonObject;

import me.Danker.commands.ArmourCommand;
import me.Danker.commands.BankCommand;
import me.Danker.commands.BlockSlayerCommand;
import me.Danker.commands.DHelpCommand;
import me.Danker.commands.DankerGuiCommand;
import me.Danker.commands.DisplayCommand;
import me.Danker.commands.DungeonsCommand;
import me.Danker.commands.GetkeyCommand;
import me.Danker.commands.GuildOfCommand;
import me.Danker.commands.ImportFishingCommand;
import me.Danker.commands.LobbySkillsCommand;
import me.Danker.commands.LootCommand;
import me.Danker.commands.MoveCommand;
import me.Danker.commands.PetsCommand;
import me.Danker.commands.ReloadConfigCommand;
import me.Danker.commands.ResetLootCommand;
import me.Danker.commands.ScaleCommand;
import me.Danker.commands.SetkeyCommand;
import me.Danker.commands.SkillsCommand;
import me.Danker.commands.SkyblockPlayersCommand;
import me.Danker.commands.SlayerCommand;
import me.Danker.commands.ToggleCommand;
import me.Danker.gui.DankerGui;
import me.Danker.gui.DisplayGui;
import me.Danker.gui.EditLocationsGui;
import me.Danker.gui.OnlySlayerGui;
import me.Danker.gui.PuzzleSolversGui;
import me.Danker.handlers.APIHandler;
import me.Danker.handlers.ConfigHandler;
import me.Danker.handlers.PacketHandler;
import me.Danker.handlers.ScoreboardHandler;
import me.Danker.handlers.TextRenderer;
import me.Danker.utils.Utils;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiChat;
import net.minecraft.client.gui.inventory.GuiChest;
import net.minecraft.client.settings.KeyBinding;
import net.minecraft.entity.Entity;
import net.minecraft.entity.monster.EntityCreeper;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.event.ClickEvent;
import net.minecraft.event.ClickEvent.Action;
import net.minecraft.init.Blocks;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.ContainerChest;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.BlockPos;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.IChatComponent;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.StringUtils;
import net.minecraft.util.Vec3;
import net.minecraft.world.World;
import net.minecraftforge.client.ClientCommandHandler;
import net.minecraftforge.client.event.ClientChatReceivedEvent;
import net.minecraftforge.client.event.GuiScreenEvent;
import net.minecraftforge.client.event.RenderGameOverlayEvent;
import net.minecraftforge.client.event.RenderWorldLastEvent;
import net.minecraftforge.client.event.sound.PlaySoundEvent;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.entity.EntityJoinWorldEvent;
import net.minecraftforge.event.entity.player.ItemTooltipEvent;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.event.world.WorldEvent;
import net.minecraftforge.fml.client.registry.ClientRegistry;
import net.minecraftforge.fml.common.Loader;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.common.Mod.EventHandler;
import net.minecraftforge.fml.common.event.FMLInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
import net.minecraftforge.fml.common.eventhandler.EventPriority;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.InputEvent.KeyInputEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent.Phase;
import net.minecraftforge.fml.common.network.FMLNetworkEvent.ClientConnectedToServerEvent;
import net.minecraftforge.fml.common.versioning.DefaultArtifactVersion;

@Mod(modid = TheMod.MODID, version = TheMod.VERSION, clientSideOnly = true)
public class TheMod
{
    public static final String MODID = "Danker's Skyblock Mod";
    public static final String VERSION = "1.8.1";
    
    static double checkItemsNow = 0;
    static double itemsChecked = 0;
    public static Map<String, String> t6Enchants = new HashMap<String, String>();
    public static Pattern pattern = Pattern.compile("");
    static boolean updateChecked = false;
    public static int titleTimer = -1;
    public static boolean showTitle = false;
    public static String titleText = "";
    public static int SKILL_TIME;
    public static int skillTimer = -1;
    public static boolean showSkill = false;
    public static String skillText = "";
    static int tickAmount = 1;
    static String lastMaddoxCommand = "/cb placeholder";
    static double lastMaddoxTime = 0;
    static KeyBinding[] keyBindings = new KeyBinding[1];
    static int lastMouse = -1;
    static boolean usingLabymod = false;
    public static String guiToOpen = null;
    static String[] riddleSolutions = {"The reward is not in my chest!", "At least one of them is lying, and the reward is not in", 
    								   "My chest doesn't have the reward. We are all telling the truth", "My chest has the reward and I'm telling the truth",
    								   "The reward isn't in any of our chests", "Both of them are telling the truth."};
    static Map<String, String[]> triviaSolutions = new HashMap<String, String[]>();
    static String[] triviaAnswers = null;
    static Entity highestBlaze = null;
	static Entity lowestBlaze = null;
	// Among Us colours
	static final int[] CREEPER_COLOURS = {0x50EF39, 0xC51111, 0x132ED1, 0x117F2D, 0xED54BA, 0xEF7D0D, 0xF5F557, 0xD6E0F0, 0x6B2FBB, 0x39FEDC};
	static boolean drawCreeperLines = false;
	static Vec3 creeperLocation = new Vec3(0, 0, 0);
	static List<Vec3[]> creeperLines = new ArrayList<Vec3[]>();
	static boolean prevInWaterRoom = false;
	static boolean inWaterRoom = false;
	static boolean foundLivid = false;
	static Entity livid = null;
	public static double cakeTime;
	
	public static final ResourceLocation CAKE_ICON = new ResourceLocation("dsm", "icons/cake.png");
    
    static double dungeonStartTime = 0;
    static double bloodOpenTime = 0;
    static double watcherClearTime = 0;
    static double bossClearTime = 0;
    static int witherDoors = 0;
    static int dungeonDeaths = 0;
    static int puzzleFails = 0;
    
    public static String MAIN_COLOUR;
    public static String SECONDARY_COLOUR;
    public static String ERROR_COLOUR;
    public static String DELIMITER_COLOUR;
    public static String TYPE_COLOUR;
    public static String VALUE_COLOUR;
    public static String SKILL_AVERAGE_COLOUR;
    public static String ANSWER_COLOUR;
    public static String SKILL_50_COLOUR;
    public static String COORDS_COLOUR;
    public static String CAKE_COLOUR;
    
    @EventHandler
    public void init(FMLInitializationEvent event) {
		MinecraftForge.EVENT_BUS.register(this);
		MinecraftForge.EVENT_BUS.register(new PacketHandler());
		
		ConfigHandler.reloadConfig();
		
		// For golden enchants
		t6Enchants.put("9Angler VI", "6Angler VI");
		t6Enchants.put("9Bane of Arthropods VI", "6Bane of Arthropods VI");
		t6Enchants.put("9Caster VI", "6Caster VI");
		t6Enchants.put("9Compact X", "6Compact X");
		t6Enchants.put("9Critical VI", "6Critical VI");
		t6Enchants.put("9Dragon Hunter V", "6Dragon Hunter V");
		t6Enchants.put("9Efficiency VI", "6Efficiency VI");
		t6Enchants.put("9Ender Slayer VI", "6Ender Slayer VI");
		t6Enchants.put("9Experience IV", "6Experience IV");
		t6Enchants.put("9Expertise X", "6Expertise X");
		t6Enchants.put("9Feather Falling X", "6Feather Falling X");
		t6Enchants.put("9Frail VI", "6Frail VI");
		t6Enchants.put("9Giant Killer VI", "6Giant Killer VI");
		t6Enchants.put("9Growth VI", "6Growth VI");
		t6Enchants.put("9Infinite Quiver X", "6Infinite Quiver X");
		t6Enchants.put("9Lethality VI", "6Lethality VI"); 
		t6Enchants.put("9Life Steal IV", "6Life Steal IV");
		t6Enchants.put("9Looting IV", "6Looting IV");
		t6Enchants.put("9Luck VI", "6Luck VI");
		t6Enchants.put("9Luck of the Sea VI", "6Luck of the Sea VI");
		t6Enchants.put("9Lure VI", "6Lure VI");
		t6Enchants.put("9Magnet VI", "6Magnet VI");
		t6Enchants.put("9Overload V", "6Overload V");
		t6Enchants.put("9Power VI", "6Power VI");
		t6Enchants.put("9Protection VI", "6Protection VI");
		t6Enchants.put("9Scavenger IV", "6Scavenger IV");
		t6Enchants.put("9Scavenger V", "6Scavenger V");
		t6Enchants.put("9Sharpness VI", "6Sharpness VI");
		t6Enchants.put("9Smite VI", "6Smite VI");
		t6Enchants.put("9Spiked Hook VI", "6Spiked Hook VI");
		t6Enchants.put("9Thunderlord VI", "6Thunderlord VI");
		t6Enchants.put("9Vampirism VI", "6Vampirism VI");
		
		triviaSolutions.put("What is the status of The Watcher?", new String[]{"Stalker"});
		triviaSolutions.put("What is the status of Bonzo?", new String[]{"New Necromancer"});
		triviaSolutions.put("What is the status of Scarf?", new String[]{"Apprentice Necromancer"});
		triviaSolutions.put("What is the status of The Professor?", new String[]{"Professor"});
		triviaSolutions.put("What is the status of Thorn?", new String[]{"Shaman Necromancer"});
		triviaSolutions.put("What is the status of Livid?", new String[]{"Master Necromancer"});
		triviaSolutions.put("What is the status of Sadan?", new String[]{"Necromancer Lord"});
		triviaSolutions.put("What is the status of Maxor?", new String[]{"Young Wither"});
		triviaSolutions.put("What is the status of Goldor?", new String[]{"Wither Soldier"});
		triviaSolutions.put("What is the status of Storm?", new String[]{"Elementalist"});
		triviaSolutions.put("What is the status of Necron?", new String[]{"Wither Lord"});
		triviaSolutions.put("How many total Fairy Souls are there?", new String[]{"209 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in Spider's Den?", new String[]{"17 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in The End?", new String[]{"12 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in The Barn?", new String[]{"7 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in Mushroom Desert?", new String[]{"8 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in Blazing Fortress?", new String[]{"19 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in The Park?", new String[]{"11 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in Jerry's Workshop?", new String[]{"5 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in Hub?", new String[]{"79 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in The Hub?", new String[]{"79 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in Deep Caverns?", new String[]{"21 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in Gold Mine?", new String[]{"12 Fairy Souls"});
		triviaSolutions.put("How many Fairy Souls are there in Dungeon Hub?", new String[]{"7 Fairy Souls"});
		triviaSolutions.put("Which brother is on the Spider's Den?", new String[]{"Rick"});
		triviaSolutions.put("What is the name of Rick's brother?", new String[]{"Pat"});
		triviaSolutions.put("What is the name of the Painter in the Hub?", new String[]{"Marco"});
		triviaSolutions.put("What is the name of the person that upgrades pets?", new String[]{"Kat"});
		triviaSolutions.put("What is the name of the lady of the Nether?", new String[]{"Elle"});
		triviaSolutions.put("Which villager in the Village gives you a Rogue Sword?", new String[]{"Jamie"});
		triviaSolutions.put("How many unique minions are there?", new String[]{"52 Minions"});
		triviaSolutions.put("Which of these enemies does not spawn in the Spider's Den?", new String[]{"Zombie Spider", "Cave Spider", "Wither Skeleton", "Dashing Spooder", "Broodfather", "Night Spider"});
		triviaSolutions.put("Which of these monsters only spawns at night?", new String[]{"Zombie Villager", "Ghast"});
		triviaSolutions.put("Which of these is not a dragon in The End?", new String[]{"Zoomer Dragon", "Weak Dragon", "Stonk Dragon", "Holy Dragon", "Boomer Dragon", "Booger Dragon", "Older Dragon", "Elder Dragon"});
		
		String patternString = "(" + String.join("|", t6Enchants.keySet()) + ")";
		pattern = Pattern.compile(patternString);
		
		keyBindings[0] = new KeyBinding("Open Maddox Menu", Keyboard.KEY_M, "Danker's Skyblock Mod");
		
		for (int i = 0; i < keyBindings.length; i++) {
			ClientRegistry.registerKeyBinding(keyBindings[i]);
		}
    }
    
    @EventHandler
    public void preInit(final FMLPreInitializationEvent event) {
    	ClientCommandHandler.instance.registerCommand(new ToggleCommand());
    	ClientCommandHandler.instance.registerCommand(new SetkeyCommand());
    	ClientCommandHandler.instance.registerCommand(new GetkeyCommand());
    	ClientCommandHandler.instance.registerCommand(new LootCommand());
    	ClientCommandHandler.instance.registerCommand(new ReloadConfigCommand());
    	ClientCommandHandler.instance.registerCommand(new DisplayCommand());
    	ClientCommandHandler.instance.registerCommand(new MoveCommand());
    	ClientCommandHandler.instance.registerCommand(new SlayerCommand());
    	ClientCommandHandler.instance.registerCommand(new SkillsCommand());
    	ClientCommandHandler.instance.registerCommand(new GuildOfCommand());
    	ClientCommandHandler.instance.registerCommand(new DHelpCommand());
    	ClientCommandHandler.instance.registerCommand(new PetsCommand());
    	ClientCommandHandler.instance.registerCommand(new BankCommand());
    	ClientCommandHandler.instance.registerCommand(new ArmourCommand());
    	ClientCommandHandler.instance.registerCommand(new ImportFishingCommand());
    	ClientCommandHandler.instance.registerCommand(new ResetLootCommand());
    	ClientCommandHandler.instance.registerCommand(new ScaleCommand());
    	ClientCommandHandler.instance.registerCommand(new SkyblockPlayersCommand());
    	ClientCommandHandler.instance.registerCommand(new BlockSlayerCommand());
    	ClientCommandHandler.instance.registerCommand(new DungeonsCommand());
    	ClientCommandHandler.instance.registerCommand(new LobbySkillsCommand());
    	ClientCommandHandler.instance.registerCommand(new DankerGuiCommand());	
    }
    
    @EventHandler
    public void postInit(final FMLPostInitializationEvent event) {
    	usingLabymod = Loader.isModLoaded("labymod");
    	System.out.println("LabyMod detection: " + usingLabymod);
    }
    
    // Update checker
    @SubscribeEvent
    public void onJoin(EntityJoinWorldEvent event) {
    	if (!updateChecked) {
			updateChecked = true;
			
    		// MULTI THREAD DRIFTING
    		new Thread(() -> {
    			EntityPlayer player = Minecraft.getMinecraft().thePlayer;	
    			
    			System.err.println("Checking for updates...");
    			JsonObject latestRelease = APIHandler.getResponse("https://api.github.com/repos/bowser0000/SkyblockMod/releases/latest");
    			
    			String latestTag = latestRelease.get("tag_name").getAsString();
    			DefaultArtifactVersion currentVersion = new DefaultArtifactVersion(VERSION);
    			DefaultArtifactVersion latestVersion = new DefaultArtifactVersion(latestTag.substring(1));
    			
    			if (currentVersion.compareTo(latestVersion) < 0) {
    				String releaseURL = latestRelease.get("html_url").getAsString();
    				
    				ChatComponentText update = new ChatComponentText(EnumChatFormatting.GREEN + "" + EnumChatFormatting.BOLD + "  [UPDATE]  ");
    				update.setChatStyle(update.getChatStyle().setChatClickEvent(new ClickEvent(Action.OPEN_URL, releaseURL)));
    					
    				try {
						Thread.sleep(2000);
					} catch (InterruptedException ex) {
						System.err.println(ex);
					}
    				player.addChatMessage(new ChatComponentText(ERROR_COLOUR + MODID + " is outdated. Please update to " + latestTag + ".\n").appendSibling(update));
    			}
    		}).start();
    	}
    }
    
    @SubscribeEvent
    public void onWorldChange(WorldEvent.Load event) {
    	foundLivid = false;
    	livid = null;
    }
    
    // It randomly broke, so I had to make it the highest priority
    @SubscribeEvent(priority = EventPriority.HIGHEST)
    public void onChat(ClientChatReceivedEvent event) {
    	String message = StringUtils.stripControlCodes(event.message.getUnformattedText());
    	
    	if (!Utils.inSkyblock) return;
    	
    	// Action Bar
    	if (event.type == 2) {
    		String[] actionBarSections = event.message.getUnformattedText().split(" {3,}");
    		for (String section : actionBarSections) {
    			if (ToggleCommand.skill50DisplayToggled) {
    				if (section.contains("+") && section.contains("/") && section.contains("(")) {
    					if (section.contains("Runecrafting")) return;
    					
    					String xpGained = section.substring(section.indexOf("+"), section.indexOf("(") - 1);
    					double currentXp = Double.parseDouble(section.substring(section.indexOf("(") + 1, section.indexOf("/")).replaceAll(",", ""));
    					int limit;
    					int totalXp;
    					if (section.contains("Farming")) {
    						limit = 60;
    						totalXp = 111672425;
    					} else {
    						limit = 50;
    						totalXp = 55172425;
    					}
    					int previousXp = Utils.getPastXpEarned(Integer.parseInt(section.substring(section.indexOf("/") + 1, section.indexOf(")")).replaceAll(",", "")), limit);
    					double percentage = (double) Math.floor(((currentXp + previousXp) / totalXp) * 10000D) / 100D;
    					
    					NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);
    					skillTimer = SKILL_TIME;
    					showSkill = true;
    					skillText = SKILL_50_COLOUR + xpGained + " (" + nf.format(currentXp + previousXp) + "/" + nf.format(totalXp) + ") " + percentage + "%";
    				}
    			}
    		}
    		return;
    	}
    	
        // Dungeon chat spoken by an NPC, containing :
        if (ToggleCommand.threeManToggled && Utils.inDungeons && message.contains("[NPC]")) {
        	for (String solution : riddleSolutions) {
        		if (message.contains(solution)) {
        			String npcName = message.substring(message.indexOf("]") + 2, message.indexOf(":"));
        			Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(ANSWER_COLOUR + EnumChatFormatting.BOLD + StringUtils.stripControlCodes(npcName) + MAIN_COLOUR + " has the blessing."));
        			break;
        		}
        	}
        }
        
        if (message.contains("[BOSS] The Watcher: You have proven yourself. You may pass.")) {
        	watcherClearTime = System.currentTimeMillis() / 1000;
        }
		if (message.contains("PUZZLE FAIL! ") || message.contains("chose the wrong answer! I shall never forget this moment")) {
			puzzleFails++;
		}
        
    	if (message.contains(":")) return;
    	
		// Spirit Sceptre
		if (!ToggleCommand.sceptreMessages && message.contains("Your Spirit Sceptre hit ")) {
			event.setCanceled(true);
			return;
		}
		// Midas Staff
		if (!ToggleCommand.midasStaffMessages && message.contains("Your Molten Wave hit ")) {
			event.setCanceled(true);
			return;
		}
		// Heals
		if (!ToggleCommand.healMessages && message.contains(" health!") && (message.contains("You healed ") || message.contains(" healed you for "))) {
			event.setCanceled(true);
			return;
		}
    	
        if (ToggleCommand.oruoToggled && Utils.inDungeons) {
        	// Don't set every answer to wrong with this question
        	if (message.contains("What SkyBlock year is it?")) triviaAnswers = null;
        	
        	for (String question : triviaSolutions.keySet()) {
        		if (message.contains(question)) {
        			triviaAnswers = triviaSolutions.get(question);
        			String answer = String.join(" OR ", triviaSolutions.get(question));
        			Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(MAIN_COLOUR + "Answer: " + ANSWER_COLOUR + EnumChatFormatting.BOLD + answer));
        			break;
        		}
        	}
        	
        	// Set wrong answers to red and remove click events
        	if (triviaAnswers != null && (message.contains("ⓐ") || message.contains("ⓑ") || message.contains("ⓒ"))) {
        		boolean isSolution = false;
        		for (String solution : triviaAnswers) {
        			if (message.contains(solution)) isSolution = true;
        		}
        		if (!isSolution) {
        			char letter = message.charAt(5);
        			String option = message.substring(6, message.length());
        			event.message = new ChatComponentText("     " + EnumChatFormatting.GOLD + letter + EnumChatFormatting.RED + option);
        			return;
        		}
        	}
        }
    	
		if (ToggleCommand.gpartyToggled) {
			if (message.contains(" has invited all members of ")) {
				try {
					final SystemTray tray = SystemTray.getSystemTray();
					final Image image = Toolkit.getDefaultToolkit().createImage("icon.png");
					final TrayIcon trayIcon = new TrayIcon(image, "Guild Party Notifier");
					trayIcon.setImageAutoSize(true);
					trayIcon.setToolTip("Guild Party Notifier");
					tray.add(trayIcon);
					trayIcon.displayMessage("Guild Party", message, TrayIcon.MessageType.INFO);
					tray.remove(trayIcon);
				} catch (Exception ex) {
					System.err.print(ex);
				}
			}
		}
		
		if (ToggleCommand.golemAlertToggled) {
			if (message.contains("The ground begins to shake as an Endstone Protector rises from below!")) {
				Utils.createTitle(EnumChatFormatting.RED + "GOLEM SPAWNING!", 3);
			}
		}
		
		if (message.contains("Yum! You gain +") && message.contains(" for 48 hours!")) {
			cakeTime = System.currentTimeMillis() / 1000 + 172800; // Add 48 hours
			ConfigHandler.writeDoubleConfig("misc", "cakeTime", cakeTime);
		}
		
		boolean wolfRNG = false;
		boolean spiderRNG = false;
		boolean zombieRNG = false;
		// T6 books
		if (message.contains("VERY RARE DROP!  (Enchanted Book)") || message.contains("CRAZY RARE DROP!  (Enchanted Book)")) {
			// Loop through scoreboard to see what boss you're doing
			List<String> scoreboard = ScoreboardHandler.getSidebarLines();
			for (String s : scoreboard) {
				String sCleaned = ScoreboardHandler.cleanSB(s);
				if (sCleaned.contains("Sven Packmaster")) {
					LootCommand.wolfBooks++;
					ConfigHandler.writeIntConfig("wolf", "book", LootCommand.wolfBooks);
				} else if (sCleaned.contains("Tarantula Broodfather")) {
					LootCommand.spiderBooks++;
					ConfigHandler.writeIntConfig("spider", "book", LootCommand.spiderBooks);
				} else if (sCleaned.contains("Revenant Horror")) {
					LootCommand.zombieBooks++;
					ConfigHandler.writeIntConfig("zombie", "book", LootCommand.zombieBooks);
				}
			}
		}

		// Wolf
		if (message.contains("Talk to Maddox to claim your Wolf Slayer XP!")) {
			LootCommand.wolfSvens++;
			LootCommand.wolfSvensSession++;
			if (LootCommand.wolfBosses != -1) {
				LootCommand.wolfBosses++;
			}
			if (LootCommand.wolfBossesSession != -1) {
				LootCommand.wolfBossesSession++;
			}
			ConfigHandler.writeIntConfig("wolf", "svens", LootCommand.wolfSvens);
			ConfigHandler.writeIntConfig("wolf", "bossRNG", LootCommand.wolfBosses);
		} else if (message.contains("RARE DROP! (Hamster Wheel)")) {
			LootCommand.wolfWheelsDrops++;
			LootCommand.wolfWheelsDropsSession++;
			ConfigHandler.writeIntConfig("wolf", "wheelDrops", LootCommand.wolfWheelsDrops);
		} else if (message.contains("VERY RARE DROP!  (") && message.contains(" Spirit Rune I)")) { // Removing the unicode here *should* fix rune drops not counting
			LootCommand.wolfSpirits++;
			LootCommand.wolfSpiritsSession++;
			ConfigHandler.writeIntConfig("wolf", "spirit", LootCommand.wolfSpirits);
		} else if (message.contains("CRAZY RARE DROP!  (Red Claw Egg)")) {
			wolfRNG = true;
			LootCommand.wolfEggs++;
			LootCommand.wolfEggsSession++;
			ConfigHandler.writeIntConfig("wolf", "egg", LootCommand.wolfEggs);
			if (ToggleCommand.rngesusAlerts) Utils.createTitle(EnumChatFormatting.DARK_RED + "RED CLAW EGG!", 3);
		} else if (message.contains("CRAZY RARE DROP!  (") && message.contains(" Couture Rune I)")) {
			wolfRNG = true;
			LootCommand.wolfCoutures++;
			LootCommand.wolfCouturesSession++;
			ConfigHandler.writeIntConfig("wolf", "couture", LootCommand.wolfCoutures);
			if (ToggleCommand.rngesusAlerts) Utils.createTitle(EnumChatFormatting.GOLD + "COUTURE RUNE!", 3);
		} else if (message.contains("CRAZY RARE DROP!  (Grizzly Bait)") || message.contains("CRAZY RARE DROP! (Rename Me)")) { // How did Skyblock devs even manage to make this item Rename Me
			wolfRNG = true;
			LootCommand.wolfBaits++;
			LootCommand.wolfBaitsSession++;
			ConfigHandler.writeIntConfig("wolf", "bait", LootCommand.wolfBaits);
			if (ToggleCommand.rngesusAlerts) Utils.createTitle(EnumChatFormatting.AQUA + "GRIZZLY BAIT!", 3);
		} else if (message.contains("CRAZY RARE DROP!  (Overflux Capacitor)")) {
			wolfRNG = true;
			LootCommand.wolfFluxes++;
			LootCommand.wolfFluxesSession++;
			ConfigHandler.writeIntConfig("wolf", "flux", LootCommand.wolfFluxes);
			if (ToggleCommand.rngesusAlerts) Utils.createTitle(EnumChatFormatting.DARK_PURPLE + "OVERFLUX CAPACITOR!", 5);
		} else if (message.contains("Talk to Maddox to claim your Spider Slayer XP!")) { // Spider
			LootCommand.spiderTarantulas++;
			LootCommand.spiderTarantulasSession++;
			if (LootCommand.spiderBosses != -1) {
				LootCommand.spiderBosses++;
			}
			if (LootCommand.spiderBossesSession != -1) {
				LootCommand.spiderBossesSession++;
			}
			ConfigHandler.writeIntConfig("spider", "tarantulas", LootCommand.spiderTarantulas);
			ConfigHandler.writeIntConfig("spider", "bossRNG", LootCommand.spiderBosses);
		} else if (message.contains("RARE DROP! (Toxic Arrow Poison)")) {
			LootCommand.spiderTAPDrops++;
			LootCommand.spiderTAPDropsSession++;
			ConfigHandler.writeIntConfig("spider", "tapDrops", LootCommand.spiderTAPDrops);
		} else if (message.contains("VERY RARE DROP!  (") && message.contains(" Bite Rune I)")) {
			LootCommand.spiderBites++;
			LootCommand.spiderBitesSession++;
			ConfigHandler.writeIntConfig("spider", "bite", LootCommand.spiderBites);
		} else if (message.contains("VERY RARE DROP!  (Spider Catalyst)")) {
			LootCommand.spiderCatalysts++;
			LootCommand.spiderCatalystsSession++;
			ConfigHandler.writeIntConfig("spider", "catalyst", LootCommand.spiderCatalysts);
		} else if (message.contains("CRAZY RARE DROP!  (Fly Swatter)")) {
			spiderRNG = true;
			LootCommand.spiderSwatters++;
			LootCommand.spiderSwattersSession++;
			ConfigHandler.writeIntConfig("spider", "swatter", LootCommand.spiderSwatters);
			if (ToggleCommand.rngesusAlerts) Utils.createTitle(EnumChatFormatting.LIGHT_PURPLE + "FLY SWATTER!", 3);
		} else if (message.contains("CRAZY RARE DROP!  (Tarantula Talisman")) {
			spiderRNG = true;
			LootCommand.spiderTalismans++;
			LootCommand.spiderTalismansSession++;
			ConfigHandler.writeIntConfig("spider", "talisman", LootCommand.spiderTalismans);
			if (ToggleCommand.rngesusAlerts) Utils.createTitle(EnumChatFormatting.DARK_PURPLE + "TARANTULA TALISMAN!", 3);
		} else if (message.contains("CRAZY RARE DROP!  (Digested Mosquito)")) {
			spiderRNG = true;
			LootCommand.spiderMosquitos++;
			LootCommand.spiderMosquitosSession++;
			ConfigHandler.writeIntConfig("spider", "mosquito", LootCommand.spiderMosquitos);
			if (ToggleCommand.rngesusAlerts) Utils.createTitle(EnumChatFormatting.GOLD + "DIGESTED MOSQUITO!", 5);
		} else if (message.contains("Talk to Maddox to claim your Zombie Slayer XP!")) { // Zombie
			LootCommand.zombieRevs++;
			LootCommand.zombieRevsSession++;
			if (LootCommand.zombieBosses != -1) {
				LootCommand.zombieBosses++;
			}
			if (LootCommand.zombieBossesSession != 1) {
				LootCommand.zombieBossesSession++;
			}
			ConfigHandler.writeIntConfig("zombie", "revs", LootCommand.zombieRevs);
			ConfigHandler.writeIntConfig("zombie", "bossRNG", LootCommand.zombieBosses);
		} else if (message.contains("RARE DROP! (Foul Flesh)")) {
			LootCommand.zombieFoulFleshDrops++;
			LootCommand.zombieFoulFleshDropsSession++;
			ConfigHandler.writeIntConfig("zombie", "foulFleshDrops", LootCommand.zombieFoulFleshDrops);
		} else if (message.contains("VERY RARE DROP!  (Revenant Catalyst)")) {
			LootCommand.zombieRevCatas++;
			LootCommand.zombieRevCatasSession++;
			ConfigHandler.writeIntConfig("zombie", "revCatalyst", LootCommand.zombieRevCatas);
		} else if (message.contains("VERY RARE DROP!  (") && message.contains(" Pestilence Rune I)")) {
			LootCommand.zombiePestilences++;
			LootCommand.zombiePestilencesSession++;
			ConfigHandler.writeIntConfig("zombie", "pestilence", LootCommand.zombiePestilences);
		} else if (message.contains("VERY RARE DROP!  (Undead Catalyst)")) {
			LootCommand.zombieUndeadCatas++;
			LootCommand.zombieUndeadCatasSession++;
			ConfigHandler.writeIntConfig("zombie", "undeadCatalyst", LootCommand.zombieUndeadCatas);
		} else if (message.contains("CRAZY RARE DROP!  (Beheaded Horror)")) {
			zombieRNG = true;
			LootCommand.zombieBeheadeds++;
			LootCommand.zombieBeheadedsSession++;
			ConfigHandler.writeIntConfig("zombie", "beheaded", LootCommand.zombieBeheadeds);
			if (ToggleCommand.rngesusAlerts) Utils.createTitle(EnumChatFormatting.DARK_PURPLE + "BEHEADED HORROR!", 3);
		} else if (message.contains("CRAZY RARE DROP!  (") && message.contains(" Snake Rune I)")) {
			zombieRNG = true;
			LootCommand.zombieSnakes++;
			LootCommand.zombieSnakesSession++;
			ConfigHandler.writeIntConfig("zombie", "snake", LootCommand.zombieSnakes);
			if (ToggleCommand.rngesusAlerts) Utils.createTitle(EnumChatFormatting.DARK_GREEN + "SNAKE RUNE!", 3);
		} else if (message.contains("CRAZY RARE DROP!  (Scythe Blade)")) {
			zombieRNG = true;
			LootCommand.zombieScythes++;
			LootCommand.zombieScythesSession++;
			ConfigHandler.writeIntConfig("zombie", "scythe", LootCommand.zombieScythes);
			if (ToggleCommand.rngesusAlerts) Utils.createTitle(EnumChatFormatting.GOLD + "SCYTHE BLADE!", 5);
		} else if (message.contains("GOOD CATCH!")) { // Fishing
			LootCommand.goodCatches++;
			LootCommand.goodCatchesSession++;
			ConfigHandler.writeIntConfig("fishing", "goodCatch", LootCommand.goodCatches);
		} else if (message.contains("GREAT CATCH!")) {
			LootCommand.greatCatches++;
			LootCommand.greatCatchesSession++;
			ConfigHandler.writeIntConfig("fishing", "greatCatch", LootCommand.greatCatches);
		} else if (message.contains("A Squid appeared")) {
			LootCommand.squids++;
			LootCommand.squidsSession++;
			ConfigHandler.writeIntConfig("fishing", "squid", LootCommand.squids);
			increaseSeaCreatures();
		} else if (message.contains("You caught a Sea Walker")) {
			LootCommand.seaWalkers++;
			LootCommand.seaWalkersSession++;
			ConfigHandler.writeIntConfig("fishing", "seaWalker", LootCommand.seaWalkers);
			increaseSeaCreatures();
		} else if (message.contains("Pitch darkness reveals a Night Squid")) {
			LootCommand.nightSquids++;
			LootCommand.nightSquidsSession++;
			ConfigHandler.writeIntConfig("fishing", "nightSquid", LootCommand.nightSquids);
			increaseSeaCreatures();
		} else if (message.contains("You stumbled upon a Sea Guardian")) {
			LootCommand.seaGuardians++;
			LootCommand.seaGuardiansSession++;
			ConfigHandler.writeIntConfig("fishing", "seaGuardian", LootCommand.seaGuardians);
			increaseSeaCreatures();
		} else if (message.contains("It looks like you've disrupted the Sea Witch's brewing session. Watch out, she's furious")) {
			LootCommand.seaWitches++;
			LootCommand.seaWitchesSession++;
			ConfigHandler.writeIntConfig("fishing", "seaWitch", LootCommand.seaWitches);
			increaseSeaCreatures();
		} else if (message.contains("You reeled in a Sea Archer")) {
			LootCommand.seaArchers++;
			LootCommand.seaArchersSession++;
			ConfigHandler.writeIntConfig("fishing", "seaArcher", LootCommand.seaArchers);
			increaseSeaCreatures();
		} else if (message.contains("The Monster of the Deep has emerged")) {
			LootCommand.monsterOfTheDeeps++;
			LootCommand.monsterOfTheDeepsSession++;
			ConfigHandler.writeIntConfig("fishing", "monsterOfDeep", LootCommand.monsterOfTheDeeps);
			increaseSeaCreatures();
		} else if (message.contains("Huh? A Catfish")) {
			LootCommand.catfishes++;
			LootCommand.catfishesSession++;
			ConfigHandler.writeIntConfig("fishing", "catfish", LootCommand.catfishes);
			increaseSeaCreatures();
		} else if (message.contains("Is this even a fish? It's the Carrot King")) {
			LootCommand.carrotKings++;
			LootCommand.carrotKingsSession++;
			ConfigHandler.writeIntConfig("fishing", "carrotKing", LootCommand.carrotKings);
			increaseSeaCreatures();
		} else if (message.contains("Gross! A Sea Leech")) {
			LootCommand.seaLeeches++;
			LootCommand.seaLeechesSession++;
			ConfigHandler.writeIntConfig("fishing", "seaLeech", LootCommand.seaLeeches);
			increaseSeaCreatures();
		} else if (message.contains("You've discovered a Guardian Defender of the sea")) {
			LootCommand.guardianDefenders++;
			LootCommand.guardianDefendersSession++;
			ConfigHandler.writeIntConfig("fishing", "guardianDefender", LootCommand.guardianDefenders);
			increaseSeaCreatures();
		} else if (message.contains("You have awoken the Deep Sea Protector, prepare for a battle")) {
			LootCommand.deepSeaProtectors++;
			LootCommand.deepSeaProtectorsSession++;
			ConfigHandler.writeIntConfig("fishing", "deepSeaProtector", LootCommand.deepSeaProtectors);
			increaseSeaCreatures();
		} else if (message.contains("The Water Hydra has come to test your strength")) {
			LootCommand.hydras++;
			LootCommand.hydrasSession++;
			ConfigHandler.writeIntConfig("fishing", "hydra", LootCommand.hydras);
			increaseSeaCreatures();
		} else if (message.contains("The Sea Emperor arises from the depths")) {
			increaseSeaCreatures();
			
			LootCommand.seaEmperors++;
			LootCommand.empTime = System.currentTimeMillis() / 1000;
			LootCommand.empSCs = 0;
			LootCommand.seaEmperorsSession++;
			LootCommand.empTimeSession = System.currentTimeMillis() / 1000;
			LootCommand.empSCsSession = 0;
			ConfigHandler.writeIntConfig("fishing", "seaEmperor", LootCommand.seaEmperors);
			ConfigHandler.writeDoubleConfig("fishing", "empTime", LootCommand.empTime);
			ConfigHandler.writeIntConfig("fishing", "empSC", LootCommand.empSCs);
		} else if (message.contains("Frozen Steve fell into the pond long ago")) { // Fishing Winter
			LootCommand.frozenSteves++;
			LootCommand.frozenStevesSession++;
			ConfigHandler.writeIntConfig("fishing", "frozenSteve", LootCommand.frozenSteves);
			increaseSeaCreatures();
		} else if (message.contains("It's a snowman! He looks harmless")) {
			LootCommand.frostyTheSnowmans++;
			LootCommand.frostyTheSnowmansSession++;
			ConfigHandler.writeIntConfig("fishing", "snowman", LootCommand.frostyTheSnowmans);
			increaseSeaCreatures();
		} else if (message.contains("stole Jerry's Gifts...get them back")) {
			LootCommand.grinches++;
			LootCommand.grinchesSession++;
			ConfigHandler.writeIntConfig("fishing", "grinch", LootCommand.grinches);
			increaseSeaCreatures();
		} else if (message.contains("What is this creature")) {
			LootCommand.yetis++;
			LootCommand.yetiTime = System.currentTimeMillis() / 1000;
			LootCommand.yetiSCs = 0;
			LootCommand.yetisSession++;
			LootCommand.yetiTimeSession = System.currentTimeMillis() / 1000;
			LootCommand.yetiSCsSession = 0;
			ConfigHandler.writeIntConfig("fishing", "yeti", LootCommand.yetis);
			ConfigHandler.writeDoubleConfig("fishing", "yetiTime", LootCommand.yetiTime);
			ConfigHandler.writeIntConfig("fishing", "yetiSC", LootCommand.yetiSCs);
			increaseSeaCreatures();
		} else if (message.contains("A tiny fin emerges from the water, you've caught a Nurse Shark")) { // Fishing Festival
			LootCommand.nurseSharks++;
			LootCommand.nurseSharksSession++;
			ConfigHandler.writeIntConfig("fishing", "nurseShark", LootCommand.nurseSharks);
			increaseSeaCreatures();
		} else if (message.contains("You spot a fin as blue as the water it came from, it's a Blue Shark")) {
			LootCommand.blueSharks++;
			LootCommand.blueSharksSession++;
			ConfigHandler.writeIntConfig("fishing", "blueShark", LootCommand.blueSharks);
			increaseSeaCreatures();
		} else if (message.contains("A striped beast bounds from the depths, the wild Tiger Shark")) {
			LootCommand.tigerSharks++;
			LootCommand.tigerSharksSession++;
			ConfigHandler.writeIntConfig("fishing", "tigerShark", LootCommand.tigerSharks);
			increaseSeaCreatures();
		} else if (message.contains("Hide no longer, a Great White Shark has tracked your scent and thirsts for your blood")) {
			LootCommand.greatWhiteSharks++;
			LootCommand.greatWhiteSharksSession++;
			ConfigHandler.writeIntConfig("fishing", "greatWhiteShark", LootCommand.greatWhiteSharks);
			increaseSeaCreatures();
		} else if (message.contains("Phew! It's only a Scarecrow")) {
			LootCommand.scarecrows++;
			LootCommand.scarecrowsSession++;
			ConfigHandler.writeIntConfig("fishing", "scarecrow", LootCommand.scarecrows);
			increaseSeaCreatures();
		} else if (message.contains("You hear trotting from beneath the waves, you caught a Nightmare")) {
			LootCommand.nightmares++;
			LootCommand.nightmaresSession++;
			ConfigHandler.writeIntConfig("fishing", "nightmare", LootCommand.nightmares);
			increaseSeaCreatures();
		} else if (message.contains("It must be a full moon, a Werewolf appears")) {
			LootCommand.werewolfs++;
			LootCommand.werewolfsSession++;
			ConfigHandler.writeIntConfig("fishing", "werewolf", LootCommand.werewolfs);
			increaseSeaCreatures();
		} else if (message.contains("The spirit of a long lost Phantom Fisher has come to haunt you")) {
			LootCommand.phantomFishers++;
			LootCommand.phantomFishersSession++;
			ConfigHandler.writeIntConfig("fishing", "phantomFisher", LootCommand.phantomFishers);
			increaseSeaCreatures();
		} else if (message.contains("This can't be! The manifestation of death himself")) {
			LootCommand.grimReapers++;
			LootCommand.grimReapersSession++;
			ConfigHandler.writeIntConfig("fishing", "grimReaper", LootCommand.grimReapers);
			increaseSeaCreatures();
		} else if (message.contains("Dungeon starts in 1 second.")) { // Dungeons Stuff
		    dungeonStartTime = System.currentTimeMillis() / 1000 + 1;
		    bloodOpenTime = dungeonStartTime;
		    watcherClearTime = dungeonStartTime;
		    bossClearTime = dungeonStartTime;
		    witherDoors = 0;
		    dungeonDeaths = 0;
		    puzzleFails = 0;
		} else if (message.contains("The BLOOD DOOR has been opened!")) {
			bloodOpenTime = System.currentTimeMillis() / 1000;
		} else if (message.contains(" opened a WITHER door!")) {
			witherDoors++;
		} else if (message.contains(" and became a ghost.")) {
			dungeonDeaths++;
		} else if (message.contains(" Defeated ") && message.contains(" in ")) {
			bossClearTime = System.currentTimeMillis() / 1000;
		} else if (message.contains("EXTRA STATS ")) {
			List<String> scoreboard = ScoreboardHandler.getSidebarLines();
			int timeToAdd = 0;
			for (String s : scoreboard) {
				String sCleaned = ScoreboardHandler.cleanSB(s);
				if (sCleaned.contains("The Catacombs (")) {
					// Add time to floor
					if (sCleaned.contains("F1")) {
						LootCommand.f1TimeSpent = Math.floor(LootCommand.f1TimeSpent + timeToAdd);
						LootCommand.f1TimeSpentSession = Math.floor(LootCommand.f1TimeSpentSession + timeToAdd);
						ConfigHandler.writeDoubleConfig("catacombs", "floorOneTime", LootCommand.f1TimeSpent);
					} else if (sCleaned.contains("F2")) {
						LootCommand.f2TimeSpent = Math.floor(LootCommand.f2TimeSpent + timeToAdd);
						LootCommand.f2TimeSpentSession = Math.floor(LootCommand.f2TimeSpentSession + timeToAdd);
						ConfigHandler.writeDoubleConfig("catacombs", "floorTwoTime", LootCommand.f2TimeSpent);
					} else if (sCleaned.contains("F3")) {
						LootCommand.f3TimeSpent = Math.floor(LootCommand.f3TimeSpent + timeToAdd);
						LootCommand.f3TimeSpentSession = Math.floor(LootCommand.f3TimeSpentSession + timeToAdd);
						ConfigHandler.writeDoubleConfig("catacombs", "floorThreeTime", LootCommand.f3TimeSpent);
					} else if (sCleaned.contains("F4")) {
						LootCommand.f4TimeSpent = Math.floor(LootCommand.f4TimeSpent + timeToAdd);
						LootCommand.f4TimeSpentSession = Math.floor(LootCommand.f4TimeSpentSession + timeToAdd);
						ConfigHandler.writeDoubleConfig("catacombs", "floorFourTime", LootCommand.f4TimeSpent);
					} else if (sCleaned.contains("F5")) {
						LootCommand.f5TimeSpent = Math.floor(LootCommand.f5TimeSpent + timeToAdd);
						LootCommand.f5TimeSpentSession = Math.floor(LootCommand.f5TimeSpentSession + timeToAdd);
						ConfigHandler.writeDoubleConfig("catacombs", "floorFiveTime", LootCommand.f5TimeSpent);
					} else if (sCleaned.contains("F6")) {
						LootCommand.f6TimeSpent = Math.floor(LootCommand.f6TimeSpent + timeToAdd);
						LootCommand.f6TimeSpentSession = Math.floor(LootCommand.f6TimeSpentSession + timeToAdd);
						ConfigHandler.writeDoubleConfig("catacombs", "floorSixTime", LootCommand.f6TimeSpent);
					} else if (sCleaned.contains("F7")) {
						LootCommand.f7TimeSpent = Math.floor(LootCommand.f7TimeSpent + timeToAdd);
						LootCommand.f7TimeSpentSession = Math.floor(LootCommand.f7TimeSpentSession + timeToAdd);
						ConfigHandler.writeDoubleConfig("catacombs", "floorSevenTime", LootCommand.f7TimeSpent);
					}
				} else if (sCleaned.contains("Time Elapsed:")) {
					// Get floor time
					String time = sCleaned.substring(sCleaned.indexOf(":") + 2);
					time = time.replaceAll("\\s", "");
					int minutes = Integer.parseInt(time.substring(0, time.indexOf("m")));
					int seconds = Integer.parseInt(time.substring(time.indexOf("m") + 1, time.indexOf("s")));
					timeToAdd = (minutes * 60) + seconds;
				}
			}
		}
		
		if (wolfRNG) {
			LootCommand.wolfTime = System.currentTimeMillis() / 1000;
			LootCommand.wolfBosses = 0;
			LootCommand.wolfTimeSession = System.currentTimeMillis() / 1000;
			LootCommand.wolfBossesSession = 0;
			ConfigHandler.writeDoubleConfig("wolf", "timeRNG", LootCommand.wolfTime);
			ConfigHandler.writeIntConfig("wolf", "bossRNG", 0);
		}
		if (spiderRNG) {
			LootCommand.spiderTime = System.currentTimeMillis() / 1000;
			LootCommand.spiderBosses = 0;
			LootCommand.spiderTimeSession = System.currentTimeMillis() / 1000;
			LootCommand.spiderBossesSession = 0;
			ConfigHandler.writeDoubleConfig("spider", "timeRNG", LootCommand.spiderTime);
			ConfigHandler.writeIntConfig("spider", "bossRNG", 0);
		}
		if (zombieRNG) {
			LootCommand.zombieTime = System.currentTimeMillis() / 1000;
			LootCommand.zombieBosses = 0;
			LootCommand.zombieTimeSession = System.currentTimeMillis() / 1000;
			LootCommand.zombieBossesSession = 0;
			ConfigHandler.writeDoubleConfig("zombie", "timeRNG", LootCommand.zombieTime);
			ConfigHandler.writeIntConfig("zombie", "bossRNG", 0);
		}
		
		// Dungeons Trackers
		if (message.contains("    ")) {
			if (message.contains("Recombobulator 3000")) {
				LootCommand.recombobulators++;
				LootCommand.recombobulatorsSession++;
				ConfigHandler.writeIntConfig("catacombs", "recombobulator", LootCommand.recombobulators);
			} else if (message.contains("Fuming Potato Book")) {
				LootCommand.fumingPotatoBooks++;
				LootCommand.fumingPotatoBooksSession++;
				ConfigHandler.writeIntConfig("catacombs", "fumingBooks", LootCommand.fumingPotatoBooks);
			} else if (message.contains("Bonzo's Staff")) { // F1
				LootCommand.bonzoStaffs++;
				LootCommand.bonzoStaffsSession++;
				ConfigHandler.writeIntConfig("catacombs", "bonzoStaff", LootCommand.bonzoStaffs);
			} else if (message.contains("Scarf's Studies")) { // F2
				LootCommand.scarfStudies++;
				LootCommand.scarfStudiesSession++;
				ConfigHandler.writeIntConfig("catacombs", "scarfStudies", LootCommand.scarfStudies);
			} else if (message.contains("Adaptive Helmet")) { // F3
				LootCommand.adaptiveHelms++;
				LootCommand.adaptiveHelmsSession++;
				ConfigHandler.writeIntConfig("catacombs", "adaptiveHelm", LootCommand.adaptiveHelms);
			} else if (message.contains("Adaptive Chestplate")) {
				LootCommand.adaptiveChests++;
				LootCommand.adaptiveChestsSession++;
				ConfigHandler.writeIntConfig("catacombs", "adaptiveChest", LootCommand.adaptiveChests);
			} else if (message.contains("Adaptive Leggings")) {
				LootCommand.adaptiveLegs++;
				LootCommand.adaptiveLegsSession++;
				ConfigHandler.writeIntConfig("catacombs", "adaptiveLegging", LootCommand.adaptiveLegs);
			} else if (message.contains("Adaptive Boots")) {
				LootCommand.adaptiveBoots++;
				LootCommand.adaptiveBootsSession++;
				ConfigHandler.writeIntConfig("catacombs", "adaptiveBoot", LootCommand.adaptiveBoots);
			} else if (message.contains("Adaptive Blade")) {
				LootCommand.adaptiveSwords++;
				LootCommand.adaptiveSwordsSession++;
				ConfigHandler.writeIntConfig("catacombs", "adaptiveSword", LootCommand.adaptiveSwords);
			} else if (message.contains("Spirit Wing")) { // F4
				LootCommand.spiritWings++;
				LootCommand.spiritWingsSession++;
				ConfigHandler.writeIntConfig("catacombs", "spiritWing", LootCommand.spiritWings);
			} else if (message.contains("Spirit Bone")) {
				LootCommand.spiritBones++;
				LootCommand.spiritBonesSession++;
				ConfigHandler.writeIntConfig("catacombs", "spiritBone", LootCommand.spiritBones);
			} else if (message.contains("Spirit Boots")) {
				LootCommand.spiritBoots++;
				LootCommand.spiritBootsSession++;
				ConfigHandler.writeIntConfig("catacombs", "spiritBoot", LootCommand.spiritBoots);
			} else if (message.contains("[Lvl 1] Spirit")) {
				String formattedMessage = event.message.getFormattedText();
				// Unicode colour code messes up here, just gonna remove the symbols
				if (formattedMessage.contains("5Spirit")) {
					LootCommand.epicSpiritPets++;
					LootCommand.epicSpiritPetsSession++;
					ConfigHandler.writeIntConfig("catacombs", "spiritPetEpic", LootCommand.epicSpiritPets);
				} else if (formattedMessage.contains("6Spirit")) {
					LootCommand.legSpiritPets++;
					LootCommand.legSpiritPetsSession++;
					ConfigHandler.writeIntConfig("catacombs", "spiritPetLeg", LootCommand.legSpiritPets);
				} 
			} else if (message.contains("Spirit Sword")) {
				LootCommand.spiritSwords++;
				LootCommand.spiritSwordsSession++;
				ConfigHandler.writeIntConfig("catacombs", "spiritSword", LootCommand.spiritSwords);
			} else if (message.contains("Spirit Bow")) {
				LootCommand.spiritBows++;
				LootCommand.spiritBowsSession++;
				ConfigHandler.writeIntConfig("catacombs", "spiritBow", LootCommand.spiritBows);
			} else if (message.contains("Warped Stone")) { // F5
				LootCommand.warpedStones++;
				LootCommand.warpedStonesSession++;
				ConfigHandler.writeIntConfig("catacombs", "warpedStone", LootCommand.warpedStones);
			} else if (message.contains("Shadow Assassin Helmet")) {
				LootCommand.shadowAssHelms++;
				LootCommand.shadowAssHelmsSession++;
				ConfigHandler.writeIntConfig("catacombs", "shadowAssassinHelm", LootCommand.shadowAssHelms);
			} else if (message.contains("Shadow Assassin Chestplate")) {
				LootCommand.shadowAssChests++;
				LootCommand.shadowAssChestsSession++;
				ConfigHandler.writeIntConfig("catacombs", "shadowAssassinChest", LootCommand.shadowAssChests);
			} else if (message.contains("Shadow Assassin Leggings")) {
				LootCommand.shadowAssLegs++;
				LootCommand.shadowAssLegsSession++;
				ConfigHandler.writeIntConfig("catacombs", "shadowAssassinLegging", LootCommand.shadowAssLegs);
			} else if (message.contains("Shadow Assassin Boots")) {
				LootCommand.shadowAssBoots++;
				LootCommand.shadowAssBootsSession++;
				ConfigHandler.writeIntConfig("catacombs", "shadowAssassinBoot", LootCommand.shadowAssBoots);
			} else if (message.contains("Livid Dagger")) {
				LootCommand.lividDaggers++;
				LootCommand.lividDaggersSession++;
				ConfigHandler.writeIntConfig("catacombs", "lividDagger", LootCommand.lividDaggers);
			} else if (message.contains("Shadow Fury")) {
				LootCommand.shadowFurys++;
				LootCommand.shadowFurysSession++;
				ConfigHandler.writeIntConfig("catacombs", "shadowFury", LootCommand.shadowFurys);
			} else if (message.contains("Ancient Rose")) { // F6
				LootCommand.ancientRoses++;
				LootCommand.ancientRosesSession++;
				ConfigHandler.writeIntConfig("catacombs", "ancientRose", LootCommand.ancientRoses);
			} else if (message.contains("Precursor Eye")) {
				LootCommand.precursorEyes++;
				LootCommand.precursorEyesSession++;
				ConfigHandler.writeIntConfig("catacombs", "precursorEye", LootCommand.precursorEyes);
			} else if (message.contains("Giant's Sword")) {
				LootCommand.giantsSwords++;
				LootCommand.giantsSwordsSession++;
				ConfigHandler.writeIntConfig("catacombs", "giantsSword", LootCommand.giantsSwords);
			} else if (message.contains("Necromancer Lord Helmet")) {
				LootCommand.necroLordHelms++;
				LootCommand.necroLordHelmsSession++;
				ConfigHandler.writeIntConfig("catacombs", "necroLordHelm", LootCommand.necroLordHelms);
			} else if (message.contains("Necromancer Lord Chestplate")) {
				LootCommand.necroLordChests++;
				LootCommand.necroLordChestsSession++;
				ConfigHandler.writeIntConfig("catacombs", "necroLordChest", LootCommand.necroLordChests);
			} else if (message.contains("Necromancer Lord Leggings")) {
				LootCommand.necroLordLegs++;
				LootCommand.necroLordLegsSession++;
				ConfigHandler.writeIntConfig("catacombs", "necroLordLegging", LootCommand.necroLordLegs);
			} else if (message.contains("Necromancer Lord Boots")) {
				LootCommand.necroLordBoots++;
				LootCommand.necroLordBootsSession++;
				ConfigHandler.writeIntConfig("catacombs", "necroLordBoot", LootCommand.necroLordBoots);
			} else if (message.contains("Necromancer Sword")) {
				LootCommand.necroSwords++;
				LootCommand.necroSwordsSession++;
				ConfigHandler.writeIntConfig("catacombs", "necroSword", LootCommand.necroSwords);
			} else if (message.contains("Wither Blood")) { // F7
				LootCommand.witherBloods++;
				LootCommand.witherBloodsSession++;
			} else if (message.contains("Wither Cloak")) {
				LootCommand.witherCloaks++;
				LootCommand.witherCloaksSession++;
			} else if (message.contains("Implosion")) {
				LootCommand.implosions++;
				LootCommand.implosionsSession++;
			} else if (message.contains("Wither Shield")) {
				LootCommand.witherShields++;
				LootCommand.witherShieldsSession++;
			} else if (message.contains("Shadow Warp")) {
				LootCommand.shadowWarps++;
				LootCommand.shadowWarpsSession++;
			} else if (message.contains("Auto Recombobulator")) {
				LootCommand.autoRecombs++;
				LootCommand.autoRecombsSession++;
			} else if (message.contains("Wither Helmet")) {
				LootCommand.witherHelms++;
				LootCommand.witherHelmsSession++;
			} else if (message.contains("Wither Chestplate")) {
				LootCommand.witherChests++;
				LootCommand.witherChestsSession++;
			} else if (message.contains("Wither Leggings")) {
				LootCommand.witherLegs++;
				LootCommand.witherLegsSession++;
			} else if (message.contains("Wither Boots")) {
				LootCommand.witherBoots++;
				LootCommand.witherBootsSession++;
			}
		}
		
		// Chat Maddox
		if (message.contains("[OPEN MENU]")) {
			List<IChatComponent> listOfSiblings = event.message.getSiblings();
			for (IChatComponent sibling : listOfSiblings) {
				if (sibling.getUnformattedText().contains("[OPEN MENU]")) {
					lastMaddoxCommand = sibling.getChatStyle().getChatClickEvent().getValue();
					lastMaddoxTime = System.currentTimeMillis() / 1000;
				}
			}
			if (ToggleCommand.chatMaddoxToggled) Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(MAIN_COLOUR + "Open chat then click anywhere on-screen to open Maddox"));
		}
		
		// Spirit Bear alerts
		if (ToggleCommand.spiritBearAlerts && message.contains("The Spirit Bear has appeared!")) {
			Utils.createTitle(EnumChatFormatting.DARK_PURPLE + "SPIRIT BEAR", 2);
		}
    }
    
    @SubscribeEvent
    public void renderPlayerInfo(final RenderGameOverlayEvent.Post event) {
    	if (usingLabymod) return;
    	if (event.type != RenderGameOverlayEvent.ElementType.EXPERIENCE && event.type != RenderGameOverlayEvent.ElementType.JUMPBAR) return;
    	renderEverything();
    }
    
    // LabyMod Support
    @SubscribeEvent
    public void renderPlayerInfoLabyMod(final RenderGameOverlayEvent event) {
    	if (!usingLabymod) return;
    	if (event.type != null) return;
    	renderEverything();
    }
    
    public void renderEverything() {
    	if (Minecraft.getMinecraft().currentScreen instanceof EditLocationsGui) return;
    	
    	Minecraft mc = Minecraft.getMinecraft();
    	
    	if (ToggleCommand.coordsToggled) {
    		EntityPlayer player = mc.thePlayer;
    		
        	double xDir = (player.rotationYaw % 360 + 360) % 360;
        	if (xDir > 180) xDir -= 360;
        	xDir = (double) Math.round(xDir * 10d) / 10d;
        	double yDir = (double) Math.round(player.rotationPitch * 10d) / 10d;
        	
        	String coordText = COORDS_COLOUR + (int) player.posX + " / " + (int) player.posY + " / " + (int) player.posZ + " (" + xDir + " / " + yDir + ")";
        	new TextRenderer(mc, coordText, MoveCommand.coordsXY[0], MoveCommand.coordsXY[1], ScaleCommand.coordsScale);
    	}
    	
    	if (ToggleCommand.dungeonTimerToggled && Utils.inDungeons) {
    		String dungeonTimerText = EnumChatFormatting.GRAY + "Wither Doors:\n" +
    								  EnumChatFormatting.DARK_RED + "Blood Open:\n" +
    								  EnumChatFormatting.RED + "Watcher Clear:\n" +
    								  EnumChatFormatting.BLUE + "Boss Clear:\n" +
    								  EnumChatFormatting.YELLOW + "Deaths:\n" +
    								  EnumChatFormatting.YELLOW + "Puzzle Fails:";
    		String dungeonTimers = EnumChatFormatting.GRAY + "" + witherDoors + "\n" +
								   EnumChatFormatting.DARK_RED + Utils.getTimeBetween(dungeonStartTime, bloodOpenTime) + "\n" +
								   EnumChatFormatting.RED + Utils.getTimeBetween(dungeonStartTime, watcherClearTime) + "\n" +
								   EnumChatFormatting.BLUE + Utils.getTimeBetween(dungeonStartTime, bossClearTime) + "\n" +
								   EnumChatFormatting.YELLOW + dungeonDeaths + "\n" +
								   EnumChatFormatting.YELLOW + puzzleFails;
    		new TextRenderer(mc, dungeonTimerText, MoveCommand.dungeonTimerXY[0], MoveCommand.dungeonTimerXY[1], ScaleCommand.dungeonTimerScale);
    		new TextRenderer(mc, dungeonTimers, (int) (MoveCommand.dungeonTimerXY[0] + (80 * ScaleCommand.dungeonTimerScale)), MoveCommand.dungeonTimerXY[1], ScaleCommand.dungeonTimerScale);
    	}
    	
    	if (ToggleCommand.lividSolverToggled && foundLivid && livid != null) {
    		new TextRenderer(mc, livid.getName().replace("" + EnumChatFormatting.BOLD, ""), MoveCommand.lividHpXY[0], MoveCommand.lividHpXY[1], ScaleCommand.lividHpScale);
    	}
    	
    	if (ToggleCommand.cakeTimerToggled && Utils.inSkyblock) {
    		double scale = ScaleCommand.cakeTimerScale;
    		double scaleReset = (double) Math.pow(scale, -1);
    		GL11.glScaled(scale, scale, scale);
    		
    		double timeNow = System.currentTimeMillis() / 1000;
    		mc.getTextureManager().bindTexture(CAKE_ICON);
    		Gui.drawModalRectWithCustomSizedTexture(MoveCommand.cakeTimerXY[0], MoveCommand.cakeTimerXY[1], 0, 0, 16, 16, 16, 16);
    		
    		String cakeText;
    		if (cakeTime - timeNow < 0) {
    			cakeText = EnumChatFormatting.RED + "NONE";
    		} else {
    			cakeText = CAKE_COLOUR + Utils.getTimeBetween(timeNow, cakeTime);
    		}
    		new TextRenderer(mc, cakeText, MoveCommand.cakeTimerXY[0] + 20, MoveCommand.cakeTimerXY[1] + 5, 1);
    		
    		GL11.glScaled(scaleReset, scaleReset, scaleReset);
    	}
    	
    	if (!DisplayCommand.display.equals("off")) {
    		String dropsText = "";
    		String countText = "";
    		String timeBetween = "Never";
    		String bossesBetween = "Never";
    		String drop20;
    		double timeNow = System.currentTimeMillis() / 1000;
    		NumberFormat nf = NumberFormat.getIntegerInstance(Locale.US);
    		
    		if (DisplayCommand.display.equals("wolf")) {
    			if (LootCommand.wolfTime == -1) {
    				timeBetween = "Never";
    			} else {
    				timeBetween = Utils.getTimeBetween(LootCommand.wolfTime, timeNow);
    			}
    			if (LootCommand.wolfBosses == -1) {
    				bossesBetween = "Never";
    			} else {
    				bossesBetween = nf.format(LootCommand.wolfBosses);
    			}
    			if (ToggleCommand.slayerCountTotal) {
    				drop20 = nf.format(LootCommand.wolfWheels);
    			} else {
    				drop20 = nf.format(LootCommand.wolfWheelsDrops) + " times";
    			}
    			
    			dropsText = EnumChatFormatting.GOLD + "Svens Killed:\n" +
							EnumChatFormatting.GREEN + "Wolf Teeth:\n" +
							EnumChatFormatting.BLUE + "Hamster Wheels:\n" +
							EnumChatFormatting.AQUA + "Spirit Runes:\n" + 
							EnumChatFormatting.WHITE + "Critical VI Books:\n" +
							EnumChatFormatting.DARK_RED + "Red Claw Eggs:\n" +
							EnumChatFormatting.GOLD + "Couture Runes:\n" +
							EnumChatFormatting.AQUA + "Grizzly Baits:\n" +
							EnumChatFormatting.DARK_PURPLE + "Overfluxes:\n" +
							EnumChatFormatting.AQUA + "Time Since RNG:\n" +
							EnumChatFormatting.AQUA + "Bosses Since RNG:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.wolfSvens) + "\n" +
							EnumChatFormatting.GREEN + nf.format(LootCommand.wolfTeeth) + "\n" +
							EnumChatFormatting.BLUE + drop20 + "\n" +
							EnumChatFormatting.AQUA + LootCommand.wolfSpirits + "\n" + 
							EnumChatFormatting.WHITE + LootCommand.wolfBooks + "\n" +
							EnumChatFormatting.DARK_RED + LootCommand.wolfEggs + "\n" +
							EnumChatFormatting.GOLD + LootCommand.wolfCoutures + "\n" +
							EnumChatFormatting.AQUA + LootCommand.wolfBaits + "\n" +
							EnumChatFormatting.DARK_PURPLE + LootCommand.wolfFluxes + "\n" +
							EnumChatFormatting.AQUA + timeBetween + "\n" +
							EnumChatFormatting.AQUA + bossesBetween;
    		} else if (DisplayCommand.display.equals("wolf_session")) {
    			if (LootCommand.wolfTimeSession == -1) {
    				timeBetween = "Never";
    			} else {
    				timeBetween = Utils.getTimeBetween(LootCommand.wolfTimeSession, timeNow);
    			}
    			if (LootCommand.wolfBossesSession == -1) {
    				bossesBetween = "Never";
    			} else {
    				bossesBetween = nf.format(LootCommand.wolfBossesSession);
    			}
    			if (ToggleCommand.slayerCountTotal) {
    				drop20 = nf.format(LootCommand.wolfWheelsSession);
    			} else {
    				drop20 = nf.format(LootCommand.wolfWheelsDropsSession) + " times";
    			}
    			
    			dropsText = EnumChatFormatting.GOLD + "Svens Killed:\n" +
							EnumChatFormatting.GREEN + "Wolf Teeth:\n" +
							EnumChatFormatting.BLUE + "Hamster Wheels:\n" +
							EnumChatFormatting.AQUA + "Spirit Runes:\n" + 
							EnumChatFormatting.WHITE + "Critical VI Books:\n" +
							EnumChatFormatting.DARK_RED + "Red Claw Eggs:\n" +
							EnumChatFormatting.GOLD + "Couture Runes:\n" +
							EnumChatFormatting.AQUA + "Grizzly Baits:\n" +
							EnumChatFormatting.DARK_PURPLE + "Overfluxes:\n" +
							EnumChatFormatting.AQUA + "Time Since RNG:\n" +
							EnumChatFormatting.AQUA + "Bosses Since RNG:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.wolfSvensSession) + "\n" +
							EnumChatFormatting.GREEN + nf.format(LootCommand.wolfTeethSession) + "\n" +
							EnumChatFormatting.BLUE + drop20 + "\n" +
							EnumChatFormatting.AQUA + LootCommand.wolfSpiritsSession + "\n" + 
							EnumChatFormatting.WHITE + LootCommand.wolfBooksSession + "\n" +
							EnumChatFormatting.DARK_RED + LootCommand.wolfEggsSession + "\n" +
							EnumChatFormatting.GOLD + LootCommand.wolfCouturesSession + "\n" +
							EnumChatFormatting.AQUA + LootCommand.wolfBaitsSession + "\n" +
							EnumChatFormatting.DARK_PURPLE + LootCommand.wolfFluxesSession + "\n" +
							EnumChatFormatting.AQUA + timeBetween + "\n" +
						EnumChatFormatting.AQUA + bossesBetween;
    		} else if (DisplayCommand.display.equals("spider")) {
    			if (LootCommand.spiderTime == -1) {
    				timeBetween = "Never";
    			} else {
    				timeBetween = Utils.getTimeBetween(LootCommand.spiderTime, timeNow);
    			}
    			if (LootCommand.spiderBosses == -1) {
    				bossesBetween = "Never";
    			} else {
    				bossesBetween = nf.format(LootCommand.spiderBosses);
    			}
    			if (ToggleCommand.slayerCountTotal) {
    				drop20 = nf.format(LootCommand.spiderTAP);
    			} else {
    				drop20 = nf.format(LootCommand.spiderTAPDrops) + " times";
    			}
    			
    			dropsText = EnumChatFormatting.GOLD + "Tarantulas Killed:\n" +
							EnumChatFormatting.GREEN + "Tarantula Webs:\n" +
							EnumChatFormatting.DARK_GREEN + "Arrow Poison:\n" +
							EnumChatFormatting.DARK_GRAY + "Bite Runes:\n" + 
							EnumChatFormatting.WHITE + "Bane VI Books:\n" +
							EnumChatFormatting.AQUA + "Spider Catalysts:\n" +
							EnumChatFormatting.DARK_PURPLE + "Tarantula Talismans:\n" +
							EnumChatFormatting.LIGHT_PURPLE + "Fly Swatters:\n" +
							EnumChatFormatting.GOLD + "Digested Mosquitos:\n" +
							EnumChatFormatting.AQUA + "Time Since RNG:\n" +
							EnumChatFormatting.AQUA + "Bosses Since RNG:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.spiderTarantulas) + "\n" +
							EnumChatFormatting.GREEN + nf.format(LootCommand.spiderWebs) + "\n" +
							EnumChatFormatting.DARK_GREEN + drop20 + "\n" +
							EnumChatFormatting.DARK_GRAY + LootCommand.spiderBites + "\n" + 
							EnumChatFormatting.WHITE + LootCommand.spiderBooks + "\n" +
							EnumChatFormatting.AQUA + LootCommand.spiderCatalysts + "\n" +
							EnumChatFormatting.DARK_PURPLE + LootCommand.spiderTalismans + "\n" +
							EnumChatFormatting.LIGHT_PURPLE + LootCommand.spiderSwatters + "\n" +
							EnumChatFormatting.GOLD + LootCommand.spiderMosquitos + "\n" +
							EnumChatFormatting.AQUA + timeBetween + "\n" +
							EnumChatFormatting.AQUA + bossesBetween;
    		} else if (DisplayCommand.display.equals("spider_session")) {
    			if (LootCommand.spiderTimeSession == -1) {
    				timeBetween = "Never";
    			} else {
    				timeBetween = Utils.getTimeBetween(LootCommand.spiderTimeSession, timeNow);
    			}
    			if (LootCommand.spiderBossesSession == -1) {
    				bossesBetween = "Never";
    			} else {
    				bossesBetween = nf.format(LootCommand.spiderBossesSession);
    			}
    			if (ToggleCommand.slayerCountTotal) {
    				drop20 = nf.format(LootCommand.spiderTAPSession);
    			} else {
    				drop20 = nf.format(LootCommand.spiderTAPDropsSession) + " times";
    			}
    			
    			dropsText = EnumChatFormatting.GOLD + "Tarantulas Killed:\n" +
							EnumChatFormatting.GREEN + "Tarantula Webs:\n" +
							EnumChatFormatting.DARK_GREEN + "Arrow Poison:\n" +
							EnumChatFormatting.DARK_GRAY + "Bite Runes:\n" + 
							EnumChatFormatting.WHITE + "Bane VI Books:\n" +
							EnumChatFormatting.AQUA + "Spider Catalysts:\n" +
							EnumChatFormatting.DARK_PURPLE + "Tarantula Talismans:\n" +
							EnumChatFormatting.LIGHT_PURPLE + "Fly Swatters:\n" +
							EnumChatFormatting.GOLD + "Digested Mosquitos:\n" +
							EnumChatFormatting.AQUA + "Time Since RNG:\n" +
							EnumChatFormatting.AQUA + "Bosses Since RNG:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.spiderTarantulasSession) + "\n" +
							EnumChatFormatting.GREEN + nf.format(LootCommand.spiderWebsSession) + "\n" +
							EnumChatFormatting.DARK_GREEN + drop20 + "\n" +
							EnumChatFormatting.DARK_GRAY + LootCommand.spiderBitesSession + "\n" + 
							EnumChatFormatting.WHITE + LootCommand.spiderBooksSession + "\n" +
							EnumChatFormatting.AQUA + LootCommand.spiderCatalystsSession + "\n" +
							EnumChatFormatting.DARK_PURPLE + LootCommand.spiderTalismansSession + "\n" +
							EnumChatFormatting.LIGHT_PURPLE + LootCommand.spiderSwattersSession + "\n" +
							EnumChatFormatting.GOLD + LootCommand.spiderMosquitosSession + "\n" +
							EnumChatFormatting.AQUA + timeBetween + "\n" +
							EnumChatFormatting.AQUA + bossesBetween;
    		} else if (DisplayCommand.display.equals("zombie")) {
    			if (LootCommand.zombieTime == -1) {
    				timeBetween = "Never";
    			} else {
    				timeBetween = Utils.getTimeBetween(LootCommand.zombieTime, timeNow);
    			}
    			if (LootCommand.zombieBosses == -1) {
    				bossesBetween = "Never";
    			} else {
    				bossesBetween = nf.format(LootCommand.zombieBosses);
    			}
    			if (ToggleCommand.slayerCountTotal) {
    				drop20 = nf.format(LootCommand.zombieFoulFlesh);
    			} else {
    				drop20 = nf.format(LootCommand.zombieFoulFleshDrops) + " times";
    			}
    			
    			dropsText = EnumChatFormatting.GOLD + "Revs Killed:\n" +
							EnumChatFormatting.GREEN + "Revenant Flesh:\n" +
							EnumChatFormatting.BLUE + "Foul Flesh:\n" +
							EnumChatFormatting.DARK_GREEN + "Pestilence Runes:\n" + 
							EnumChatFormatting.WHITE + "Smite VI Books:\n" +
							EnumChatFormatting.AQUA + "Undead Catalysts:\n" +
							EnumChatFormatting.DARK_PURPLE + "Beheaded Horrors:\n" +
							EnumChatFormatting.RED + "Revenant Catalysts:\n" +
							EnumChatFormatting.DARK_GREEN + "Snake Runes:\n" +
							EnumChatFormatting.GOLD + "Scythe Blades:\n" +
							EnumChatFormatting.AQUA + "Time Since RNG:\n" +
							EnumChatFormatting.AQUA + "Bosses Since RNG:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.zombieRevs) + "\n" +
							EnumChatFormatting.GREEN + nf.format(LootCommand.zombieRevFlesh) + "\n" +
							EnumChatFormatting.BLUE + drop20 + "\n" +
							EnumChatFormatting.DARK_GREEN + LootCommand.zombiePestilences + "\n" + 
							EnumChatFormatting.WHITE + LootCommand.zombieBooks + "\n" +
							EnumChatFormatting.AQUA + LootCommand.zombieUndeadCatas + "\n" +
							EnumChatFormatting.DARK_PURPLE + LootCommand.zombieBeheadeds + "\n" +
							EnumChatFormatting.RED + LootCommand.zombieRevCatas + "\n" +
							EnumChatFormatting.DARK_GREEN + LootCommand.zombieSnakes + "\n" +
							EnumChatFormatting.GOLD + LootCommand.zombieScythes + "\n" +
							EnumChatFormatting.AQUA + timeBetween + "\n" +
							EnumChatFormatting.AQUA + bossesBetween;
    		} else if (DisplayCommand.display.equals("zombie_session")) {
    			if (LootCommand.zombieTimeSession == -1) {
    				timeBetween = "Never";
    			} else {
    				timeBetween = Utils.getTimeBetween(LootCommand.zombieTimeSession, timeNow);
    			}
    			if (LootCommand.zombieBossesSession == -1) {
    				bossesBetween = "Never";
    			} else {
    				bossesBetween = nf.format(LootCommand.zombieBossesSession);
    			}
    			if (ToggleCommand.slayerCountTotal) {
    				drop20 = nf.format(LootCommand.zombieFoulFleshSession);
    			} else {
    				drop20 = nf.format(LootCommand.zombieFoulFleshDropsSession) + " times";
    			}
    			
    			dropsText = EnumChatFormatting.GOLD + "Revs Killed:\n" +
							EnumChatFormatting.GREEN + "Revenant Flesh:\n" +
							EnumChatFormatting.BLUE + "Foul Flesh:\n" +
							EnumChatFormatting.DARK_GREEN + "Pestilence Runes:\n" + 
							EnumChatFormatting.WHITE + "Smite VI Books:\n" +
							EnumChatFormatting.AQUA + "Undead Catalysts:\n" +
							EnumChatFormatting.DARK_PURPLE + "Beheaded Horrors:\n" +
							EnumChatFormatting.RED + "Revenant Catalysts:\n" +
							EnumChatFormatting.DARK_GREEN + "Snake Runes:\n" +
							EnumChatFormatting.GOLD + "Scythe Blades:\n" +
							EnumChatFormatting.AQUA + "Time Since RNG:\n" +
							EnumChatFormatting.AQUA + "Bosses Since RNG:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.zombieRevsSession) + "\n" +
							EnumChatFormatting.GREEN + nf.format(LootCommand.zombieRevFleshSession) + "\n" +
							EnumChatFormatting.BLUE + drop20 + "\n" +
							EnumChatFormatting.DARK_GREEN + LootCommand.zombiePestilencesSession + "\n" + 
							EnumChatFormatting.WHITE + LootCommand.zombieBooksSession + "\n" +
							EnumChatFormatting.AQUA + LootCommand.zombieUndeadCatasSession + "\n" +
							EnumChatFormatting.DARK_PURPLE + LootCommand.zombieBeheadedsSession + "\n" +
							EnumChatFormatting.RED + LootCommand.zombieRevCatasSession + "\n" +
							EnumChatFormatting.DARK_GREEN + LootCommand.zombieSnakesSession + "\n" +
							EnumChatFormatting.GOLD + LootCommand.zombieScythes + "\n" +
							EnumChatFormatting.AQUA + timeBetween + "\n" +
							EnumChatFormatting.AQUA + bossesBetween;
    		} else if (DisplayCommand.display.equals("fishing")) {
    			if (LootCommand.empTime == -1) {
    				timeBetween = "Never";
    			} else {
    				timeBetween = Utils.getTimeBetween(LootCommand.empTime, timeNow);
    			}
    			if (LootCommand.empSCs == -1) {
    				bossesBetween = "Never";
    			} else {
    				bossesBetween = nf.format(LootCommand.empSCs);
    			}
    			
    			dropsText = EnumChatFormatting.AQUA + "Creatures Caught:\n" +
    						EnumChatFormatting.AQUA + "Fishing Milestone:\n" +
	    					EnumChatFormatting.GOLD + "Good Catches:\n" +
							EnumChatFormatting.DARK_PURPLE + "Great Catches:\n" +
							EnumChatFormatting.GRAY + "Squids:\n" +
							EnumChatFormatting.GREEN + "Sea Walkers:\n" +
							EnumChatFormatting.DARK_GRAY + "Night Squids:\n" +
							EnumChatFormatting.DARK_AQUA + "Sea Guardians:\n" +
							EnumChatFormatting.BLUE + "Sea Witches:\n" +
							EnumChatFormatting.GREEN + "Sea Archers:";
    			countText = EnumChatFormatting.AQUA + nf.format(LootCommand.seaCreatures) + "\n" +
							EnumChatFormatting.AQUA + nf.format(LootCommand.fishingMilestone) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.goodCatches) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.greatCatches) + "\n" +
							EnumChatFormatting.GRAY + nf.format(LootCommand.squids) + "\n" +
							EnumChatFormatting.GREEN + nf.format(LootCommand.seaWalkers) + "\n" +
							EnumChatFormatting.DARK_GRAY + nf.format(LootCommand.nightSquids) + "\n" +
							EnumChatFormatting.DARK_AQUA + nf.format(LootCommand.seaGuardians) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.seaWitches) + "\n" +
							EnumChatFormatting.GREEN + nf.format(LootCommand.seaArchers);
    			// Seperated to save vertical space
    			String dropsTextTwo = EnumChatFormatting.GREEN + "Monster of Deeps:\n" +
    								  EnumChatFormatting.YELLOW + "Catfishes:\n" +
									  EnumChatFormatting.GOLD + "Carrot Kings:\n" +
									  EnumChatFormatting.GRAY + "Sea Leeches:\n" +
									  EnumChatFormatting.DARK_PURPLE + "Guardian Defenders:\n" +
									  EnumChatFormatting.DARK_PURPLE + "Deep Sea Protectors:\n" +
									  EnumChatFormatting.GOLD + "Hydras:\n" +
									  EnumChatFormatting.GOLD + "Sea Emperors:\n" +
									  EnumChatFormatting.AQUA + "Time Since Emp:\n" +
									  EnumChatFormatting.AQUA + "Creatures Since Emp:";
    			String countTextTwo = EnumChatFormatting.GREEN + nf.format(LootCommand.monsterOfTheDeeps) + "\n" +
    								  EnumChatFormatting.YELLOW + nf.format(LootCommand.catfishes) + "\n" +
									  EnumChatFormatting.GOLD + nf.format(LootCommand.carrotKings) + "\n" +
									  EnumChatFormatting.GRAY + nf.format(LootCommand.seaLeeches) + "\n" +
									  EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.guardianDefenders) + "\n" +
									  EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.deepSeaProtectors) + "\n" +
									  EnumChatFormatting.GOLD + nf.format(LootCommand.hydras) + "\n" +
									  EnumChatFormatting.GOLD + nf.format(LootCommand.seaEmperors) + "\n" +
									  EnumChatFormatting.AQUA + timeBetween + "\n" +
									  EnumChatFormatting.AQUA + bossesBetween;
    			
    			if (ToggleCommand.splitFishing) {
    				new TextRenderer(mc, dropsTextTwo, (int) (MoveCommand.displayXY[0] + (160 * ScaleCommand.displayScale)), MoveCommand.displayXY[1], ScaleCommand.displayScale);
        			new TextRenderer(mc, countTextTwo, (int) (MoveCommand.displayXY[0] + (270 * ScaleCommand.displayScale)), MoveCommand.displayXY[1], ScaleCommand.displayScale);
    			} else {
    				dropsText += "\n" + dropsTextTwo;
    				countText += "\n" + countTextTwo;
    			}
    		} else if (DisplayCommand.display.equals("fishing_session")) {
    			if (LootCommand.empTimeSession == -1) {
    				timeBetween = "Never";
    			} else {
    				timeBetween = Utils.getTimeBetween(LootCommand.empTimeSession, timeNow);
    			}
    			if (LootCommand.empSCsSession == -1) {
    				bossesBetween = "Never";
    			} else {
    				bossesBetween = nf.format(LootCommand.empSCsSession);
    			}
    			
    			dropsText = EnumChatFormatting.AQUA + "Creatures Caught:\n" +
    						EnumChatFormatting.AQUA + "Fishing Milestone:\n" +
	    					EnumChatFormatting.GOLD + "Good Catches:\n" +
							EnumChatFormatting.DARK_PURPLE + "Great Catches:\n" +
							EnumChatFormatting.GRAY + "Squids:\n" +
							EnumChatFormatting.GREEN + "Sea Walkers:\n" +
							EnumChatFormatting.DARK_GRAY + "Night Squids:\n" +
							EnumChatFormatting.DARK_AQUA + "Sea Guardians:\n" +
							EnumChatFormatting.BLUE + "Sea Witches:\n" +
							EnumChatFormatting.GREEN + "Sea Archers:";
    			countText = EnumChatFormatting.AQUA + nf.format(LootCommand.seaCreaturesSession) + "\n" +
							EnumChatFormatting.AQUA + nf.format(LootCommand.fishingMilestoneSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.goodCatchesSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.greatCatchesSession) + "\n" +
							EnumChatFormatting.GRAY + nf.format(LootCommand.squidsSession) + "\n" +
							EnumChatFormatting.GREEN + nf.format(LootCommand.seaWalkersSession) + "\n" +
							EnumChatFormatting.DARK_GRAY + nf.format(LootCommand.nightSquidsSession) + "\n" +
							EnumChatFormatting.DARK_AQUA + nf.format(LootCommand.seaGuardiansSession) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.seaWitchesSession) + "\n" +
							EnumChatFormatting.GREEN + nf.format(LootCommand.seaArchersSession);
    			// Seperated to save vertical space
    			String dropsTextTwo = EnumChatFormatting.GREEN + "Monster of Deeps:\n" +
    								  EnumChatFormatting.YELLOW + "Catfishes:\n" +
									  EnumChatFormatting.GOLD + "Carrot Kings:\n" +
									  EnumChatFormatting.GRAY + "Sea Leeches:\n" +
									  EnumChatFormatting.DARK_PURPLE + "Guardian Defenders:\n" +
									  EnumChatFormatting.DARK_PURPLE + "Deep Sea Protectors:\n" +
									  EnumChatFormatting.GOLD + "Hydras:\n" +
									  EnumChatFormatting.GOLD + "Sea Emperors:\n" +
									  EnumChatFormatting.AQUA + "Time Since Emp:\n" +
									  EnumChatFormatting.AQUA + "Creatures Since Emp:";
    			String countTextTwo = EnumChatFormatting.GREEN + nf.format(LootCommand.monsterOfTheDeepsSession) + "\n" +
    								  EnumChatFormatting.YELLOW + nf.format(LootCommand.catfishesSession) + "\n" +
									  EnumChatFormatting.GOLD + nf.format(LootCommand.carrotKingsSession) + "\n" +
									  EnumChatFormatting.GRAY + nf.format(LootCommand.seaLeechesSession) + "\n" +
									  EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.guardianDefendersSession) + "\n" +
									  EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.deepSeaProtectorsSession) + "\n" +
									  EnumChatFormatting.GOLD + nf.format(LootCommand.hydrasSession) + "\n" +
									  EnumChatFormatting.GOLD + nf.format(LootCommand.seaEmperorsSession) + "\n" +
									  EnumChatFormatting.AQUA + timeBetween + "\n" +
									  EnumChatFormatting.AQUA + bossesBetween;
    			
    			if (ToggleCommand.splitFishing) {
    				new TextRenderer(mc, dropsTextTwo, (int) (MoveCommand.displayXY[0] + (160 * ScaleCommand.displayScale)), MoveCommand.displayXY[1], ScaleCommand.displayScale);
        			new TextRenderer(mc, countTextTwo, (int) (MoveCommand.displayXY[0] + (270 * ScaleCommand.displayScale)), MoveCommand.displayXY[1], ScaleCommand.displayScale);
    			} else {
    				dropsText += "\n" + dropsTextTwo;
    				countText += "\n" + countTextTwo;
    			}
    		} else if (DisplayCommand.display.equals("fishing_winter")) {
    			if (LootCommand.yetiTime == -1) {
    				timeBetween = "Never";
    			} else {
    				timeBetween = Utils.getTimeBetween(LootCommand.yetiTime, timeNow);
    			}
    			if (LootCommand.yetiSCs == -1) {
    				bossesBetween = "Never";
    			} else {
    				bossesBetween = nf.format(LootCommand.yetiSCs);
    			}
    			
    			dropsText = EnumChatFormatting.AQUA + "Creatures Caught:\n" +
    						EnumChatFormatting.AQUA + "Fishing Milestone:\n" +
    						EnumChatFormatting.GOLD + "Good Catches:\n" +
    						EnumChatFormatting.DARK_PURPLE + "Great Catches:\n" +
	    					EnumChatFormatting.AQUA + "Frozen Steves:\n" +
							EnumChatFormatting.WHITE + "Snowmans:\n" +
							EnumChatFormatting.DARK_GREEN + "Grinches:\n" +
							EnumChatFormatting.GOLD + "Yetis:\n" +
							EnumChatFormatting.AQUA + "Time Since Yeti:\n" +
							EnumChatFormatting.AQUA + "Creatures Since Yeti:";
    			countText = EnumChatFormatting.AQUA + nf.format(LootCommand.seaCreatures) + "\n" +
							EnumChatFormatting.AQUA + nf.format(LootCommand.fishingMilestone) + "\n" +
	    					EnumChatFormatting.GOLD + nf.format(LootCommand.goodCatches) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.greatCatches) + "\n" +
	    					EnumChatFormatting.AQUA + nf.format(LootCommand.frozenSteves) + "\n" +
							EnumChatFormatting.WHITE + nf.format(LootCommand.frostyTheSnowmans) + "\n" +
							EnumChatFormatting.DARK_GREEN + nf.format(LootCommand.grinches) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.yetis) + "\n" +
							EnumChatFormatting.AQUA + timeBetween + "\n" +
							EnumChatFormatting.AQUA + bossesBetween;
    		} else if (DisplayCommand.display.equals("fishing_winter_session")) {
    			if (LootCommand.yetiTimeSession == -1) {
    				timeBetween = "Never";
    			} else {
    				timeBetween = Utils.getTimeBetween(LootCommand.yetiTimeSession, timeNow);
    			}
    			if (LootCommand.yetiSCsSession == -1) {
    				bossesBetween = "Never";
    			} else {
    				bossesBetween = nf.format(LootCommand.yetiSCsSession);
    			}
    			
    			dropsText = EnumChatFormatting.AQUA + "Creatures Caught:\n" +
							EnumChatFormatting.AQUA + "Fishing Milestone:\n" +
							EnumChatFormatting.GOLD + "Good Catches:\n" +
							EnumChatFormatting.DARK_PURPLE + "Great Catches:\n" +
	    					EnumChatFormatting.AQUA + "Frozen Steves:\n" +
							EnumChatFormatting.WHITE + "Snowmans:\n" +
							EnumChatFormatting.DARK_GREEN + "Grinches:\n" +
							EnumChatFormatting.GOLD + "Yetis:\n" +
							EnumChatFormatting.AQUA + "Time Since Yeti:\n" +
							EnumChatFormatting.AQUA + "Creatures Since Yeti:";
				countText = EnumChatFormatting.AQUA + nf.format(LootCommand.seaCreaturesSession) + "\n" +
							EnumChatFormatting.AQUA + nf.format(LootCommand.fishingMilestoneSession) + "\n" +
	    					EnumChatFormatting.GOLD + nf.format(LootCommand.goodCatchesSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.greatCatchesSession) + "\n" +
	    					EnumChatFormatting.AQUA + nf.format(LootCommand.frozenStevesSession) + "\n" +
							EnumChatFormatting.WHITE + nf.format(LootCommand.frostyTheSnowmansSession) + "\n" +
							EnumChatFormatting.DARK_GREEN + nf.format(LootCommand.grinchesSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.yetisSession) + "\n" +
							EnumChatFormatting.AQUA + timeBetween + "\n" +
							EnumChatFormatting.AQUA + bossesBetween;
    		} else if (DisplayCommand.display.equals("fishing_festival")) {
    			dropsText = EnumChatFormatting.AQUA + "Creatures Caught:\n" +
    						EnumChatFormatting.AQUA + "Fishing Milestone:\n" +
    						EnumChatFormatting.GOLD + "Good Catches:\n" +
    						EnumChatFormatting.DARK_PURPLE + "Great Catches:\n" +
    						EnumChatFormatting.LIGHT_PURPLE + "Nurse Sharks:\n" +
    						EnumChatFormatting.BLUE + "Blue Sharks:\n" +
    						EnumChatFormatting.GOLD + "Tiger Sharks:\n" +
    						EnumChatFormatting.WHITE + "Great White Sharks:";
    			countText = EnumChatFormatting.AQUA + nf.format(LootCommand.seaCreatures) + "\n" +
							EnumChatFormatting.AQUA + nf.format(LootCommand.fishingMilestone) + "\n" +
	    					EnumChatFormatting.GOLD + nf.format(LootCommand.goodCatches) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.greatCatches) + "\n" +
	    					EnumChatFormatting.LIGHT_PURPLE + nf.format(LootCommand.nurseSharks) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.blueSharks) + "\n" +
	    					EnumChatFormatting.GOLD + nf.format(LootCommand.tigerSharks) + "\n" +
							EnumChatFormatting.WHITE + nf.format(LootCommand.greatWhiteSharks);
     		} else if (DisplayCommand.display.equals("fishing_festival_session")) {
    			dropsText = EnumChatFormatting.AQUA + "Creatures Caught:\n" +
							EnumChatFormatting.AQUA + "Fishing Milestone:\n" +
							EnumChatFormatting.GOLD + "Good Catches:\n" +
							EnumChatFormatting.DARK_PURPLE + "Great Catches:\n" +
							EnumChatFormatting.LIGHT_PURPLE + "Nurse Sharks:\n" +
							EnumChatFormatting.BLUE + "Blue Sharks:\n" +
							EnumChatFormatting.GOLD + "Tiger Sharks:\n" +
							EnumChatFormatting.WHITE + "Great White Sharks:";
				countText = EnumChatFormatting.AQUA + nf.format(LootCommand.seaCreaturesSession) + "\n" +
							EnumChatFormatting.AQUA + nf.format(LootCommand.fishingMilestoneSession) + "\n" +
	    					EnumChatFormatting.GOLD + nf.format(LootCommand.goodCatchesSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.greatCatchesSession) + "\n" +
	    					EnumChatFormatting.LIGHT_PURPLE + nf.format(LootCommand.nurseSharksSession) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.blueSharksSession) + "\n" +
	    					EnumChatFormatting.GOLD + nf.format(LootCommand.tigerSharksSession) + "\n" +
							EnumChatFormatting.WHITE + nf.format(LootCommand.greatWhiteSharksSession);
     		} else if (DisplayCommand.display.equals("fishing_spooky")) {
     			dropsText = EnumChatFormatting.AQUA + "Creatures Caught:\n" +
     						EnumChatFormatting.AQUA + "Fishing Milestone:\n" +
     						EnumChatFormatting.GOLD + "Good Catches:\n" +
							EnumChatFormatting.DARK_PURPLE + "Great Catches:\n" +
     						EnumChatFormatting.BLUE + "Scarecrows:\n" +
							EnumChatFormatting.GRAY + "Nightmares:\n" +
     						EnumChatFormatting.DARK_PURPLE + "Werewolves:\n" +
							EnumChatFormatting.GOLD + "Phantom Fishers:\n" +
     						EnumChatFormatting.GOLD + "Grim Reapers:";
     			countText = EnumChatFormatting.AQUA + nf.format(LootCommand.seaCreatures) + "\n" +
							EnumChatFormatting.AQUA + nf.format(LootCommand.fishingMilestone) + "\n" +
	    					EnumChatFormatting.GOLD + nf.format(LootCommand.goodCatches) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.greatCatches) + "\n" +
	    					EnumChatFormatting.BLUE + nf.format(LootCommand.scarecrows) + "\n" +
							EnumChatFormatting.GRAY + nf.format(LootCommand.nightmares) + "\n" +
	    					EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.werewolfs) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.phantomFishers) + "\n" +
	    					EnumChatFormatting.GOLD + nf.format(LootCommand.grimReapers);
     		} else if (DisplayCommand.display.equals("fishing_spooky_session")) {
     			dropsText = EnumChatFormatting.AQUA + "Creatures Caught:\n" +
	 						EnumChatFormatting.AQUA + "Fishing Milestone:\n" +
	 						EnumChatFormatting.GOLD + "Good Catches:\n" +
							EnumChatFormatting.DARK_PURPLE + "Great Catches:\n" +
	 						EnumChatFormatting.BLUE + "Scarecrows:\n" +
							EnumChatFormatting.GRAY + "Nightmares:\n" +
	 						EnumChatFormatting.DARK_PURPLE + "Werewolves:\n" +
							EnumChatFormatting.GOLD + "Phantom Fishers:\n" +
	 						EnumChatFormatting.GOLD + "Grim Reapers:";
	 			countText = EnumChatFormatting.AQUA + nf.format(LootCommand.seaCreaturesSession) + "\n" +
							EnumChatFormatting.AQUA + nf.format(LootCommand.fishingMilestoneSession) + "\n" +
	    					EnumChatFormatting.GOLD + nf.format(LootCommand.goodCatchesSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.greatCatchesSession) + "\n" +
	    					EnumChatFormatting.BLUE + nf.format(LootCommand.scarecrowsSession) + "\n" +
							EnumChatFormatting.GRAY + nf.format(LootCommand.nightmaresSession) + "\n" +
	    					EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.werewolfsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.phantomFishersSession) + "\n" +
	    					EnumChatFormatting.GOLD + nf.format(LootCommand.grimReapersSession);
     		} else if (DisplayCommand.display.equals("catacombs_floor_one")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
    						EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
    						EnumChatFormatting.BLUE + "Bonzo's Staffs:\n" +
    						EnumChatFormatting.AQUA + "Coins Spent:\n" +
    						EnumChatFormatting.AQUA + "Time Spent:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulators) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooks) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.bonzoStaffs) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f1CoinsSpent) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f1TimeSpent);
    		} else if (DisplayCommand.display.equals("catacombs_floor_one_session")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.BLUE + "Bonzo's Staffs:\n" +
    						EnumChatFormatting.AQUA + "Coins Spent:\n" +
    						EnumChatFormatting.AQUA + "Time Spent:";
				countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulatorsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooksSession) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.bonzoStaffsSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f1CoinsSpentSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f1TimeSpentSession);
    		} else if (DisplayCommand.display.equals("catacombs_floor_two")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.BLUE + "Scarf's Studies:\n" +
							EnumChatFormatting.DARK_PURPLE + "Adaptive Blades:\n" +
		    				EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
				countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulators) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooks) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.scarfStudies) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.adaptiveSwords) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f2CoinsSpent) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f2TimeSpent);
    		} else if (DisplayCommand.display.equals("catacombs_floor_two_session")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.BLUE + "Scarf's Studies:\n" +
							EnumChatFormatting.DARK_PURPLE + "Adaptive Blades:\n" +
		    				EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
				countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulatorsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooksSession) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.scarfStudiesSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.adaptiveSwordsSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f2CoinsSpentSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f2TimeSpentSession);
    		} else if (DisplayCommand.display.equals("catacombs_floor_three")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.DARK_PURPLE + "Adaptive Helmets:\n" +
							EnumChatFormatting.DARK_PURPLE + "Adaptive Chestplates:\n" +
							EnumChatFormatting.DARK_PURPLE + "Adaptive Leggings:\n" +
							EnumChatFormatting.DARK_PURPLE + "Adaptive Boots:\n" +
		    				EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
				countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulators) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooks) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.adaptiveHelms) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.adaptiveChests) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.adaptiveLegs) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.adaptiveBoots) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f3CoinsSpent) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f3TimeSpent);
    		} else if (DisplayCommand.display.equals("catacombs_floor_three_session")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.DARK_PURPLE + "Adaptive Helmets:\n" +
							EnumChatFormatting.DARK_PURPLE + "Adaptive Chestplates:\n" +
							EnumChatFormatting.DARK_PURPLE + "Adaptive Leggings:\n" +
							EnumChatFormatting.DARK_PURPLE + "Adaptive Boots:\n" +
		    				EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
				countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulatorsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooksSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.adaptiveHelmsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.adaptiveChestsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.adaptiveLegsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.adaptiveBootsSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f3CoinsSpentSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f3TimeSpentSession);
    		} else if (DisplayCommand.display.equals("catacombs_floor_four")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.DARK_PURPLE + "Spirit Wings:\n" +
							EnumChatFormatting.DARK_PURPLE + "Spirit Bones:\n" +
							EnumChatFormatting.DARK_PURPLE + "Spirit Boots:\n" +
							EnumChatFormatting.DARK_PURPLE + "Spirit Swords:\n" +
							EnumChatFormatting.GOLD + "Spirit Bows:\n" +
							EnumChatFormatting.DARK_PURPLE + "Epic Spirit Pets:\n" +
							EnumChatFormatting.GOLD + "Leg Spirit Pets:\n" +
		    				EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
				countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulators) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooks) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.spiritWings) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.spiritBones) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.spiritBoots) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.spiritSwords) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.spiritBows) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.epicSpiritPets) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.legSpiritPets) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f4CoinsSpent) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f4TimeSpent);
    		} else if (DisplayCommand.display.equals("catacombs_floor_four_session")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.DARK_PURPLE + "Spirit Wings:\n" +
							EnumChatFormatting.DARK_PURPLE + "Spirit Bones:\n" +
							EnumChatFormatting.DARK_PURPLE + "Spirit Boots:\n" +
							EnumChatFormatting.DARK_PURPLE + "Spirit Swords:\n" +
							EnumChatFormatting.GOLD + "Spirit Bows:\n" +
							EnumChatFormatting.DARK_PURPLE + "Epic Spirit Pets:\n" +
							EnumChatFormatting.GOLD + "Leg Spirit Pets:\n" +
		    				EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
				countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulatorsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooksSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.spiritWingsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.spiritBonesSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.spiritBootsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.spiritSwordsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.spiritBowsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.epicSpiritPetsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.legSpiritPetsSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f4CoinsSpentSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f4TimeSpentSession);
    		} else if (DisplayCommand.display.equals("catacombs_floor_five")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.BLUE + "Warped Stones:\n" +
							EnumChatFormatting.DARK_PURPLE + "Shadow Helmets:\n" +
							EnumChatFormatting.DARK_PURPLE + "Shadow Chestplates:\n" +
							EnumChatFormatting.DARK_PURPLE + "Shadow Leggings:\n" +
							EnumChatFormatting.DARK_PURPLE + "Shadow Boots:\n" +
							EnumChatFormatting.GOLD + "Last Breaths:\n" +
							EnumChatFormatting.GOLD + "Livid Daggers:\n" +
							EnumChatFormatting.GOLD + "Shadow Furys:\n" +
							EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulators) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooks) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.warpedStones) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.shadowAssHelms) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.shadowAssChests) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.shadowAssLegs) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.shadowAssBoots) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.lastBreaths) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.lividDaggers) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.shadowFurys) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f5CoinsSpent) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f5TimeSpent);
    		} else if (DisplayCommand.display.equals("catacombs_floor_five_session")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.BLUE + "Warped Stones:\n" +
							EnumChatFormatting.DARK_PURPLE + "Shadow Helmets:\n" +
							EnumChatFormatting.DARK_PURPLE + "Shadow Chestplates:\n" +
							EnumChatFormatting.DARK_PURPLE + "Shadow Leggings:\n" +
							EnumChatFormatting.DARK_PURPLE + "Shadow Boots:\n" +
							EnumChatFormatting.GOLD + "Last Breaths:\n" +
							EnumChatFormatting.GOLD + "Livid Daggers:\n" +
							EnumChatFormatting.GOLD + "Shadow Furys:\n" +
							EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulatorsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooksSession) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.warpedStonesSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.shadowAssHelmsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.shadowAssChestsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.shadowAssLegsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.shadowAssBootsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.lastBreathsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.lividDaggersSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.shadowFurysSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f5CoinsSpentSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f5TimeSpentSession);
    		} else if (DisplayCommand.display.equals("catacombs_floor_six")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.BLUE + "Ancient Roses:\n" +
							EnumChatFormatting.GOLD + "Precursor Eyes:\n" +
							EnumChatFormatting.GOLD + "Giant's Swords:\n" +
							EnumChatFormatting.GOLD + "Necro Lord Helmets:\n" +
							EnumChatFormatting.GOLD + "Necro Lord Chests:\n" +
							EnumChatFormatting.GOLD + "Necro Lord Leggings:\n" +
							EnumChatFormatting.GOLD + "Necro Lord Boots:\n" +
							EnumChatFormatting.GOLD + "Necro Swords:\n" +
							EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulators) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooks) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.ancientRoses) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.precursorEyes) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.giantsSwords) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.necroLordHelms) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.necroLordChests) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.necroLordLegs) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.necroLordBoots) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.necroSwords) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f6CoinsSpent) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f6TimeSpent);
    		} else if (DisplayCommand.display.equals("catacombs_floor_six_session")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.BLUE + "Ancient Roses:\n" +
							EnumChatFormatting.GOLD + "Precursor Eyes:\n" +
							EnumChatFormatting.GOLD + "Giant's Swords:\n" +
							EnumChatFormatting.GOLD + "Necro Lord Helmets:\n" +
							EnumChatFormatting.GOLD + "Necro Lord Chests:\n" +
							EnumChatFormatting.GOLD + "Necro Lord Leggings:\n" +
							EnumChatFormatting.GOLD + "Necro Lord Boots:\n" +
							EnumChatFormatting.GOLD + "Necro Swords:\n" +
							EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulatorsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooksSession) + "\n" +
							EnumChatFormatting.BLUE + nf.format(LootCommand.ancientRosesSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.precursorEyesSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.giantsSwordsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.necroLordHelmsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.necroLordChestsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.necroLordLegsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.necroLordBootsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.necroSwordsSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f6CoinsSpentSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f6TimeSpentSession);
    		} else if (DisplayCommand.display.equals("catacombs_floor_seven")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.DARK_PURPLE + "Wither Bloods:\n" +
							EnumChatFormatting.DARK_PURPLE + "Wither Cloaks:\n" +
							EnumChatFormatting.DARK_PURPLE + "Implosions:\n" +
							EnumChatFormatting.DARK_PURPLE + "Wither Shields:\n" +
							EnumChatFormatting.DARK_PURPLE + "Shadow Warps:\n" +
							EnumChatFormatting.GOLD + "Auto Recombobs:\n" +
							EnumChatFormatting.GOLD + "Wither Helmets:\n" +
							EnumChatFormatting.GOLD + "Wither Chests:\n" +
							EnumChatFormatting.GOLD + "Wither Leggings:\n" +
							EnumChatFormatting.GOLD + "Wither Boots:\n" +
							EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulators) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooks) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.witherBloods) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.witherCloaks) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.implosions) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.witherShields) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.shadowWarps) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.autoRecombs) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.witherHelms) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.witherChests) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.witherLegs) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.witherBoots) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f7CoinsSpent) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f7TimeSpent);
    		} else if (DisplayCommand.display.equals("catacombs_floor_seven_session")) {
    			dropsText = EnumChatFormatting.GOLD + "Recombobulators:\n" +
							EnumChatFormatting.DARK_PURPLE + "Fuming Potato Books:\n" +
							EnumChatFormatting.DARK_PURPLE + "Wither Bloods:\n" +
							EnumChatFormatting.DARK_PURPLE + "Wither Cloaks:\n" +
							EnumChatFormatting.DARK_PURPLE + "Implosions:\n" +
							EnumChatFormatting.DARK_PURPLE + "Wither Shields:\n" +
							EnumChatFormatting.DARK_PURPLE + "Shadow Warps:\n" +
							EnumChatFormatting.GOLD + "Auto Recombobulators:\n" +
							EnumChatFormatting.GOLD + "Wither Helmets:\n" +
							EnumChatFormatting.GOLD + "Wither Chests:\n" +
							EnumChatFormatting.GOLD + "Wither Leggings:\n" +
							EnumChatFormatting.GOLD + "Wither Boots:\n" +
							EnumChatFormatting.AQUA + "Coins Spent:\n" +
		    				EnumChatFormatting.AQUA + "Time Spent:";
    			countText = EnumChatFormatting.GOLD + nf.format(LootCommand.recombobulatorsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.fumingPotatoBooksSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.witherBloodsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.witherCloaksSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.implosionsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.witherShieldsSession) + "\n" +
							EnumChatFormatting.DARK_PURPLE + nf.format(LootCommand.shadowWarpsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.autoRecombsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.witherHelmsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.witherChestsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.witherLegsSession) + "\n" +
							EnumChatFormatting.GOLD + nf.format(LootCommand.witherBootsSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getMoneySpent(LootCommand.f7CoinsSpentSession) + "\n" +
							EnumChatFormatting.AQUA + Utils.getTimeBetween(0, LootCommand.f7TimeSpentSession);
    		} else {
    			System.out.println("Display was an unknown value, turning off.");
    			DisplayCommand.display = "off";
    			ConfigHandler.writeStringConfig("misc", "display", "off");
    		}
    		new TextRenderer(mc, dropsText, MoveCommand.displayXY[0], MoveCommand.displayXY[1], ScaleCommand.displayScale);
    		new TextRenderer(mc, countText, (int) (MoveCommand.displayXY[0] + (110 * ScaleCommand.displayScale)), MoveCommand.displayXY[1], ScaleCommand.displayScale);
    	}
    	
    	if (showTitle) {
    		Utils.drawTitle(titleText);
    	}
    	if (showSkill) {
    		new TextRenderer(mc, skillText, MoveCommand.skill50XY[0], MoveCommand.skill50XY[1], ScaleCommand.skill50Scale);
    	}
    }
    
    @SubscribeEvent(priority = EventPriority.HIGHEST)
    public void onSound(final PlaySoundEvent event) {
    	if (!Utils.inSkyblock) return;
    	if (event.name.equals("note.pling")) {
    		// Don't check twice within 3 seconds 
    		checkItemsNow = System.currentTimeMillis() / 1000;
    		if (checkItemsNow - itemsChecked < 3) return;
    		
    		List<String> scoreboard = ScoreboardHandler.getSidebarLines();
    		
    		for (String line : scoreboard) {
    			String cleanedLine = ScoreboardHandler.cleanSB(line);
    			// If Hypixel lags and scoreboard doesn't update
    			if (cleanedLine.contains("Boss slain!") || cleanedLine.contains("Slay the boss!")) {
    				int itemTeeth = Utils.getItems("Wolf Tooth");
        			int itemWheels = Utils.getItems("Hamster Wheel");
        			int itemWebs = Utils.getItems("Tarantula Web");
        			int itemTAP = Utils.getItems("Toxic Arrow Poison");
        			int itemRev = Utils.getItems("Revenant Flesh");
        			int itemFoul = Utils.getItems("Foul Flesh");
        			
        			// If no items, are detected, allow check again. Should fix items not being found
        			if (itemTeeth + itemWheels + itemWebs + itemTAP + itemRev + itemFoul > 0) {
        				itemsChecked = System.currentTimeMillis() / 1000;
            			LootCommand.wolfTeeth += itemTeeth;
            			LootCommand.wolfWheels += itemWheels;
            			LootCommand.spiderWebs += itemWebs;
            			LootCommand.spiderTAP += itemTAP;
            			LootCommand.zombieRevFlesh += itemRev;
            			LootCommand.zombieFoulFlesh += itemFoul;
            			LootCommand.wolfTeethSession += itemTeeth;
            			LootCommand.wolfWheelsSession += itemWheels;
            			LootCommand.spiderWebsSession += itemWebs;
            			LootCommand.spiderTAPSession += itemTAP;
            			LootCommand.zombieRevFleshSession += itemRev;
            			LootCommand.zombieFoulFleshSession += itemFoul;
            			
            			ConfigHandler.writeIntConfig("wolf", "teeth", LootCommand.wolfTeeth);
            			ConfigHandler.writeIntConfig("wolf", "wheel", LootCommand.wolfWheels);
            			ConfigHandler.writeIntConfig("spider", "web", LootCommand.spiderWebs);
            			ConfigHandler.writeIntConfig("spider", "tap", LootCommand.spiderTAP);
            			ConfigHandler.writeIntConfig("zombie", "revFlesh", LootCommand.zombieRevFlesh);
            			ConfigHandler.writeIntConfig("zombie", "foulFlesh", LootCommand.zombieFoulFlesh);
        			}
    			}
    		}
    	}
    }
    
    @SubscribeEvent(priority = EventPriority.HIGHEST)
    public void onTooltip(ItemTooltipEvent event) {
    	if (!Utils.inSkyblock) return;
    	if (event.toolTip == null) return;
    	
    	ItemStack item = event.itemStack;
    	if (ToggleCommand.goldenToggled) {
    		for (int i = 0; i < event.toolTip.size(); i++) {
    			event.toolTip.set(i, Utils.returnGoldenEnchants(event.toolTip.get(i)));
    		}
    	}
    	
    	if (ToggleCommand.expertiseLoreToggled) {
    		if (item.hasTagCompound()) {
    			NBTTagCompound tags = item.getSubCompound("ExtraAttributes", false);
    			if (tags != null) {
    				if (tags.hasKey("expertise_kills")) {
    					int index = 4;
    					if (!Minecraft.getMinecraft().gameSettings.advancedItemTooltips) index -= 2;
    					
    					event.toolTip.add(event.toolTip.size() - index, "");
    					event.toolTip.add(event.toolTip.size() - index, "Expertise Kills: " + EnumChatFormatting.RED + tags.getInteger("expertise_kills"));
    					if (Utils.expertiseKillsLeft(tags.getInteger("expertise_kills")) != -1) {
    						event.toolTip.add(event.toolTip.size() - index, Utils.expertiseKillsLeft(tags.getInteger("expertise_kills")) + " kills to tier up!");
    					}
    				}
    			}
    		}
    	}
    }
    
    @SubscribeEvent
    public void onTick(TickEvent.ClientTickEvent event) {
    	if (event.phase != Phase.START) return;
    	
		Minecraft mc = Minecraft.getMinecraft();
		World world = mc.theWorld;
		EntityPlayerSP player = mc.thePlayer;
		
    	// Checks every second
    	tickAmount++;
    	if (tickAmount % 20 == 0) {
    		if (player != null) {
        		Utils.checkForSkyblock();
        		Utils.checkForDungeons();
    		}
    		
    		if (DisplayCommand.auto && mc != null && world != null) {
    			List<String> scoreboard = ScoreboardHandler.getSidebarLines();
    			boolean found = false;
    			for (String s : scoreboard) {
    				String sCleaned = ScoreboardHandler.cleanSB(s);
    				if (sCleaned.contains("Sven Packmaster")) {
    					DisplayCommand.display = "wolf";
    					found = true;
    				} else if (sCleaned.contains("Tarantula Broodfather")) {
    					DisplayCommand.display = "spider";
    					found = true;
    				} else if (sCleaned.contains("Revenant Horror")) {
    					DisplayCommand.display = "zombie";
    					found = true;
    				} else if (sCleaned.contains("The Catacombs (")) {
    					if (sCleaned.contains("F1")) {
    						DisplayCommand.display = "catacombs_floor_one";
    					} else if (sCleaned.contains("F2")) {
    						DisplayCommand.display = "catacombs_floor_two";
    					} else if (sCleaned.contains("F3")) {
    						DisplayCommand.display = "catacombs_floor_three";
    					} else if (sCleaned.contains("F4")) {
    						DisplayCommand.display = "catacombs_floor_four";
    					} else if (sCleaned.contains("F5")) {
    						DisplayCommand.display = "catacombs_floor_five";
    					} else if (sCleaned.contains("F6")) {
    						DisplayCommand.display = "catacombs_floor_six";
    					} else if (sCleaned.contains("F7")) {
    						DisplayCommand.display = "catacombs_floor_seven";
    					}
    					found = true;
    				}
    			}
    			if (!found) DisplayCommand.display = "off";
    			ConfigHandler.writeStringConfig("misc", "display", DisplayCommand.display);
    		}
    		
    		if (ToggleCommand.creeperToggled && Utils.inDungeons && world != null) {
    	    	double x = player.posX;
    	    	double y = player.posY;
    	    	double z = player.posZ;
    			// Find creepers nearby
    			AxisAlignedBB creeperScan = new AxisAlignedBB(x - 14, y - 8, z - 13, x + 14, y + 8, z + 13); // 28x16x26 cube
    			List<EntityCreeper> creepers = world.getEntitiesWithinAABB(EntityCreeper.class, creeperScan);
    			// Check if creeper is nearby
    			if (creepers.size() > 0) {
    				EntityCreeper creeper = creepers.get(0);
    				// Start creeper line drawings
    				creeperLines.clear();
    				if (!drawCreeperLines) creeperLocation = new Vec3(creeper.posX, creeper.posY + 1, creeper.posZ);
    				drawCreeperLines = true;
    				// Search for nearby sea lanterns and prismarine blocks
    				BlockPos point1 = new BlockPos(creeper.posX - 14, creeper.posY - 7, creeper.posZ - 13);
    				BlockPos point2 = new BlockPos(creeper.posX + 14, creeper.posY + 10, creeper.posZ + 13);
    				Iterable<BlockPos> blocks = BlockPos.getAllInBox(point1, point2);
    				for (BlockPos blockPos : blocks) {
    					Block block = world.getBlockState(blockPos).getBlock();
    					if (block == Blocks.sea_lantern || block == Blocks.prismarine) {
    						// Connect block to nearest block on opposite side
    						Vec3 startBlock = new Vec3(blockPos.getX() + 0.5, blockPos.getY() + 0.5, blockPos.getZ() + 0.5);
    						BlockPos oppositeBlock = Utils.getFirstBlockPosAfterVectors(mc, startBlock, creeperLocation, 10, 20);
    						BlockPos endBlock = Utils.getNearbyBlock(mc, oppositeBlock, Blocks.sea_lantern, Blocks.prismarine);
    						if (endBlock != null && startBlock.yCoord > 68 && endBlock.getY() > 68) { // Don't create line underground
    							// Add to list for drawing
        						Vec3[] insertArray = {startBlock, new Vec3(endBlock.getX() + 0.5, endBlock.getY() + 0.5, endBlock.getZ() + 0.5)};
        						creeperLines.add(insertArray);
    						}
    					}
    				}
    			} else {
    				drawCreeperLines = false;
    			}
    		}
    		
    		if (ToggleCommand.waterToggled && Utils.inDungeons && world != null) {
    			// multi thread block checking
    			new Thread(() -> {
    				prevInWaterRoom = inWaterRoom;
    				inWaterRoom = false;
    				boolean done = false;
    				for (int x = (int) (player.posX - 25); x < player.posX + 25; x++) {
    					for (int z = (int) (player.posZ - 25); z < player.posZ + 25; z++) {
    						BlockPos blockPos = new BlockPos(x, 82, z);
    						if (world.getBlockState(blockPos).getBlock() == Blocks.piston_head) {
    							inWaterRoom = true;
    							if (!prevInWaterRoom && inWaterRoom) {
        							boolean foundGold = false;
        							boolean foundClay = false;
        							boolean foundEmerald = false;
        							boolean foundQuartz = false;
        							boolean foundDiamond = false;
        							
        							// Detect first blocks near water stream
        							BlockPos scan1 = new BlockPos(x + 1, 78, z + 1);
        							BlockPos scan2 = new BlockPos(x - 1, 77, z - 1);
        							Iterable<BlockPos> blocks = BlockPos.getAllInBox(scan1, scan2);
        							for (BlockPos puzzleBlockPos : blocks) {
        								Block block = world.getBlockState(puzzleBlockPos).getBlock();
        								if (block == Blocks.gold_block) {
        									foundGold = true;
        								} else if (block == Blocks.hardened_clay) {
        									foundClay = true;
        								} else if (block == Blocks.emerald_block) {
        									foundEmerald = true;
        								} else if (block == Blocks.quartz_block) {
        									foundQuartz = true;
        								} else if (block == Blocks.diamond_block) {
        									foundDiamond = true;
        								}
        							}
        							
        							int variant = 0;
        							if (foundGold && foundClay) {
        								variant = 1;
        							} else if (foundEmerald && foundQuartz) {
        								variant = 2;
        							} else if (foundQuartz && foundDiamond) {
        								variant = 3;
        							} else if (foundGold && foundQuartz) {
        								variant = 4;
        							}
        							
        							// Return solution
        							String purple = "";
        							String orange = "";
        							String blue = "";
        							String green = "";
        							String red = "";
        							switch (variant) {
    	    							case 1:
    	    								purple = EnumChatFormatting.WHITE + "Quartz, " + EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.AQUA + "Diamond, " + EnumChatFormatting.RED + "Clay";
    	    								orange = EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.DARK_GRAY + "Coal, " + EnumChatFormatting.GREEN + "Emerald";
    	    								blue = EnumChatFormatting.WHITE + "Quartz, " + EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.GREEN + "Emerald" + EnumChatFormatting.RED + "Clay";
    	    								green = EnumChatFormatting.GREEN + "Emerald";
    	    								red = EnumChatFormatting.GRAY + "None";
    	    								break;
    	    							case 2:
    	    								purple = EnumChatFormatting.DARK_GRAY + "Coal";
    	    								orange = EnumChatFormatting.WHITE + "Quartz, " + EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.GREEN + "Emerald, " + EnumChatFormatting.RED + "Clay";
    	    								blue = EnumChatFormatting.WHITE + "Quartz, " + EnumChatFormatting.AQUA + "Diamond, " + EnumChatFormatting.GREEN + "Emerald";
    	    								green = EnumChatFormatting.WHITE + "Quartz, " + EnumChatFormatting.GREEN + "Emerald";
    	    								red = EnumChatFormatting.WHITE + "Quartz, " + EnumChatFormatting.DARK_GRAY + "Coal, " + EnumChatFormatting.GREEN + "Emerald";
    	    								break;
    	    							case 3:
    	    								purple = EnumChatFormatting.WHITE + "Quartz, " + EnumChatFormatting.AQUA + "Diamond";
    	    								orange = EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.GREEN + "Emerald";
    	    								blue = EnumChatFormatting.WHITE + "Quartz, " + EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.AQUA + "Diamond";
    	    								green = EnumChatFormatting.YELLOW + "Gold";
    	    								red = EnumChatFormatting.GREEN + "Emerald";
    	    								break;
    	    							case 4:
    	    								purple = EnumChatFormatting.WHITE + "Quartz, " + EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.GREEN + "Emerald, " + EnumChatFormatting.RED + "Clay";
    	    								orange = EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.DARK_GRAY + "Coal";
    	    								blue = EnumChatFormatting.WHITE + "Quartz, " + EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.DARK_GRAY + "Coal, " + EnumChatFormatting.GREEN + "Emerald, " + EnumChatFormatting.RED + "Clay";
    	    								green = EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.GREEN + "Emerald";
    	    								red = EnumChatFormatting.YELLOW + "Gold, " + EnumChatFormatting.AQUA + "Diamond, " + EnumChatFormatting.GREEN + "Emerald, " + EnumChatFormatting.RED + "Clay";
    	    								break;
    	    							default:
    	    								player.addChatMessage(new ChatComponentText(ERROR_COLOUR + "Error detecting water puzzle variant."));
    	    								break;
        							}
        							player.addChatMessage(new ChatComponentText(DELIMITER_COLOUR + EnumChatFormatting.BOLD + "-------------------\n" +
        																		MAIN_COLOUR + " The following levers must be down:\n " + 
        																		EnumChatFormatting.DARK_PURPLE + "Purple: " + purple + "\n " + 
        																		EnumChatFormatting.GOLD + "Orange: " + orange + "\n " + 
        																		EnumChatFormatting.BLUE + "Blue: " + blue + "\n " + 
        																		EnumChatFormatting.GREEN + "Green: " + green + "\n " + 
        																		EnumChatFormatting.RED + "Red: " + red + "\n" +
        																		DELIMITER_COLOUR + EnumChatFormatting.BOLD + " -------------------"));
        							done = true;
        							break;	
    							}
    						}
    					}
    					if (done) break;
    				}
    			}).start();
    		}
    		
    		if (ToggleCommand.lividSolverToggled && Utils.inDungeons && !foundLivid && world != null) {
    			boolean inF5 = false;
    			
    			List<String> scoreboard = ScoreboardHandler.getSidebarLines();
    			for (String s : scoreboard) {
    				String sCleaned = ScoreboardHandler.cleanSB(s);
    				if (sCleaned.contains("The Catacombs (F5)")) {
    					inF5 = true;
    					break;
    				}
    			}
    			
    			if (inF5) {
    				List<Entity> loadedLivids = new ArrayList<Entity>();
    				List<Entity> entities = world.getLoadedEntityList();
    				for (Entity entity : entities) {
    					String name = entity.getName();
    					if (name.contains("Livid") && name.length() > 5 && name.charAt(1) == name.charAt(5) && !loadedLivids.contains(entity)) {
    						loadedLivids.add(entity);
    					}
    				}
    				if (loadedLivids.size() > 8) {
    					livid = loadedLivids.get(0);
    					foundLivid = true;
    				}
    			}
    		}
    		
    		tickAmount = 0;
    	}
    	
    	// Checks 5 times per second
    	if (tickAmount % 4 == 0) {
    		if (ToggleCommand.blazeToggled && Utils.inDungeons && world != null) {
    			List<Entity> entities = world.getLoadedEntityList();
    			int highestHealth = 0;
    			highestBlaze = null;
    			int lowestHealth = 99999999;
    			lowestBlaze = null;

    			for (Entity entity : entities) {
    				if (entity.getName().contains("Blaze") && entity.getName().contains("/")) {
    					String blazeName = StringUtils.stripControlCodes(entity.getName());
    					try {
    						int health = Integer.parseInt(blazeName.substring(blazeName.indexOf("/") + 1, blazeName.length() - 1));
    						if (health > highestHealth) {
    							highestHealth = health;
    							highestBlaze = entity;
    						}
    						if (health < lowestHealth) {
    							lowestHealth = health;
    							lowestBlaze = entity;
    						}
    					} catch (NumberFormatException ex) {
    						System.err.println(ex);
    					}
    				}
    			}
    		}
    	}
    	
    	if (titleTimer >= 0) {
    		if (titleTimer == 0) {
    			showTitle = false;
    		}
    		titleTimer--;
    	}
    	if (skillTimer >= 0) {
    		if (skillTimer == 0) {
    			showSkill = false;
    		}
    		skillTimer--;
     	}
    }
    
    // Delay GUI by 1 tick
    @SubscribeEvent
    public void onRenderTick(TickEvent.RenderTickEvent event) {
    	if (guiToOpen != null) {
    		Minecraft mc = Minecraft.getMinecraft();
        	if (guiToOpen.startsWith("dankergui")) {
        		int page = Character.getNumericValue(guiToOpen.charAt(guiToOpen.length() - 1));
        		mc.displayGuiScreen(new DankerGui(page));
        	} else if (guiToOpen.equals("displaygui")) {
        		mc.displayGuiScreen(new DisplayGui());
        	} else if (guiToOpen.equals("onlyslayergui")) {
        		mc.displayGuiScreen(new OnlySlayerGui());
        	} else if (guiToOpen.equals("editlocations")) {
        		mc.displayGuiScreen(new EditLocationsGui());
        	} else if (guiToOpen.equals("puzzlesolvers")) {
        		mc.displayGuiScreen(new PuzzleSolversGui());
        	}
        	guiToOpen = null;
    	}
    }
    
    @SubscribeEvent
    public void onWorldRender(RenderWorldLastEvent event) {
    	if (ToggleCommand.blazeToggled) {
    		if (lowestBlaze != null) {
    			BlockPos stringPos = new BlockPos(lowestBlaze.posX, lowestBlaze.posY + 1, lowestBlaze.posZ);
    			Utils.draw3DString(stringPos, EnumChatFormatting.BOLD + "Smallest", 0xFF0000, event.partialTicks);
    			AxisAlignedBB aabb = new AxisAlignedBB(lowestBlaze.posX - 0.5, lowestBlaze.posY - 2, lowestBlaze.posZ - 0.5, lowestBlaze.posX + 0.5, lowestBlaze.posY, lowestBlaze.posZ + 0.5);
    			Utils.draw3DBox(aabb, 0xFF, 0x00, 0x00, 0xFF, event.partialTicks);
    		}
    		if (highestBlaze != null) {
    			BlockPos stringPos = new BlockPos(highestBlaze.posX, highestBlaze.posY + 1, highestBlaze.posZ);
    			Utils.draw3DString(stringPos, EnumChatFormatting.BOLD + "Biggest", 0x40FF40, event.partialTicks);
    			AxisAlignedBB aabb = new AxisAlignedBB(highestBlaze.posX - 0.5, highestBlaze.posY - 2, highestBlaze.posZ - 0.5, highestBlaze.posX + 0.5, highestBlaze.posY, highestBlaze.posZ + 0.5);
    			Utils.draw3DBox(aabb, 0x00, 0xFF, 0x00, 0xFF, event.partialTicks);
    		}
    	}
    	if (ToggleCommand.creeperToggled && drawCreeperLines && !creeperLines.isEmpty()) {
    		for (int i = 0; i < creeperLines.size(); i++) {
    			Utils.draw3DLine(creeperLines.get(i)[0], creeperLines.get(i)[1], CREEPER_COLOURS[i % 10], event.partialTicks);
    		}
    	}
    }
    
    @SubscribeEvent
    public void onInteract(PlayerInteractEvent event) {
    	if (!Utils.inSkyblock || Minecraft.getMinecraft().thePlayer != event.entityPlayer) return;
    	ItemStack item = event.entityPlayer.getHeldItem();
    	if (item == null) return;
    	
    	if (event.action == PlayerInteractEvent.Action.RIGHT_CLICK_AIR) {
    		if (ToggleCommand.aotdToggled && item.getDisplayName().contains("Aspect of the Dragons")) {
    			event.setCanceled(true);
    		}
    		if (ToggleCommand.lividDaggerToggled && item.getDisplayName().contains("Livid Dagger")) {
    			event.setCanceled(true);
    		}
    	}
    }
    
    @SubscribeEvent
    public void onKey(KeyInputEvent event) {
    	if (!Utils.inSkyblock) return;
    	if (keyBindings[0].isPressed()) {
    		Minecraft.getMinecraft().thePlayer.sendChatMessage(lastMaddoxCommand);
    	}
    }
    
    @SubscribeEvent
    public void onGuiMouseInputPre(GuiScreenEvent.MouseInputEvent.Pre event) {
    	if (!Utils.inSkyblock) return;
    	if (Mouse.getEventButton() == lastMouse) return;
    	if (Mouse.getEventButton() != 0 && Mouse.getEventButton() != 1) return; // Left click or right click
    	
    	if (event.gui instanceof GuiChest) {
    		Container containerChest = ((GuiChest) event.gui).inventorySlots;
    		if (containerChest instanceof ContainerChest) {
    			// a lot of declarations here, if you get scarred, my bad
        		GuiChest chest = (GuiChest) event.gui;
    			IInventory inventory = ((ContainerChest) containerChest).getLowerChestInventory();
    			Slot mouseSlot = chest.getSlotUnderMouse();
    			if (mouseSlot == null || mouseSlot.getStack() == null) return;
    			ItemStack item = mouseSlot.getStack();
    			String inventoryName = inventory.getDisplayName().getUnformattedText();
    			
    			if (inventoryName.endsWith(" Chest") && item.getDisplayName().contains("Open Reward Chest")) {
    				List<String> tooltip = item.getTooltip(Minecraft.getMinecraft().thePlayer, Minecraft.getMinecraft().gameSettings.advancedItemTooltips);
    				for (String lineUnclean : tooltip) {
    					String line = StringUtils.stripControlCodes(lineUnclean);
    					if (line.contains("FREE")) {
    						break;
    					} else if (line.contains(" Coins")) {
    						int coinsSpent = Integer.parseInt(line.substring(0, line.indexOf(" ")).replaceAll(",", ""));
    						
    						List<String> scoreboard = ScoreboardHandler.getSidebarLines();
    						for (String s : scoreboard) {
    							String sCleaned = ScoreboardHandler.cleanSB(s);
    							if (sCleaned.contains("The Catacombs (")) {
    								if (sCleaned.contains("F1")) {
    									LootCommand.f1CoinsSpent += coinsSpent;
    									LootCommand.f1CoinsSpentSession += coinsSpent;
    									ConfigHandler.writeDoubleConfig("catacombs", "floorOneCoins", LootCommand.f1CoinsSpent);
    								} else if (sCleaned.contains("F2")) {
    									LootCommand.f2CoinsSpent += coinsSpent;
    									LootCommand.f2CoinsSpentSession += coinsSpent;
    									ConfigHandler.writeDoubleConfig("catacombs", "floorTwoCoins", LootCommand.f2CoinsSpent);
    								} else if (sCleaned.contains("F3")) {
    									LootCommand.f3CoinsSpent += coinsSpent;
    									LootCommand.f3CoinsSpentSession += coinsSpent;
    									ConfigHandler.writeDoubleConfig("catacombs", "floorThreeCoins", LootCommand.f3CoinsSpent);
    								} else if (sCleaned.contains("F4")) {
    									LootCommand.f4CoinsSpent += coinsSpent;
    									LootCommand.f4CoinsSpentSession += coinsSpent;
    									ConfigHandler.writeDoubleConfig("catacombs", "floorFourCoins", LootCommand.f4CoinsSpent);
    								} else if (sCleaned.contains("F5")) {
    									LootCommand.f5CoinsSpent += coinsSpent;
    									LootCommand.f5CoinsSpentSession += coinsSpent;
    									ConfigHandler.writeDoubleConfig("catacombs", "floorFiveCoins", LootCommand.f5CoinsSpent);
    								} else if (sCleaned.contains("F6")) {
    									LootCommand.f6CoinsSpent += coinsSpent;
    									LootCommand.f6CoinsSpentSession += coinsSpent;
    									ConfigHandler.writeDoubleConfig("catacombs", "floorSixCoins", LootCommand.f6CoinsSpent);
    								} else if (sCleaned.contains("F7")) {
    									LootCommand.f7CoinsSpent += coinsSpent;
    									LootCommand.f7CoinsSpentSession += coinsSpent;
    									ConfigHandler.writeDoubleConfig("catacombs", "floorSevenCoins", LootCommand.f7CoinsSpent);
    								}
    								break;
    							}
    						}
    						break;
    					}
    				}
    			} 
    			
    			if (!BlockSlayerCommand.onlySlayerName.equals("")) {
    				if (inventoryName.equals("Slayer")) {
        				if (!item.getDisplayName().contains("Revenant Horror") && !item.getDisplayName().contains("Tarantula Broodfather") && !item.getDisplayName().contains("Sven Packmaster")) return;
        				if (!item.getDisplayName().contains(BlockSlayerCommand.onlySlayerName)) {
        					Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(ERROR_COLOUR + "Danker's Skyblock Mod has stopped you from starting this quest (Set to " + BlockSlayerCommand.onlySlayerName + " " + BlockSlayerCommand.onlySlayerNumber + ")"));
        					Minecraft.getMinecraft().thePlayer.playSound("note.bass", 1, (float) 0.5);
        					event.setCanceled(true);
        				}
        			} else if (inventoryName.equals("Revenant Horror") || inventoryName.equals("Tarantula Broodfather") || inventoryName.equals("Sven Packmaster")) {
        				if (item.getDisplayName().contains("Revenant Horror") || item.getDisplayName().contains("Tarantula Broodfather") || item.getDisplayName().contains("Sven Packmaster")) {
        					// Only check number as they passed the above check
        					String slayerNumber = item.getDisplayName().substring(item.getDisplayName().lastIndexOf(" ") + 1, item.getDisplayName().length());
            				if (!slayerNumber.equals(BlockSlayerCommand.onlySlayerNumber)) {
            					Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(ERROR_COLOUR + "Danker's Skyblock Mod has stopped you from starting this quest (Set to " + BlockSlayerCommand.onlySlayerName + " " + BlockSlayerCommand.onlySlayerNumber + ")"));
            					Minecraft.getMinecraft().thePlayer.playSound("note.bass", 1, (float) 0.5);
            					event.setCanceled(true);
            				}
        				}
        			}
    			}
    		}
    	}
    }
    
    @SubscribeEvent
    public void onMouseInputPost(GuiScreenEvent.MouseInputEvent.Post event) {
    	if (!Utils.inSkyblock) return;
    	if (Mouse.getEventButton() == lastMouse) return;
    	if (Mouse.getEventButton() == 0 && event.gui instanceof GuiChat) {
    		if (ToggleCommand.chatMaddoxToggled && System.currentTimeMillis() / 1000 - lastMaddoxTime < 10) {
    			Minecraft.getMinecraft().thePlayer.sendChatMessage(lastMaddoxCommand);
    		}
    	}
    	
    	lastMouse = Mouse.getEventButton();
    }
    
    @SubscribeEvent
    public void onGuiRender(GuiScreenEvent.BackgroundDrawnEvent event) {
    	if (!Utils.inSkyblock) return;
    	if (ToggleCommand.petColoursToggled && event.gui instanceof GuiChest) {
    		GuiChest inventory = (GuiChest) event.gui;
    		List<Slot> invSlots = inventory.inventorySlots.inventorySlots;
    		Pattern petPattern = Pattern.compile("\\[Lvl [\\d]{1,3}]");
    		for (Slot slot : invSlots) {
    			ItemStack item = slot.getStack();
    			if (item == null) continue;
    			String name = item.getDisplayName();
    			if (petPattern.matcher(StringUtils.stripControlCodes(name)).find()) {
    				if (name.endsWith("aHealer") || name.endsWith("aMage") || name.endsWith("aBerserk") || name.endsWith("aArcher") || name.endsWith("aTank")) continue;
    				int colour;
    				int petLevel = Integer.parseInt(item.getDisplayName().substring(item.getDisplayName().indexOf(" ") + 1, item.getDisplayName().indexOf("]")));
    				if (petLevel == 100) {
    					colour = 0xBFF2D249; // Gold
    				} else if (petLevel >= 90) {
    					colour = 0xBF9E794E; // Brown
    				} else if (petLevel >= 80) {
    					colour = 0xBF5C1F35; // idk weird magenta
    				} else if (petLevel >= 70) {
    					colour = 0xBFD64FC8; // Pink
    				} else if (petLevel >= 60) {
    					colour = 0xBF7E4FC6; // Purple
    				} else if (petLevel >= 50) {
    					colour = 0xBF008AD8; // Light Blue
    				} else if (petLevel >= 40) {
    					colour = 0xBF0EAC35; // Green
    				} else if (petLevel >= 30) {
    					colour = 0xBFFFC400; // Yellow
    				} else if (petLevel >= 20) {
    					colour = 0xBFEF5230; // Orange
    				} else if (petLevel >= 10) {
    					colour = 0xBFD62440; // Red
    				} else {
    					colour = 0xBF999999; // Gray
    				}
    				Utils.drawOnSlot(inventory.inventorySlots.inventorySlots.size(), slot.xDisplayPosition, slot.yDisplayPosition, colour);
    			}
    		}
    	}
    }
    
    @SubscribeEvent
    public void onServerConnect(ClientConnectedToServerEvent event) {
        event.manager.channel().pipeline().addBefore("packet_handler", "danker_packet_handler", new PacketHandler());
        System.out.println("Added packet handler to channel pipeline.");
    }
    
    public void increaseSeaCreatures() {
    	if (LootCommand.empSCs != -1) {
    		LootCommand.empSCs++;
    	}
    	if (LootCommand.empSCsSession != -1) {
    		LootCommand.empSCsSession++;
    	}
    	// Only increment Yetis when in Jerry's Workshop
    	List<String> scoreboard = ScoreboardHandler.getSidebarLines();
    	for (String s : scoreboard) {
    		String sCleaned = ScoreboardHandler.cleanSB(s);
    		if (sCleaned.contains("Jerry's Workshop") || sCleaned.contains("Jerry Pond")) {
    			if (LootCommand.yetiSCs != -1) {
    				LootCommand.yetiSCs++;
    			}
    			if (LootCommand.yetiSCsSession != -1) {
    				LootCommand.yetiSCsSession++;
    			}
    		}
    	}
    	
		LootCommand.seaCreatures++;
		LootCommand.fishingMilestone++;
		LootCommand.seaCreaturesSession++;
		LootCommand.fishingMilestoneSession++;
		ConfigHandler.writeIntConfig("fishing", "seaCreature", LootCommand.seaCreatures);
		ConfigHandler.writeIntConfig("fishing", "milestone", LootCommand.fishingMilestone);
    	ConfigHandler.writeIntConfig("fishing", "empSC", LootCommand.empSCs);
    	ConfigHandler.writeIntConfig("fishing", "yetiSC", LootCommand.yetiSCs);
    	
    }
    
}