Initial (1.0-BETA)

18 files changed, 2756 insertions, 0 deletions

diff --git a/src/main/java/io/github/moulberry/notenoughupdates/LerpingFloat.java b/src/main/java/io/github/moulberry/notenoughupdates/LerpingFloat.java
new file mode 100644
index 00000000..e2cca0c0
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/LerpingFloat.java
@@ -0,0 +1,68 @@
+package io.github.moulberry.notenoughupdates;
+
+public class LerpingFloat {
+
+    private int timeSpent;
+    private long lastMillis;
+    private int timeToReachTarget;
+
+    private float targetValue;
+    private float lerpValue;
+
+    public LerpingFloat(float initialValue, int timeToReachTarget) {
+        this.targetValue = this.lerpValue = initialValue;
+        this.timeToReachTarget = timeToReachTarget;
+    }
+
+    public LerpingFloat(int initialValue) {
+        this(initialValue, 200);
+    }
+
+    public void tick() {
+        int lastTimeSpent = timeSpent;
+        this.timeSpent += System.currentTimeMillis() - lastMillis;
+
+        float lastDistPercentToTarget = lastTimeSpent/(float)timeToReachTarget;
+        float distPercentToTarget = timeSpent/(float)timeToReachTarget;
+        float fac = (1-lastDistPercentToTarget)/lastDistPercentToTarget;
+
+        float startValue = lerpValue - (targetValue - lerpValue)/fac;
+
+        float dist = targetValue - startValue;
+        if(dist == 0) return;
+
+        float oldLerpValue = lerpValue;
+        if(distPercentToTarget >= 1) {
+            lerpValue = targetValue;
+        } else {
+            lerpValue = startValue + dist*distPercentToTarget;
+        }
+
+        if(lerpValue == oldLerpValue) {
+            timeSpent = lastTimeSpent;
+        } else {
+            this.lastMillis = System.currentTimeMillis();
+        }
+    }
+
+    public void resetTimer() {
+        this.timeSpent = 0;
+        this.lastMillis = System.currentTimeMillis();
+    }
+
+    public void setTarget(float targetValue) {
+        this.targetValue = targetValue;
+    }
+
+    public void setValue(float value) {
+        this.targetValue = this.lerpValue = value;
+    }
+
+    public float getValue() {
+        return lerpValue;
+    }
+
+    public float getTarget() {
+        return targetValue;
+    }
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/LerpingInteger.java b/src/main/java/io/github/moulberry/notenoughupdates/LerpingInteger.java
new file mode 100644
index 00000000..2f21927a
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/LerpingInteger.java
@@ -0,0 +1,68 @@
+package io.github.moulberry.notenoughupdates;
+
+public class LerpingInteger {
+
+    private int timeSpent;
+    private long lastMillis;
+    private int timeToReachTarget;
+
+    private int targetValue;
+    private int lerpValue;
+
+    public LerpingInteger(int initialValue, int timeToReachTarget) {
+        this.targetValue = this.lerpValue = initialValue;
+        this.timeToReachTarget = timeToReachTarget;
+    }
+
+    public LerpingInteger(int initialValue) {
+        this(initialValue, 200);
+    }
+
+    public void tick() {
+        int lastTimeSpent = timeSpent;
+        this.timeSpent += System.currentTimeMillis() - lastMillis;
+
+        float lastDistPercentToTarget = lastTimeSpent/(float)timeToReachTarget;
+        float distPercentToTarget = timeSpent/(float)timeToReachTarget;
+        float fac = (1-lastDistPercentToTarget)/lastDistPercentToTarget;
+
+        int startValue = lerpValue - (int)((targetValue - lerpValue)/fac);
+
+        int dist = targetValue - startValue;
+        if(dist == 0) return;
+
+        int oldLerpValue = lerpValue;
+        if(distPercentToTarget >= 1) {
+            lerpValue = targetValue;
+        } else {
+            lerpValue = startValue + (int)(dist*distPercentToTarget);
+        }
+
+        if(lerpValue == oldLerpValue) {
+            timeSpent = lastTimeSpent;
+        } else {
+            this.lastMillis = System.currentTimeMillis();
+        }
+    }
+
+    public void resetTimer() {
+        this.timeSpent = 0;
+        this.lastMillis = System.currentTimeMillis();
+    }
+
+    public void setTarget(int targetValue) {
+        this.targetValue = targetValue;
+    }
+
+    public void setValue(int value) {
+        this.targetValue = this.lerpValue = value;
+    }
+
+    public int getValue() {
+        return lerpValue;
+    }
+
+    public int getTarget() {
+        return targetValue;
+    }
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/NEUIO.java b/src/main/java/io/github/moulberry/notenoughupdates/NEUIO.java
new file mode 100644
index 00000000..7e7091cf
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/NEUIO.java
@@ -0,0 +1,98 @@
+package io.github.moulberry.notenoughupdates;
+
+import org.kohsuke.github.*;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class NEUIO {
+
+    private final String accessToken;
+
+    public NEUIO(String accessToken) {
+        this.accessToken = accessToken;
+    }
+
+    /**
+     * Creates a new branch, commits to it with a single file change and submits a pull request from the new branch
+     * back to the master branch.
+     */
+    public boolean createNewRequest(String newBranchName, String prTitle, String prBody, String filename, String content) {
+        try {
+            GitHub github = new GitHubBuilder().withOAuthToken(accessToken).build();
+            System.out.println("Getting repo");
+
+            //https://github.com/Moulberry/NotEnoughUpdates-REPO
+            GHRepository repo = github.getRepositoryById("247692460");
+
+            System.out.println("Getting last commit");
+            String lastCommitSha = repo.getRef("heads/master").getObject().getSha();
+            System.out.println("Last master commit sha: " + lastCommitSha);
+
+            String lastTreeSha = repo.getCommit(lastCommitSha).getTree().getSha();
+
+            GHTreeBuilder tb = repo.createTree();
+            tb.baseTree(lastTreeSha);
+            tb.add(filename, content, false);
+            GHTree tree = tb.create();
+            System.out.println("Created new tree: " + tree.getSha());
+
+            GHCommitBuilder cb = repo.createCommit();
+            cb.message(prTitle);
+            cb.tree(tree.getSha());
+            cb.parent(lastCommitSha);
+            GHCommit commit = cb.create();
+            System.out.println("Created commit: " + commit.getSHA1());
+
+            repo.createRef("refs/heads/"+newBranchName, commit.getSHA1());
+            System.out.println("Set new branch head to commit.");
+
+            repo.createPullRequest(prTitle, newBranchName, "master", prBody);
+            return true;
+        } catch(IOException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * @param oldShas Map from filename (eg. BOW.json) to the sha in the local repository
+     * @return Map from filename to the new shas
+     */
+    public Map<String, String> getChangedItems(Map<String, String> oldShas) {
+        HashMap<String, String> changedFiles = new HashMap<>();
+        try {
+            GitHub github = new GitHubBuilder().withOAuthToken(accessToken).build();
+            GHRepository repo = github.getRepositoryById("247692460");
+
+            for(GHContent content : repo.getDirectoryContent("items")) {
+                String oldSha = oldShas.get(content.getName());
+                if(!content.getSha().equals(oldSha)) {
+                    changedFiles.put(content.getName(), content.getSha());
+                }
+            }
+        } catch(IOException e) { }
+        return changedFiles;
+    }
+
+    /**
+     * Takes set of filename (eg. BOW.json) and returns map from that filename to the individual download link.
+     */
+    public Map<String, String> getItemsDownload(Set<String> filename) {
+        HashMap<String, String> downloadUrls = new HashMap<>();
+        try {
+            GitHub github = new GitHubBuilder().withOAuthToken(accessToken).build();
+            GHRepository repo = github.getRepositoryById("247692460");
+
+            for(GHContent content : repo.getDirectoryContent("items")) {
+                if(filename.contains(content.getName())) {
+                    downloadUrls.put(content.getName(), content.getDownloadUrl());
+                }
+            }
+        } catch(IOException e) { }
+        return downloadUrls;
+    }
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/NEUManager.java b/src/main/java/io/github/moulberry/notenoughupdates/NEUManager.java
new file mode 100644
index 00000000..c6fab0f1
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/NEUManager.java
@@ -0,0 +1,627 @@
+package io.github.moulberry.notenoughupdates;
+
+import com.google.gson.*;
+import javafx.scene.control.Alert;
+import net.minecraft.client.Minecraft;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.JsonToNBT;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.nbt.NBTUtil;
+import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.Display;
+
+import javax.swing.*;
+import java.io.*;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+public class NEUManager {
+
+    public final NEUIO neuio;
+    public static final Gson gson = new GsonBuilder().setPrettyPrinting().create();
+
+    private TreeMap<String, JsonObject> itemMap = new TreeMap<>();
+
+    private TreeMap<String, Set<String>> tagWordMap = new TreeMap<>();
+    private TreeMap<String, HashMap<String, List<Integer>>> titleWordMap = new TreeMap<>();
+    private TreeMap<String, HashMap<String, List<Integer>>> loreWordMap = new TreeMap<>();
+
+    private File configLocation;
+    private File itemsLocation;
+    private File itemShaLocation;
+    private JsonObject itemShaConfig;
+    private File config;
+    private JsonObject configJson;
+
+    public NEUManager(NEUIO neuio, File configLocation) {
+        this.configLocation = configLocation;
+        this.neuio = neuio;
+
+        this.config = new File(configLocation, "config.json");
+        try {
+            config.createNewFile();
+            configJson = getJsonFromFile(config);
+            if(configJson == null) configJson = new JsonObject();
+        } catch(IOException e) { }
+
+        this.itemsLocation = new File(configLocation, "items");
+        itemsLocation.mkdir();
+
+        this.itemShaLocation = new File(configLocation, "itemSha.json");
+        try {
+            itemShaLocation.createNewFile();
+            itemShaConfig = getJsonFromFile(itemShaLocation);
+            if(itemShaConfig == null) itemShaConfig = new JsonObject();
+        } catch(IOException e) { }
+    }
+
+    /**
+     * Parses a file in to a JsonObject.
+     */
+    public JsonObject getJsonFromFile(File file) throws IOException {
+        InputStream in = new FileInputStream(file);
+        BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8));
+        JsonObject json = gson.fromJson(reader, JsonObject.class);
+        return json;
+    }
+
+    /**
+     * Some convenience methods for working with the config. Should probably switch to using a more sophisticated
+     * config system, but until we only use it for more than one value, this should be fine.
+     */
+    public void setAllowEditing(boolean allowEditing) {
+        try {
+            configJson.addProperty("allowEditing", allowEditing);
+            writeJson(configJson, config);
+        } catch(IOException e) {}
+    }
+
+    public boolean getAllowEditing() {
+        try {
+            return configJson.get("allowEditing").getAsBoolean();
+        } catch(Exception e) {}
+        return false;
+    }
+
+    /**
+     * Called when the game is first loaded. Compares the local repository to the github repository and handles
+     * the downloading of new/updated files. This then calls the "loadItem" method for every item in the local
+     * repository.
+     */
+    public void loadItemInformation() {
+        JOptionPane pane = new JOptionPane("Getting items to download from remote repository.");
+        JDialog dialog = pane.createDialog("NotEnoughUpdates Remote Sync");
+        dialog.setModal(false);
+        dialog.setVisible(true);
+
+        if(Display.isActive()) dialog.toFront();
+
+        HashMap<String, String> oldShas = new HashMap<>();
+        for(Map.Entry<String, JsonElement> entry : itemShaConfig.entrySet()) {
+            if(new File(itemsLocation, entry.getKey()+".json").exists()) {
+                oldShas.put(entry.getKey()+".json", entry.getValue().getAsString());
+            }
+        }
+        Map<String, String> changedFiles = neuio.getChangedItems(oldShas);
+        for(Map.Entry<String, String> changedFile : changedFiles.entrySet()) {
+            itemShaConfig.addProperty(changedFile.getKey().substring(0, changedFile.getKey().length()-5),
+                    changedFile.getValue());
+        }
+        try {
+            writeJson(itemShaConfig, itemShaLocation);
+        } catch(IOException e) {}
+
+        if(Display.isActive()) dialog.toFront();
+
+        if(changedFiles.size() <= 20) {
+            Map<String, String> downloads = neuio.getItemsDownload(changedFiles.keySet());
+
+            String startMessage = "NotEnoughUpdates: Syncing with remote repository (";
+            int downloaded = 0;
+
+            for(Map.Entry<String, String> entry : downloads.entrySet()) {
+                pane.setMessage(startMessage + (++downloaded) + "/" + downloads.size() + ")\nCurrent: " + entry.getKey());
+                dialog.pack();
+                dialog.setVisible(true);
+                if(Display.isActive()) dialog.toFront();
+
+                File item = new File(itemsLocation, entry.getKey());
+                try { item.createNewFile(); } catch(IOException e) { }
+                try(BufferedInputStream inStream = new BufferedInputStream(new URL(entry.getValue()).openStream());
+                    FileOutputStream fileOutputStream = new FileOutputStream(item)) {
+                    byte dataBuffer[] = new byte[1024];
+                    int bytesRead;
+                    while ((bytesRead = inStream.read(dataBuffer, 0, 1024)) != -1) {
+                        fileOutputStream.write(dataBuffer, 0, bytesRead);
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        } else {
+            //TODO: Store hard-coded value somewhere else
+            String dlUrl = "https://github.com/Moulberry/NotEnoughUpdates-REPO/archive/master.zip";
+
+            pane.setMessage("Downloading NEU Master Archive. (DL# >20)");
+            dialog.pack();
+            dialog.setVisible(true);
+            if(Display.isActive()) dialog.toFront();
+
+            File itemsZip = new File(configLocation, "neu-items-master.zip");
+            try { itemsZip.createNewFile(); } catch(IOException e) { }
+            try(BufferedInputStream inStream = new BufferedInputStream(new URL(dlUrl).openStream());
+                FileOutputStream fileOutputStream = new FileOutputStream(itemsZip)) {
+                byte dataBuffer[] = new byte[1024];
+                int bytesRead;
+                while ((bytesRead = inStream.read(dataBuffer, 0, 1024)) != -1) {
+                    fileOutputStream.write(dataBuffer, 0, bytesRead);
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            pane.setMessage("Unzipping NEU Master Archive.");
+            dialog.pack();
+            dialog.setVisible(true);
+            if(Display.isActive()) dialog.toFront();
+
+            unzipIgnoreFirstFolder(itemsZip.getAbsolutePath(), configLocation.getAbsolutePath());
+        }
+
+
+        dialog.dispose();
+
+        for(File f : itemsLocation.listFiles()) {
+            loadItem(f.getName().substring(0, f.getName().length()-5));
+        }
+    }
+
+    /**
+     * Loads the item in to the itemMap and also stores various words associated with this item
+     * in to titleWordMap and loreWordMap. These maps are used in the searching algorithm.
+     * @param internalName
+     */
+    private void loadItem(String internalName) {
+        try {
+            JsonObject json = getJsonFromFile(new File(itemsLocation, internalName + ".json"));
+            if(json == null) {
+                return;
+            }
+            itemMap.put(internalName, json);
+
+            if(json.has("displayname")) {
+                int wordIndex=0;
+                for(String str : json.get("displayname").getAsString().split(" ")) {
+                    str = clean(str);
+                    if(!titleWordMap.containsKey(str)) {
+                        titleWordMap.put(str, new HashMap<>());
+                    }
+                    if(!titleWordMap.get(str).containsKey(internalName)) {
+                        titleWordMap.get(str).put(internalName, new ArrayList<>());
+                    }
+                    titleWordMap.get(str).get(internalName).add(wordIndex);
+                    wordIndex++;
+                }
+            }
+
+            if(json.has("lore")) {
+                int wordIndex=0;
+                for(JsonElement element : json.get("lore").getAsJsonArray()) {
+                    for(String str : element.getAsString().split(" ")) {
+                        str = clean(str);
+                        if(!loreWordMap.containsKey(str)) {
+                            loreWordMap.put(str, new HashMap<>());
+                        }
+                        if(!loreWordMap.get(str).containsKey(internalName)) {
+                            loreWordMap.get(str).put(internalName, new ArrayList<>());
+                        }
+                        loreWordMap.get(str).get(internalName).add(wordIndex);
+                        wordIndex++;
+                    }
+                }
+            }
+        } catch(IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Searches a string for a query. This method is used to mimic the behaviour of the
+     * more complex map-based search function. This method is used for the chest-item-search feature.
+     */
+    public boolean searchString(String toSearch, String query) {
+        int lastMatch = -1;
+
+        toSearch = clean(toSearch).toLowerCase();
+        query = clean(query).toLowerCase();
+        String[] splitToSeach = toSearch.split(" ");
+        out:
+        for(String s : query.split(" ")) {
+            for(int i=0; i<splitToSeach.length; i++) {
+                if(lastMatch == -1 || lastMatch == i-1) {
+                    if (splitToSeach[i].startsWith(s)) {
+                        lastMatch = i;
+                        continue out;
+                    }
+                }
+            }
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Checks whether an itemstack matches a certain query, following the same rules implemented by the
+     * more complex map-based search function.
+     */
+    public boolean doesStackMatchSearch(ItemStack stack, String query) {
+        if(query.startsWith("title:")) {
+            query = query.substring(6);
+            return searchString(stack.getDisplayName(), query);
+        } else if(query.startsWith("desc:")) {
+            query = query.substring(5);
+            String lore = "";
+            NBTTagCompound tag = stack.getTagCompound();
+            if(tag != null) {
+                NBTTagCompound display = tag.getCompoundTag("display");
+                if (display.hasKey("Lore", 9)) {
+                    NBTTagList list = display.getTagList("Lore", 8);
+                    for (int i = 0; i < list.tagCount(); i++) {
+                        lore += list.getStringTagAt(i) + " ";
+                    }
+                }
+            }
+            return searchString(lore, query);
+        } else if(query.startsWith("id:")) {
+            query = query.substring(3);
+            String internalName = getInternalNameForItem(stack);
+            return query.equalsIgnoreCase(internalName);
+        } else {
+            boolean result = false;
+            if(!query.trim().contains(" ")) {
+                StringBuilder sb = new StringBuilder();
+                for(char c : query.toCharArray()) {
+                    sb.append(c).append(" ");
+                }
+                result = result || searchString(stack.getDisplayName(), sb.toString());
+            }
+            result = result || searchString(stack.getDisplayName(), query);
+
+            String lore = "";
+            NBTTagCompound tag = stack.getTagCompound();
+            if(tag != null) {
+                NBTTagCompound display = tag.getCompoundTag("display");
+                if (display.hasKey("Lore", 9)) {
+                    NBTTagList list = display.getTagList("Lore", 8);
+                    for (int i = 0; i < list.tagCount(); i++) {
+                        lore += list.getStringTagAt(i) + " ";
+                    }
+                }
+            }
+
+            result = result || searchString(lore, query);
+
+            return result;
+        }
+    }
+
+    /**
+     * Returns the name of items which match a certain search query.
+     */
+    public Set<String> search(String query) {
+        LinkedHashSet<String> results = new LinkedHashSet<>();
+        if(query.startsWith("title:")) {
+            query = query.substring(6);
+            results.addAll(new TreeSet<>(search(query, titleWordMap)));
+        } else if(query.startsWith("desc:")) {
+            query = query.substring(5);
+            results.addAll(new TreeSet<>(search(query, loreWordMap)));
+        } else if(query.startsWith("id:")) {
+            query = query.substring(3);
+            results.addAll(new TreeSet<>(subMapWithKeysThatAreSuffixes(query.toUpperCase(), itemMap).keySet()));
+        } else {
+            if(!query.trim().contains(" ")) {
+                StringBuilder sb = new StringBuilder();
+                for(char c : query.toCharArray()) {
+                    sb.append(c).append(" ");
+                }
+                results.addAll(new TreeSet<>(search(sb.toString(), titleWordMap)));
+            }
+            results.addAll(new TreeSet<>(search(query, titleWordMap)));
+            results.addAll(new TreeSet<>(search(query, loreWordMap)));
+        }
+        return results;
+    }
+
+    /**
+     * Splits a search query into an array of strings delimited by a space character. Then, matches the query to
+     * the start of words in the various maps (title & lore). The small query does not need to match the whole entry
+     * of the map, only the beginning. eg. "ench" and "encha" will both match "enchanted". All sub queries must
+     * follow a word matching the previous sub query. eg. "ench po" will match "enchanted pork" but will not match
+     * "pork enchanted".
+     */
+    private Set<String> search(String query, TreeMap<String, HashMap<String, List<Integer>>> wordMap) {
+        HashMap<String, List<Integer>> matches = null;
+
+        query = clean(query).toLowerCase();
+        for(String queryWord : query.split(" ")) {
+            HashMap<String, List<Integer>> matchesToKeep = new HashMap<>();
+            for(HashMap<String, List<Integer>> wordMatches : subMapWithKeysThatAreSuffixes(queryWord, wordMap).values()) {
+                if(wordMatches != null && !wordMatches.isEmpty()) {
+                    if(matches == null) {
+                        //Copy all wordMatches to titleMatches
+                        for(String internalname : wordMatches.keySet()) {
+                            if(!matchesToKeep.containsKey(internalname)) {
+                                matchesToKeep.put(internalname, new ArrayList<>());
+                            }
+                            matchesToKeep.get(internalname).addAll(wordMatches.get(internalname));
+                        }
+                    } else {
+                        for(String internalname : matches.keySet()) {
+                            if(wordMatches.containsKey(internalname)) {
+                                for(Integer newIndex : wordMatches.get(internalname)) {
+                                    if(matches.get(internalname).contains(newIndex-1)) {
+                                        if(!matchesToKeep.containsKey(internalname)) {
+                                            matchesToKeep.put(internalname, new ArrayList<>());
+                                        }
+                                        matchesToKeep.get(internalname).add(newIndex);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if(matchesToKeep.isEmpty()) return new HashSet<>();
+            matches = matchesToKeep;
+        }
+
+        return matches.keySet();
+    }
+
+    /**
+     * From https://stackoverflow.com/questions/10711494/get-values-in-treemap-whose-string-keys-start-with-a-pattern
+     */
+    public <T> Map<String, T> subMapWithKeysThatAreSuffixes(String prefix, NavigableMap<String, T> map) {
+        if ("".equals(prefix)) return map;
+        String lastKey = createLexicographicallyNextStringOfTheSameLenght(prefix);
+        return map.subMap(prefix, true, lastKey, false);
+    }
+
+    String createLexicographicallyNextStringOfTheSameLenght(String input) {
+        final int lastCharPosition = input.length()-1;
+        String inputWithoutLastChar = input.substring(0, lastCharPosition);
+        char lastChar = input.charAt(lastCharPosition) ;
+        char incrementedLastChar = (char) (lastChar + 1);
+        return inputWithoutLastChar+incrementedLastChar;
+    }
+
+    private String clean(String str) {
+        return str.replaceAll("(\u00a7.)|[^0-9a-zA-Z ]", "").toLowerCase().trim();
+    }
+
+    /**
+     * Takes an item stack and produces a JsonObject. This is used in the item editor.
+     */
+    public JsonObject getJsonForItem(ItemStack stack) {
+        NBTTagCompound tag = stack.getTagCompound() == null ? new NBTTagCompound() : stack.getTagCompound();
+
+        //Item lore
+        String[] lore = new String[0];
+        if(tag.hasKey("display", 10)) {
+            NBTTagCompound display = tag.getCompoundTag("display");
+
+            if(display.hasKey("Lore", 9)) {
+                NBTTagList list = display.getTagList("Lore", 8);
+                lore = new String[list.tagCount()];
+                for(int i=0; i<list.tagCount(); i++) {
+                    lore[i] = list.getStringTagAt(i);
+                }
+            }
+        }
+
+        if(stack.getDisplayName().endsWith(" Recipes")) {
+            stack.setStackDisplayName(stack.getDisplayName().substring(0, stack.getDisplayName().length()-8));
+        }
+
+        if(lore.length > 0 && (lore[lore.length-1].endsWith("Click to view recipes!") ||
+                lore[lore.length-1].endsWith("Click to view recipe!"))) {
+            String[] lore2 = new String[lore.length-2];
+            System.arraycopy(lore, 0, lore2, 0, lore.length-2);
+            lore = lore2;
+        }
+
+        JsonObject json = new JsonObject();
+        json.addProperty("itemid", stack.getItem().getRegistryName());
+        json.addProperty("displayname", stack.getDisplayName());
+        json.addProperty("nbttag", tag.toString());
+        json.addProperty("damage", stack.getItemDamage());
+
+        JsonArray jsonlore = new JsonArray();
+        for(String line : lore) {
+            jsonlore.add(new JsonPrimitive(line));
+        }
+        json.add("lore", jsonlore);
+
+        return json;
+    }
+
+    public String getInternalNameForItem(ItemStack stack) {
+        NBTTagCompound tag = stack.getTagCompound();
+        //Internal id
+        if(tag != null && tag.hasKey("ExtraAttributes", 10)) {
+            NBTTagCompound ea = tag.getCompoundTag("ExtraAttributes");
+
+            if(ea.hasKey("id", 8)) {
+                return ea.getString("id");
+            }
+        }
+        return null;
+    }
+
+    //Currently unused in production.
+    public void writeItemToFile(ItemStack stack) {
+        String internalname = getInternalNameForItem(stack);
+
+        if(internalname == null) {
+            return;
+        }
+
+        JsonObject json = getJsonForItem(stack);
+        json.addProperty("internalname", internalname);
+        json.addProperty("clickcommand", "viewrecipe");
+        json.addProperty("modver", NotEnoughUpdates.VERSION);
+
+        if(!json.has("internalname")) {
+            return;
+        }
+
+        try {
+            writeJson(json, new File(itemsLocation, internalname+".json"));
+        } catch (IOException e) {}
+
+        loadItem(internalname);
+    }
+
+    public JsonObject createItemJson(String internalname, String itemid, String displayname, String[] lore, String[] info,
+                                     String clickcommand, int damage, NBTTagCompound nbttag) {
+        if(internalname == null || internalname.isEmpty()) {
+            return null;
+        }
+
+        JsonObject json = new JsonObject();
+        json.addProperty("internalname", internalname);
+        json.addProperty("itemid", itemid);
+        json.addProperty("displayname", displayname);
+        json.addProperty("clickcommand", clickcommand);
+        json.addProperty("damage", damage);
+        json.addProperty("nbttag", nbttag.toString());
+        json.addProperty("modver", NotEnoughUpdates.VERSION);
+
+        if(info != null && info.length > 0) {
+            JsonArray jsoninfo = new JsonArray();
+            for (String line : info) {
+                jsoninfo.add(new JsonPrimitive(line));
+            }
+            json.add("info", jsoninfo);
+        }
+
+        JsonArray jsonlore = new JsonArray();
+        for(String line : lore) {
+            System.out.println("Lore:"+line);
+            jsonlore.add(new JsonPrimitive(line));
+        }
+        json.add("lore", jsonlore);
+
+        return json;
+    }
+
+    public boolean writeItemJson(String internalname, String itemid, String displayname, String[] lore, String[] info,
+                              String clickcommand, int damage, NBTTagCompound nbttag) {
+        JsonObject json = createItemJson(internalname, itemid, displayname, lore, info, clickcommand, damage, nbttag);
+        if(json == null) {
+            return false;
+        }
+
+        try {
+            writeJsonDefaultDir(json, internalname+".json");
+        } catch(IOException e) {
+            return false;
+        }
+
+        loadItem(internalname);
+        return true;
+    }
+
+    public boolean uploadItemJson(String internalname, String itemid, String displayname, String[] lore, String[] info,
+                                 String clickcommand, int damage, NBTTagCompound nbttag) {
+        JsonObject json = createItemJson(internalname, itemid, displayname, lore, info, clickcommand, damage, nbttag);
+        if(json == null) {
+            return false;
+        }
+
+        String username = Minecraft.getMinecraft().thePlayer.getName();
+        String newBranchName = UUID.randomUUID().toString().substring(0, 8) + "-" + internalname + "-" + username;
+        String prTitle = internalname + "-" + username;
+        String prBody = "Internal name: " + internalname + "\nSubmitted by: " + username;
+        String file = "items/"+internalname+".json";
+        if(!neuio.createNewRequest(newBranchName, prTitle, prBody, file, gson.toJson(json))) {
+            return false;
+        }
+
+        try {
+            writeJsonDefaultDir(json, internalname+".json");
+        } catch(IOException e) {
+            return false;
+        }
+
+        loadItem(internalname);
+        return true;
+    }
+
+    private void writeJson(JsonObject json, File file) throws IOException {
+        file.createNewFile();
+
+        try(BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8))) {
+            writer.write(gson.toJson(json));
+        }
+    }
+
+    private void writeJsonDefaultDir(JsonObject json, String filename) throws IOException {
+        File file = new File(itemsLocation, filename);
+        writeJson(json, file);
+    }
+
+    public TreeMap<String, JsonObject> getItemInformation() {
+        return itemMap;
+    }
+
+    /**
+     * Stolen from https://www.journaldev.com/960/java-unzip-file-example
+     */
+    private static void unzipIgnoreFirstFolder(String zipFilePath, String destDir) {
+        File dir = new File(destDir);
+        // create output directory if it doesn't exist
+        if(!dir.exists()) dir.mkdirs();
+        FileInputStream fis;
+        //buffer for read and write data to file
+        byte[] buffer = new byte[1024];
+        try {
+            fis = new FileInputStream(zipFilePath);
+            ZipInputStream zis = new ZipInputStream(fis);
+            ZipEntry ze = zis.getNextEntry();
+            while(ze != null){
+                if(!ze.isDirectory()) {
+                    String fileName = ze.getName();
+                    fileName = fileName.substring(fileName.split("/")[0].length()+1);
+                    File newFile = new File(destDir + File.separator + fileName);
+                    //create directories for sub directories in zip
+                    new File(newFile.getParent()).mkdirs();
+                    FileOutputStream fos = new FileOutputStream(newFile);
+                    int len;
+                    while ((len = zis.read(buffer)) > 0) {
+                        fos.write(buffer, 0, len);
+                    }
+                    fos.close();
+                }
+                //close this ZipEntry
+                zis.closeEntry();
+                ze = zis.getNextEntry();
+            }
+            //close last ZipEntry
+            zis.closeEntry();
+            zis.close();
+            fis.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/NEUOverlay.java b/src/main/java/io/github/moulberry/notenoughupdates/NEUOverlay.java
new file mode 100644
index 00000000..b86ad932
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/NEUOverlay.java
@@ -0,0 +1,804 @@
+package io.github.moulberry.notenoughupdates;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.mojang.realmsclient.gui.ChatFormatting;
+import io.github.moulberry.notenoughupdates.itemeditor.NEUItemEditor;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.*;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.renderer.*;
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.*;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fml.client.config.GuiUtils;
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.input.Mouse;
+import org.lwjgl.opengl.GL11;
+
+import java.awt.*;
+import java.lang.reflect.Field;
+import java.util.*;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class NEUOverlay extends Gui {
+
+    private NEUManager manager;
+
+    private ResourceLocation itemPaneTabArrow = new ResourceLocation("notenoughupdates:item_pane_tab_arrow.png");
+    private ResourceLocation prev = new ResourceLocation("notenoughupdates:prev_pow2.png");
+    private ResourceLocation next = new ResourceLocation("notenoughupdates:next_pow2.png");
+    private ResourceLocation item_edit = new ResourceLocation("notenoughupdates:item_edit.png");
+
+    private final int searchBarXSize = 200;
+    private final int searchBarYOffset = 10;
+    private final int searchBarYSize = 40;
+    private final int searchBarPadding = 2;
+
+    private final int boxPadding = 15;
+    private final int itemPadding = 4;
+    private final int itemSize = 16;
+
+    private String informationPaneTitle;
+    private String[] informationPane;
+
+    private boolean allowItemEditing;
+
+    private LinkedHashMap<String, JsonObject> searchedItems = null;
+
+    private boolean itemPaneOpen = false;
+
+    private int page = 0;
+
+    private LerpingFloat itemPaneOffsetFactor = new LerpingFloat(1);
+    private LerpingInteger itemPaneTabOffset = new LerpingInteger(20, 50);
+    private LerpingFloat infoPaneOffsetFactor = new LerpingFloat(0);
+
+    private boolean searchMode = false;
+    private long millisLastLeftClick = 0;
+
+    private boolean searchBarHasFocus = false;
+    GuiTextField textField = new GuiTextField(0, null, 0, 0, 0, 0);
+
+    public NEUOverlay(NEUManager manager) {
+        this.manager = manager;
+        textField.setFocused(true);
+        textField.setCanLoseFocus(false);
+
+        allowItemEditing = manager.getAllowEditing();
+    }
+
+    public void reset() {
+        searchBarHasFocus = false;
+        itemPaneOpen = searchMode;
+        itemPaneOffsetFactor.setValue(1);
+        itemPaneTabOffset.setValue(20);
+    }
+
+    /**
+     * Handles the mouse input, cancelling the forge event if a NEU gui element is clicked.
+     */
+    public boolean mouseInput() {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int width = scaledresolution.getScaledWidth();
+        int height = scaledresolution.getScaledHeight();
+
+        int mouseX = Mouse.getX() / scaledresolution.getScaleFactor();
+        int mouseY = height - Mouse.getY() / scaledresolution.getScaleFactor();
+
+        //Unfocuses the search bar by default. Search bar is focused if the click is on the bar itself.
+        if(Mouse.getEventButtonState()) setSearchBarFocus(false);
+
+        //Item selection (right) gui
+        if(mouseX > width*itemPaneOffsetFactor.getValue()) {
+            if(!Mouse.getEventButtonState()) return true; //End early if the mouse isn't pressed, but still cancel event.
+
+            AtomicBoolean clickedItem = new AtomicBoolean(false);
+            iterateItemSlots((x, y) -> {
+                if(mouseX >= x-1 && mouseX <= x+itemSize+1) {
+                    if(mouseY >= y-1 && mouseY <= y+itemSize+1) {
+                        clickedItem.set(true);
+                        //TODO: Do something when clicking on items :)
+                        int id = getSlotId(x, y);
+                        JsonObject item = getSearchedItemPage(id);
+                        if (item != null) {
+                            if(item.has("clickcommand") && Mouse.getEventButton() == 0) {
+                                String clickcommand = item.get("clickcommand").getAsString();
+
+                                if(clickcommand.equals("viewrecipe")) {
+                                    Minecraft.getMinecraft().thePlayer.sendChatMessage(
+                                            "/" + clickcommand + " " + item.get("internalname").getAsString().toUpperCase());
+                                } else if(clickcommand.equals("viewpotion")) {
+
+                                    Minecraft.getMinecraft().thePlayer.sendChatMessage(
+                                            "/" + clickcommand + " " + item.get("internalname").getAsString().toLowerCase());
+                                }
+                            } else if(item.has("info") && Mouse.getEventButton() == 1) {
+                                JsonArray lore = item.get("info").getAsJsonArray();
+                                String[] loreA = new String[lore.size()];
+                                for(int i=0; i<lore.size(); i++) loreA[i] = lore.get(i).getAsString();
+                                displayInformationPane(item.get("displayname").getAsString(), loreA);
+                            } else if(Mouse.getEventButton() == 3) {
+                                textField.setText("itemid:"+item.get("internalname").getAsString());
+                            }
+                        }
+                    }
+                }
+            });
+            if(!clickedItem.get()) {
+                int leftSide = (int)(width*itemPaneOffsetFactor.getValue());
+
+                if(mouseY > boxPadding && mouseY < boxPadding+searchBarYSize/scaledresolution.getScaleFactor()) {
+                    int leftPrev = leftSide+boxPadding+getItemBoxXPadding();
+                    if(mouseX > leftPrev && mouseX < leftPrev+120/scaledresolution.getScaleFactor()) { //"Previous" button
+                        page--;
+                    }
+                    int rightNext = leftSide+width/3-boxPadding-getItemBoxXPadding();
+                    if(mouseX > rightNext-120/scaledresolution.getScaleFactor() && mouseX < rightNext) {
+                        page++;
+                    }
+                }
+            }
+            return true;
+        }
+
+        //Search bar
+        if(mouseX >= width/2 - searchBarXSize/2 && mouseX <= width/2 + searchBarXSize/2) {
+            if(mouseY >= height - searchBarYOffset - searchBarYSize/scaledresolution.getScaleFactor() &&
+                    mouseY <= height - searchBarYOffset) {
+                if(Mouse.getEventButtonState()) {
+                    setSearchBarFocus(true);
+                    if(Mouse.getEventButton() == 1) { //Right mouse button down
+                        textField.setText("");
+                        updateSearch();
+                    } else {
+                        if(System.currentTimeMillis() - millisLastLeftClick < 300) {
+                            searchMode = !searchMode;
+                        }
+                        textField.setCursorPosition(getClickedIndex(mouseX, mouseY));
+                        millisLastLeftClick = System.currentTimeMillis();
+                    }
+                }
+                return true;
+            }
+        }
+
+        int paddingUnscaled = searchBarPadding/scaledresolution.getScaleFactor();
+        int topTextBox = height - searchBarYOffset - searchBarYSize/scaledresolution.getScaleFactor();
+        int iconSize = searchBarYSize/scaledresolution.getScaleFactor()+paddingUnscaled*2;
+        if(paddingUnscaled < 1) paddingUnscaled = 1;
+        if(mouseX > width/2 + searchBarXSize/2 + paddingUnscaled*6 &&
+                mouseX < width/2 + searchBarXSize/2 + paddingUnscaled*6 + iconSize) {
+            if(mouseY > topTextBox - paddingUnscaled && mouseY < topTextBox - paddingUnscaled + iconSize) {
+                if(Mouse.getEventButtonState()) {
+                    allowItemEditing = !allowItemEditing;
+                    manager.setAllowEditing(allowItemEditing);
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public void displayInformationPane(String title, String[] info) {
+        informationPaneTitle = title;
+
+        if(info == null || info.length == 0) {
+            informationPane = new String[]{"\u00A77No additional information."};
+        } else {
+            informationPane = info;
+        }
+        infoPaneOffsetFactor.setTarget(1/3f);
+        infoPaneOffsetFactor.resetTimer();
+    }
+
+    public int getClickedIndex(int mouseX, int mouseY) {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int width = scaledresolution.getScaledWidth();
+        int height = scaledresolution.getScaledHeight();
+
+        int xComp = mouseX - (width/2 - searchBarXSize/2 + 5);
+
+        String trimmed = Minecraft.getMinecraft().fontRendererObj.trimStringToWidth(textField.getText(), xComp);
+        int linePos = trimmed.length();
+        if(linePos != textField.getText().length()) {
+            char after = textField.getText().charAt(linePos);
+            int trimmedWidth = Minecraft.getMinecraft().fontRendererObj.getStringWidth(trimmed);
+            int charWidth = Minecraft.getMinecraft().fontRendererObj.getCharWidth(after);
+            if(trimmedWidth + charWidth/2 < xComp-5) {
+                linePos++;
+            }
+        }
+        return linePos;
+    }
+
+    public void setSearchBarFocus(boolean focus) {
+        if(focus) {
+            itemPaneOpen = true;
+        }
+        searchBarHasFocus = focus;
+    }
+
+    /**
+     * Handles the keyboard input, cancelling the forge event if the search bar has focus.
+     */
+    public boolean keyboardInput() {
+        if(searchBarHasFocus && Keyboard.getEventKey() == 1 && Keyboard.getEventKeyState()) {
+            searchBarHasFocus = false;
+            if(!textField.getText().isEmpty()) {
+                return true;
+            }
+        }
+
+        if(searchBarHasFocus && Keyboard.getEventKeyState()) {
+            if(textField.textboxKeyTyped(Keyboard.getEventCharacter(), Keyboard.getEventKey())) {
+                if(textField.getText().isEmpty()) {
+                    searchedItems = null;
+                } else {
+                    updateSearch();
+                }
+            }
+        }
+
+        if(allowItemEditing) {
+            if(Keyboard.getEventCharacter() == 'k' && Keyboard.getEventKeyState()) {
+                Slot slot = ((GuiContainer)Minecraft.getMinecraft().currentScreen).getSlotUnderMouse();
+                if(slot != null) {
+                    ItemStack hover = slot.getStack();
+                    if(hover != null) {
+                        Minecraft.getMinecraft().displayGuiScreen(new NEUItemEditor(manager,
+                                manager.getInternalNameForItem(hover), manager.getJsonForItem(hover)));
+                        //manager.writeItemToFile(hover);
+                    }
+                } else {
+                    ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+                    int height = scaledresolution.getScaledHeight();
+
+                    int mouseX = Mouse.getX() / scaledresolution.getScaleFactor();
+                    int mouseY = height - Mouse.getY() / scaledresolution.getScaleFactor();
+
+                    iterateItemSlots((x, y) -> {
+                        if (mouseX >= x - 1 && mouseX <= x + itemSize + 1) {
+                            if (mouseY >= y - 1 && mouseY <= y + itemSize + 1) {
+                                int id = getSlotId(x, y);
+                                JsonObject item = getSearchedItemPage(id);
+
+                                if(item != null) {
+                                    Minecraft.getMinecraft().displayGuiScreen(new NEUItemEditor(manager,
+                                            item.get("internalname").getAsString(), item));
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+        }
+
+        return searchBarHasFocus; //Cancels keyboard events if the search bar has focus
+    }
+
+    public void updateSearch() {
+        if(searchedItems==null) searchedItems = new LinkedHashMap<>();
+        searchedItems.clear();
+        Set<String> itemsMatch = manager.search(textField.getText());
+        for(String item : itemsMatch) {
+            searchedItems.put(item, manager.getItemInformation().get(item));
+        }
+    }
+
+    public Collection<JsonObject> getSearchedItems() {
+        if(searchedItems==null) {
+            return manager.getItemInformation().values();
+        } else {
+            return searchedItems.values();
+        }
+    }
+
+    public JsonObject getSearchedItemPage(int index) {
+        if(index < getSlotsXSize()*getSlotsYSize()) {
+            int actualIndex = index + getSlotsXSize()*getSlotsYSize()*page;
+            if(actualIndex < getSearchedItems().size()) {
+                return (JsonObject) (getSearchedItems().toArray()[actualIndex]);
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    public int getItemBoxXPadding() {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int width = scaledresolution.getScaledWidth();
+        return (((int)(width-width*itemPaneOffsetFactor.getValue())-2*boxPadding)%(itemSize+itemPadding)+itemPadding)/2;
+    }
+
+    /**
+     * Iterates through all the item slots in the right panel and calls a biconsumer for each slot with
+     * arguments equal to the slot's x and y position respectively. This is used in order to prevent
+     * code duplication issues.
+     */
+    public void iterateItemSlots(BiConsumer<Integer, Integer> itemSlotConsumer) {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int width = scaledresolution.getScaledWidth();
+        int height = scaledresolution.getScaledHeight();
+
+        int itemBoxXPadding = getItemBoxXPadding();
+        int itemBoxYPadding = ((height-2*boxPadding)%(itemSize+itemPadding)+itemPadding)/2;
+
+        int xStart = (int)(width*itemPaneOffsetFactor.getValue())+boxPadding+itemBoxXPadding;
+        int yStart = boxPadding+searchBarYSize/scaledresolution.getScaleFactor()+itemBoxYPadding;
+        int xEnd = (int)(width*itemPaneOffsetFactor.getValue())+width/3-boxPadding-itemSize;
+        int yEnd = height-boxPadding-itemSize;
+
+        //Render the items, displaying the tooltip if the cursor is over the item
+        for(int y = yStart; y < yEnd; y+=itemSize+itemPadding) {
+            for(int x = xStart; x < xEnd; x+=itemSize+itemPadding) {
+                itemSlotConsumer.accept(x, y);
+            }
+        }
+    }
+
+    /**
+     * Calculates the number of horizontal item slots.
+     */
+    public int getSlotsXSize() {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int width = scaledresolution.getScaledWidth();
+
+        int itemBoxXPadding = (((int)(width-width*itemPaneOffsetFactor.getValue())-2*boxPadding)%(itemSize+itemPadding)+itemPadding)/2;
+        int xStart = (int)(width*itemPaneOffsetFactor.getValue())+boxPadding+itemBoxXPadding;
+        int xEnd = (int)(width*itemPaneOffsetFactor.getValue())+width/3-boxPadding-itemSize;
+
+        return (int)Math.ceil((xEnd - xStart)/((float)(itemSize+itemPadding)));
+    }
+
+    /**
+     * Calculates the number of vertical item slots.
+     */
+    public int getSlotsYSize() {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int height = scaledresolution.getScaledHeight();
+
+        int itemBoxYPadding = ((height-2*boxPadding)%(itemSize+itemPadding)+itemPadding)/2;
+        int yStart = boxPadding+searchBarYSize/scaledresolution.getScaleFactor()+itemBoxYPadding;
+        int yEnd = height-boxPadding-itemSize;
+
+        return (int)Math.ceil((yEnd - yStart)/((float)(itemSize+itemPadding)));
+    }
+
+    public int getMaxPages() {
+        if(getSearchedItems().size() == 0) return 1;
+        return (int)Math.ceil(getSearchedItems().size()/(float)getSlotsYSize()/getSlotsXSize());
+    }
+
+    /**
+     * Takes in the x and y coordinates of a slot and returns the id of that slot.
+     */
+    public int getSlotId(int x, int y) {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int width = scaledresolution.getScaledWidth();
+        int height = scaledresolution.getScaledHeight();
+
+        int itemBoxXPadding = (((int)(width-width*itemPaneOffsetFactor.getValue())-2*boxPadding)%(itemSize+itemPadding)+itemPadding)/2;
+        int itemBoxYPadding = ((height-2*boxPadding)%(itemSize+itemPadding)+itemPadding)/2;
+
+        int xStart = (int)(width*itemPaneOffsetFactor.getValue())+boxPadding+itemBoxXPadding;
+        int yStart = boxPadding+searchBarYSize/scaledresolution.getScaleFactor()+itemBoxYPadding;
+
+        int xIndex = (x-xStart)/(itemSize+itemPadding);
+        int yIndex = (y-yStart)/(itemSize+itemPadding);
+        return xIndex + yIndex*getSlotsXSize();
+    }
+
+    /**
+     * Renders the search bar, item selection (right) and item info (left) gui elements.
+     */
+    public void render(float partialTicks, int mouseX, int mouseY) {
+        FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int width = scaledresolution.getScaledWidth();
+        int height = scaledresolution.getScaledHeight();
+
+        if(searchMode && textField.getText().length() > 0) {
+            try {
+                GuiContainer inv = (GuiContainer) Minecraft.getMinecraft().currentScreen;
+                Field guiLeft = GuiContainer.class.getDeclaredField("field_147003_i");
+                Field guiTop = GuiContainer.class.getDeclaredField("field_147009_r");
+                guiLeft.setAccessible(true);
+                guiTop.setAccessible(true);
+                int guiLeftI = (int) guiLeft.get(inv);
+                int guiTopI = (int) guiTop.get(inv);
+
+                GL11.glPushMatrix();
+                GL11.glTranslatef(0, 0, 300);
+                int overlay = new Color(50, 50, 50, 150).getRGB();
+                for(Slot slot : inv.inventorySlots.inventorySlots) {
+                    if(slot.getStack() == null || !manager.doesStackMatchSearch(slot.getStack(), textField.getText())) {
+                        drawRect(guiLeftI+slot.xDisplayPosition, guiTopI+slot.yDisplayPosition,
+                                guiLeftI+slot.xDisplayPosition+16, guiTopI+slot.yDisplayPosition+16,
+                                overlay);
+                    }
+                }
+                if(inv.getSlotUnderMouse() != null) {
+                    ItemStack stack = inv.getSlotUnderMouse().getStack();
+                    if(stack != null) {
+                        List<String> list = stack.getTooltip(Minecraft.getMinecraft().thePlayer,
+                                Minecraft.getMinecraft().gameSettings.advancedItemTooltips);
+
+                        for (int i = 0; i < list.size(); ++i){
+                            if (i == 0){
+                                list.set(i, stack.getRarity().rarityColor + (String)list.get(i));
+                            } else {
+                                list.set(i, EnumChatFormatting.GRAY + (String)list.get(i));
+                            }
+                        }
+
+                        GuiUtils.drawHoveringText(list, mouseX, mouseY, width, height, -1, Minecraft.getMinecraft().fontRendererObj);
+                    }
+                }
+                GL11.glPopMatrix();
+            } catch (NoSuchFieldException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+
+        if(itemPaneOpen) {
+            if(itemPaneTabOffset.getValue() == 0) {
+                if(itemPaneOffsetFactor.getTarget() != 2/3f) {
+                    itemPaneOffsetFactor.setTarget(2/3f);
+                    itemPaneOffsetFactor.resetTimer();
+                }
+            } else {
+                if(itemPaneTabOffset.getTarget() != 0) {
+                    itemPaneTabOffset.setTarget(0);
+                    itemPaneTabOffset.resetTimer();
+                }
+            }
+        } else {
+            if(itemPaneOffsetFactor.getValue() == 1) {
+                if(itemPaneTabOffset.getTarget() != 20) {
+                    itemPaneTabOffset.setTarget(20);
+                    itemPaneTabOffset.resetTimer();
+                }
+            } else {
+                if(itemPaneOffsetFactor.getTarget() != 1f) {
+                    itemPaneOffsetFactor.setTarget(1f);
+                    itemPaneOffsetFactor.resetTimer();
+                }
+            }
+        }
+
+        itemPaneOffsetFactor.tick();
+        itemPaneTabOffset.tick();
+        infoPaneOffsetFactor.tick();
+
+        if(page > getMaxPages()-1) page = getMaxPages()-1;
+        if(page < 0) page = 0;
+
+        GlStateManager.disableLighting();
+
+        /**
+         * Search bar
+         */
+        int paddingUnscaled = searchBarPadding/scaledresolution.getScaleFactor();
+        if(paddingUnscaled < 1) paddingUnscaled = 1;
+
+        int topTextBox = height - searchBarYOffset - searchBarYSize/scaledresolution.getScaleFactor();
+
+        //Search bar background
+        drawRect(width/2 - searchBarXSize/2 - paddingUnscaled,
+                topTextBox - paddingUnscaled,
+                width/2 + searchBarXSize/2 + paddingUnscaled,
+                height - searchBarYOffset + paddingUnscaled, searchMode ? Color.YELLOW.getRGB() : Color.WHITE.getRGB());
+        drawRect(width/2 - searchBarXSize/2,
+                topTextBox,
+                width/2 + searchBarXSize/2,
+                height - searchBarYOffset, Color.BLACK.getRGB());
+
+        //Item editor enable button
+        int iconSize = searchBarYSize/scaledresolution.getScaleFactor()+paddingUnscaled*2;
+        Minecraft.getMinecraft().getTextureManager().bindTexture(item_edit);
+        drawRect(width/2 + searchBarXSize/2 + paddingUnscaled*6,
+                topTextBox - paddingUnscaled,
+                width/2 + searchBarXSize/2 + paddingUnscaled*6 + iconSize,
+                topTextBox - paddingUnscaled + iconSize, Color.WHITE.getRGB());
+
+        drawRect(width/2 + searchBarXSize/2 + paddingUnscaled*7,
+                topTextBox,
+                width/2 + searchBarXSize/2 + paddingUnscaled*5 + iconSize,
+                topTextBox - paddingUnscaled*2 + iconSize, allowItemEditing ? Color.GREEN.getRGB() : Color.RED.getRGB());
+        GlStateManager.color(1f, 1f, 1f, 1f);
+        drawTexturedRect(width/2 + searchBarXSize/2 + paddingUnscaled*6, topTextBox - paddingUnscaled, iconSize, iconSize);
+        GlStateManager.bindTexture(0);
+
+        if(mouseX > width/2 + searchBarXSize/2 + paddingUnscaled*6 &&
+                mouseX < width/2 + searchBarXSize/2 + paddingUnscaled*6 + iconSize) {
+            if(mouseY > topTextBox - paddingUnscaled && mouseY < topTextBox - paddingUnscaled + iconSize) {
+                GuiUtils.drawHoveringText(Arrays.asList(
+                        EnumChatFormatting.GOLD.toString()+EnumChatFormatting.BOLD+"Enable item editing",
+                        EnumChatFormatting.RED+"Warning: "+EnumChatFormatting.YELLOW+"Uploading fake, " +
+                                "misinformative or misleading information using the item editor may result in your " +
+                                "account being banned from using this mod.",
+                        EnumChatFormatting.GREEN.toString()+EnumChatFormatting.BOLD+"Press k on an any item to use the item editor."),
+                        mouseX, mouseY, width, height, 250, Minecraft.getMinecraft().fontRendererObj);
+                GlStateManager.disableLighting();
+            }
+        }
+
+        //Search bar text
+        fr.drawString(textField.getText(), width/2 - searchBarXSize/2 + 5,
+                topTextBox+(searchBarYSize/scaledresolution.getScaleFactor()-8)/2, Color.WHITE.getRGB());
+
+        //Determines position of cursor. Cursor blinks on and off every 500ms.
+        if(searchBarHasFocus && System.currentTimeMillis()%1000>500) {
+            String textBeforeCursor = textField.getText().substring(0, textField.getCursorPosition());
+            int textBeforeCursorWidth = fr.getStringWidth(textBeforeCursor);
+            drawRect(width/2 - searchBarXSize/2 + 5 + textBeforeCursorWidth,
+                    topTextBox+(searchBarYSize/scaledresolution.getScaleFactor()-8)/2-1,
+                    width/2 - searchBarXSize/2 + 5 + textBeforeCursorWidth+1,
+                    topTextBox+(searchBarYSize/scaledresolution.getScaleFactor()-8)/2+9, Color.WHITE.getRGB());
+        }
+
+        String selectedText = textField.getSelectedText();
+        if(!selectedText.isEmpty()) {
+            int selectionWidth = fr.getStringWidth(selectedText);
+
+            int leftIndex = textField.getCursorPosition() < textField.getSelectionEnd() ?
+                    textField.getCursorPosition() : textField.getSelectionEnd();
+            String textBeforeSelection = textField.getText().substring(0, leftIndex);
+            int textBeforeSelectionWidth = fr.getStringWidth(textBeforeSelection);
+
+            drawRect(width/2 - searchBarXSize/2 + 5 + textBeforeSelectionWidth,
+                    topTextBox+(searchBarYSize/scaledresolution.getScaleFactor()-8)/2-1,
+                    width/2 - searchBarXSize/2 + 5 + textBeforeSelectionWidth + selectionWidth,
+                    topTextBox+(searchBarYSize/scaledresolution.getScaleFactor()-8)/2+9, Color.LIGHT_GRAY.getRGB());
+
+            fr.drawString(selectedText,
+                    width/2 - searchBarXSize/2 + 5 + textBeforeSelectionWidth,
+                    topTextBox+(searchBarYSize/scaledresolution.getScaleFactor()-8)/2, Color.BLACK.getRGB());
+        }
+
+
+        /**
+         * Item selection (right) gui element rendering
+         */
+        Color bg = new Color(128, 128, 128, 50);
+        int leftSide = (int)(width*itemPaneOffsetFactor.getValue());
+        int rightSide = leftSide+width/3-boxPadding-getItemBoxXPadding();
+        drawRect(leftSide+boxPadding-5, boxPadding-5,
+                leftSide+width/3-boxPadding+5, height-boxPadding+5, bg.getRGB());
+
+        drawRect(leftSide+boxPadding+getItemBoxXPadding()-1, boxPadding,
+                rightSide+1,
+                boxPadding+searchBarYSize/scaledresolution.getScaleFactor(), Color.GRAY.getRGB());
+
+        Minecraft.getMinecraft().getTextureManager().bindTexture(prev);
+        GlStateManager.color(1f, 1f, 1f, 1f);
+        drawTexturedRect(leftSide+boxPadding+getItemBoxXPadding(), boxPadding,
+                120/scaledresolution.getScaleFactor(), searchBarYSize/scaledresolution.getScaleFactor());
+        GlStateManager.bindTexture(0);
+
+
+        Minecraft.getMinecraft().getTextureManager().bindTexture(next);
+        GlStateManager.color(1f, 1f, 1f, 1f);
+        drawTexturedRect(rightSide-120/scaledresolution.getScaleFactor(), boxPadding,
+                120/scaledresolution.getScaleFactor(), searchBarYSize/scaledresolution.getScaleFactor());
+        GlStateManager.bindTexture(0);
+
+        int offset = 1;
+        if(scaledresolution.getScaleFactor()==4) offset = 0;
+
+        String pageText = EnumChatFormatting.BOLD+"Page: " + (page+1) + "/" + getMaxPages();
+        fr.drawString(pageText, leftSide+width/6-fr.getStringWidth(pageText)/2-1,
+                boxPadding+(searchBarYSize/scaledresolution.getScaleFactor())/2-4+offset, Color.BLACK.getRGB());
+
+        //Tab
+        Minecraft.getMinecraft().getTextureManager().bindTexture(itemPaneTabArrow);
+        GlStateManager.color(1f, 1f, 1f, 0.3f);
+        drawTexturedRect(width-itemPaneTabOffset.getValue(), height/2 - 50, 20, 100);
+        GlStateManager.bindTexture(0);
+
+        if(mouseX > width-itemPaneTabOffset.getValue() && mouseY > height/2 - 50
+                    && mouseY < height/2 + 50) {
+            itemPaneOpen = true;
+        }
+
+        //Atomic integer used so that below lambda doesn't complain about non-effectively-final variable
+        AtomicReference<JsonObject> tooltipToDisplay = new AtomicReference<>(null);
+
+        //Iterate through all item slots and display the appropriate item
+        iterateItemSlots((x, y) -> {
+            int id = getSlotId(x, y);
+            JsonObject json = getSearchedItemPage(id);
+            if(json == null) {
+                return;
+            }
+
+            drawRect(x-1, y-1, x+itemSize+1, y+itemSize+1, Color.GRAY.getRGB());
+            ItemStack stack = new ItemStack(Item.itemRegistry.getObject(
+                    new ResourceLocation(json.get("itemid").getAsString())));
+
+            if(stack.getItem() == null) {
+                stack = new ItemStack(Items.diamond, 1, 10); //Purple broken texture item
+            } else {
+                if(json.has("damage")) {
+                    stack.setItemDamage(json.get("damage").getAsInt());
+                }
+
+                if(json.has("nbttag")) {
+                    try {
+                        NBTTagCompound tag = JsonToNBT.getTagFromJson(json.get("nbttag").getAsString());
+                        stack.setTagCompound(tag);
+                    } catch(NBTException e) {
+                    }
+                }
+            }
+
+            //Integer.toString(getSlotId(x, y))
+            drawItemStack(stack, x, y, null);
+
+            if(mouseX > x-1 && mouseX < x+itemSize+1) {
+                if(mouseY > y-1 && mouseY < y+itemSize+1) {
+                    tooltipToDisplay.set(json);
+                }
+            }
+        });
+
+        //Render tooltip
+        JsonObject json = tooltipToDisplay.get();
+        if(json != null) {
+            List<String> text = new ArrayList<>();
+            text.add(json.get("displayname").getAsString());
+            JsonArray lore = json.get("lore").getAsJsonArray();
+            for(int i=0; i<lore.size(); i++) {
+                text.add(lore.get(i).getAsString());
+            }
+
+            boolean hasClick = false;
+            boolean hasInfo = false;
+            if(json.has("clickcommand") && !json.get("clickcommand").getAsString().isEmpty()) {
+                hasClick = true;
+            }
+            if(json.has("info") && json.get("info").getAsJsonArray().size() > 0) {
+                hasInfo = true;
+            }
+
+            if(hasClick || hasInfo) text.add("");
+            if(hasClick) text.add("\u00A7e\u00A7lLeft click to view recipe!");
+            if(hasInfo) text.add("\u00A7e\u00A7lRight click to view additional information!");
+
+            GuiUtils.drawHoveringText(text, mouseX, mouseY, width, height, -1, fr);
+            GlStateManager.disableLighting();
+        }
+
+        /**
+         * Item info (left) gui element rendering
+         */
+
+        rightSide = (int)(width*getInfoPaneOffsetFactor());
+        leftSide = rightSide - width/3;
+
+        drawRect(leftSide+boxPadding-5, boxPadding-5, rightSide-boxPadding+5, height-boxPadding+5, bg.getRGB());
+        if(informationPane != null && informationPaneTitle != null) {
+            int titleLen = fr.getStringWidth(informationPaneTitle);
+            fr.drawString(informationPaneTitle, (leftSide+rightSide-titleLen)/2, boxPadding + 5, Color.WHITE.getRGB());
+
+            int yOff = 20;
+            for(int i=0; i<informationPane.length; i++) {
+                String line = informationPane[i];
+
+                String excess;
+                String trimmed = trimToWidth(line, width*1/3-boxPadding*2-10);
+
+                String colourCodes = "";
+                Pattern pattern = Pattern.compile("\\u00A7.");
+                Matcher matcher = pattern.matcher(trimmed);
+                while(matcher.find()) {
+                    colourCodes += matcher.group();
+                }
+
+                boolean firstLine = true;
+                int trimmedCharacters = trimmed.length();
+                while(true) {
+                    if(trimmed.length() == line.length()) {
+                        fr.drawString(trimmed, leftSide+boxPadding + 5, boxPadding + 10 + yOff, Color.WHITE.getRGB());
+                        break;
+                    } else if(trimmed.isEmpty()) {
+                        yOff -= 12;
+                        break;
+                    } else {
+                        if(firstLine) {
+                            fr.drawString(trimmed, leftSide+boxPadding + 5, boxPadding + 10 + yOff, Color.WHITE.getRGB());
+                            firstLine = false;
+                        } else {
+                            if(trimmed.startsWith(" ")) {
+                                trimmed = trimmed.substring(1);
+                            }
+                            fr.drawString(colourCodes + trimmed, leftSide+boxPadding + 5, boxPadding + 10 + yOff, Color.WHITE.getRGB());
+                        }
+
+                        excess = line.substring(trimmedCharacters);
+                        trimmed = trimToWidth(excess, width * 1 / 3 - boxPadding * 2 - 10);
+                        trimmedCharacters += trimmed.length();
+                        yOff += 12;
+                    }
+                }
+
+                yOff += 16;
+            }
+        }
+    }
+
+    public float getInfoPaneOffsetFactor() {
+        if(itemPaneOffsetFactor.getValue() == 2/3f) {
+            return infoPaneOffsetFactor.getValue();
+        } else {
+            return Math.min(infoPaneOffsetFactor.getValue(), 1-itemPaneOffsetFactor.getValue());
+        }
+    }
+
+    public String trimToWidth(String str, int len) {
+        FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;
+        String trim = fr.trimStringToWidth(str, len);
+
+        if(str.length() != trim.length() && !trim.endsWith(" ")) {
+            char next = str.charAt(trim.length());
+            if(next != ' ') {
+                String[] split = trim.split(" ");
+                String last = split[split.length-1];
+                if(last.length() < 8) {
+                    trim = trim.substring(0, trim.length()-last.length());
+                }
+            }
+        }
+
+        return trim;
+    }
+
+    private void drawItemStack(ItemStack stack, int x, int y, String altText) {
+        RenderItem itemRender = Minecraft.getMinecraft().getRenderItem();
+        FontRenderer font = Minecraft.getMinecraft().fontRendererObj;
+
+        RenderHelper.enableGUIStandardItemLighting();
+        itemRender.renderItemAndEffectIntoGUI(stack, x, y);
+        RenderHelper.disableStandardItemLighting();
+
+        itemRender.renderItemOverlayIntoGUI(font, stack, x, y, altText);
+    }
+
+    private void drawTexturedRect(int x, int y, int width, int height) {
+        drawTexturedRect(x, y, width, height, 0, 1, 0 , 1);
+    }
+
+    private void drawTexturedRect(int x, int y, int width, int height, float uMin, float uMax, float vMin, float vMax) {
+        Tessellator tessellator = Tessellator.getInstance();
+        WorldRenderer worldrenderer = tessellator.getWorldRenderer();
+
+        GlStateManager.enableAlpha();
+        GlStateManager.enableBlend();
+        GlStateManager.blendFunc(770, 771);
+        GlStateManager.alphaFunc(516, 0.003921569F);
+
+        worldrenderer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+        worldrenderer.pos(x + 0, y + height, this.zLevel).tex(uMin, vMax).endVertex();
+        worldrenderer.pos(x + width, y + height, this.zLevel).tex(uMax, vMax).endVertex();
+        worldrenderer.pos(x + width, y + 0, this.zLevel).tex(uMax, vMin).endVertex();
+        worldrenderer.pos(x + 0, y + 0, this.zLevel).tex(uMin, vMin).endVertex();
+        tessellator.draw();
+
+        GlStateManager.disableBlend();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/NotEnoughUpdates.java b/src/main/java/io/github/moulberry/notenoughupdates/NotEnoughUpdates.java
new file mode 100644
index 00000000..17295aa8
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/NotEnoughUpdates.java
@@ -0,0 +1,159 @@
+package io.github.moulberry.notenoughupdates;
+
+import com.mojang.authlib.Agent;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.exceptions.AuthenticationException;
+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
+import com.mojang.authlib.yggdrasil.YggdrasilUserAuthentication;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.Session;
+import net.minecraftforge.client.event.GuiOpenEvent;
+import net.minecraftforge.client.event.GuiScreenEvent;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.player.ItemTooltipEvent;
+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.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import org.lwjgl.input.Keyboard;
+
+import javax.swing.*;
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.net.Proxy;
+import java.util.Scanner;
+import java.util.UUID;
+
+@Mod(modid = NotEnoughUpdates.MODID, version = NotEnoughUpdates.VERSION)
+public class NotEnoughUpdates {
+    public static final String MODID = "notenoughupdates";
+    public static final String VERSION = "1.0.0";
+
+    private NEUManager manager;
+    private NEUOverlay overlay;
+    private NEUIO neuio;
+    
+    @EventHandler
+    public void preinit(FMLPreInitializationEvent event) {
+        MinecraftForge.EVENT_BUS.register(this);
+
+        File f = new File(event.getModConfigurationDirectory(), "notenoughupdates");
+        f.mkdirs();
+        //Github Access Token, may change. Value hard-coded.
+        neuio = new NEUIO("c49fcad378ae46e5c08bf6b0c5502f7e4830bfef");
+        manager = new NEUManager(neuio, f);
+        manager.loadItemInformation();
+        overlay = new NEUOverlay(manager);
+
+        //TODO: login code. Ignore this, used for testing.
+        /*try {
+            Field field = Minecraft.class.getDeclaredField("session");
+            YggdrasilUserAuthentication auth = (YggdrasilUserAuthentication)
+                    new YggdrasilAuthenticationService(Proxy.NO_PROXY, UUID.randomUUID().toString())
+                            .createUserAuthentication(Agent.MINECRAFT);
+            auth.setUsername("...");
+            JPasswordField pf = new JPasswordField();
+            JOptionPane.showConfirmDialog(null,
+                    pf,
+                    "Enter password:",
+                    JOptionPane.NO_OPTION,
+                    JOptionPane.PLAIN_MESSAGE);
+            auth.setPassword(new String(pf.getPassword()));
+            System.out.print("Attempting login...");
+
+            auth.logIn();
+
+            Session session = new Session(auth.getSelectedProfile().getName(),
+                    auth.getSelectedProfile().getId().toString().replace("-", ""),
+                    auth.getAuthenticatedToken(),
+                    auth.getUserType().getName());
+
+            Field modifiersField = Field.class.getDeclaredField("modifiers");
+            modifiersField.setAccessible(true);
+            modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+
+            field.setAccessible(true);
+            field.set(Minecraft.getMinecraft(), session);
+        } catch (NoSuchFieldException | AuthenticationException | IllegalAccessException e) {
+            e.printStackTrace();
+        }*/
+
+    }
+
+    @SubscribeEvent
+    public void onGuiOpen(GuiOpenEvent event) {
+        if(Minecraft.getMinecraft().currentScreen == null
+                && event.gui instanceof GuiContainer) {
+            overlay.reset();
+        }
+    }
+
+    @SubscribeEvent
+    public void onGuiScreenDraw(GuiScreenEvent.DrawScreenEvent.Post event) {
+        if(event.gui instanceof GuiContainer) {
+            overlay.render(event.renderPartialTicks, event.mouseX, event.mouseY);
+        }
+    }
+
+    @SubscribeEvent
+    public void onGuiScreenMouse(GuiScreenEvent.MouseInputEvent.Pre event) {
+        if(event.gui instanceof GuiContainer) {
+            if(overlay.mouseInput()) {
+                event.setCanceled(true);
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void onGuiScreenKeyboard(GuiScreenEvent.KeyboardInputEvent.Pre event) {
+        if(event.gui instanceof GuiContainer) {
+            if(overlay.keyboardInput()) {
+                event.setCanceled(true);
+            }
+        }
+    }
+
+    /**
+     * This was code leftover from testing but it ended up in the final mod so I guess its staying here.
+     * This makes it so that holding LCONTROL while hovering over an item with NBT will show the NBT of the item.
+     * Should probably have this disabled by default via config.
+     * @param event
+     */
+    @SubscribeEvent
+    public void onItemTooltip(ItemTooltipEvent event) {
+        if(!Keyboard.isKeyDown(Keyboard.KEY_LCONTROL)) return;
+        if(event.toolTip.get(event.toolTip.size()-1).startsWith(EnumChatFormatting.DARK_GRAY + "NBT: ")) {
+            event.toolTip.remove(event.toolTip.size()-1);
+
+            StringBuilder sb = new StringBuilder();
+            String nbt = event.itemStack.getTagCompound().toString();
+            int indent = 0;
+            for(char c : nbt.toCharArray()) {
+                boolean newline = false;
+                if(c == '{' || c == '[') {
+                    indent++;
+                    newline = true;
+                } else if(c == '}' || c == ']') {
+                    indent--;
+                    sb.append("\n");
+                    for(int i=0; i<indent; i++) sb.append("  ");
+                } else if(c == ',') {
+                    newline = true;
+                } else if(c == '\"') {
+                    sb.append(EnumChatFormatting.RESET.toString() + EnumChatFormatting.GRAY);
+                }
+
+                sb.append(c);
+                if(newline) {
+                    sb.append("\n");
+                    for(int i=0; i<indent; i++) sb.append("  ");
+                }
+            }
+            event.toolTip.add(sb.toString());
+        }
+    }
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElement.java b/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElement.java
new file mode 100644
index 00000000..06a8810d
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElement.java
@@ -0,0 +1,15 @@
+package io.github.moulberry.notenoughupdates.itemeditor;
+
+import net.minecraft.client.gui.Gui;
+
+public abstract class GuiElement extends Gui {
+
+    public abstract void render(int x, int y);
+    public abstract int getWidth();
+    public abstract int getHeight();
+    public void mouseClicked(int mouseX, int mouseY, int mouseButton) {}
+    public void mouseClickMove(int mouseX, int mouseY, int clickedMouseButton, long timeSinceLastClick) {}
+    public void otherComponentClick() {}
+    public void keyTyped(char typedChar, int keyCode) {}
+
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementButton.java b/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementButton.java
new file mode 100644
index 00000000..0ed03c36
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementButton.java
@@ -0,0 +1,35 @@
+package io.github.moulberry.notenoughupdates.itemeditor;
+
+import java.awt.*;
+
+public class GuiElementButton extends GuiElementText {
+
+    private Runnable callback;
+
+    public GuiElementButton(String text, int colour, Runnable callback) {
+        super(text, colour);
+        this.callback = callback;
+    }
+
+    @Override
+    public int getHeight() {
+        return super.getHeight() + 5;
+    }
+
+    @Override
+    public int getWidth() {
+        return super.getWidth() + 10;
+    }
+
+    @Override
+    public void mouseClicked(int mouseX, int mouseY, int mouseButton) {
+        callback.run();
+    }
+
+    @Override
+    public void render(int x, int y) {
+        drawRect(x, y, x+getWidth(), y+super.getHeight(), Color.WHITE.getRGB());
+        drawRect(x+1, y+1, x+getWidth()-1, y+super.getHeight()-1, Color.BLACK.getRGB());
+        super.render(x+5, y-1);
+    }
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementText.java b/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementText.java
new file mode 100644
index 00000000..28bc9b71
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementText.java
@@ -0,0 +1,42 @@
+package io.github.moulberry.notenoughupdates.itemeditor;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+
+public class GuiElementText extends GuiElement {
+
+    protected String text;
+    private int colour;
+
+    public GuiElementText(String text, int colour) {
+        this.text = text;
+        this.colour = colour;
+    }
+
+    @Override
+    public int getHeight() {
+        return 18;
+    }
+
+    @Override
+    public int getWidth() {
+        FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;
+        return fr.getStringWidth(text);
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    @Override
+    public void render(int x, int y) {
+        FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;
+
+        fr.drawString(text, x, y+6, colour);
+    }
+
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementTextField.java b/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementTextField.java
new file mode 100644
index 00000000..5ad5c66c
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementTextField.java
@@ -0,0 +1,407 @@
+package io.github.moulberry.notenoughupdates.itemeditor;
+
+import com.google.common.base.Predicate;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.GuiTextField;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.client.renderer.GlStateManager;
+import org.apache.commons.lang3.StringUtils;
+
+import javax.annotation.Nullable;
+import java.awt.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class GuiElementTextField extends GuiElement {
+
+    public static final int NUM_ONLY = 0b10000;
+    public static final int NO_SPACE = 0b01000;
+    public static final int FORCE_CAPS = 0b00100;
+    public static final int COLOUR = 0b00010;
+    public static final int MULTILINE = 0b00001;
+
+    private static final int searchBarYSize = 20;
+    private static final int searchBarXSize = 350;
+    private static final int searchBarPadding = 2;
+
+    private int options = 0;
+
+    private boolean focus = false;
+
+    private int x;
+    private int y;
+
+    private GuiTextField textField = new GuiTextField(0, Minecraft.getMinecraft().fontRendererObj,
+            0 , 0, 0, 0);
+
+    public GuiElementTextField(String initialText, int options) {
+        textField.setFocused(true);
+        textField.setCanLoseFocus(false);
+        textField.setMaxStringLength(999);
+        textField.setText(initialText);
+        this.options = options;
+    }
+
+    @Override
+    public String toString() {
+        return textField.getText();
+    }
+
+    @Override
+    public int getHeight() {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int paddingUnscaled = searchBarPadding/scaledresolution.getScaleFactor();
+
+        int numLines = StringUtils.countMatches(textField.getText(), "\n")+1;
+        int extraSize = (searchBarYSize-8)/2+8;
+        int bottomTextBox = searchBarYSize + extraSize*(numLines-1);
+
+        return bottomTextBox + paddingUnscaled*2;
+    }
+
+    @Override
+    public int getWidth() {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int paddingUnscaled = searchBarPadding/scaledresolution.getScaleFactor();
+
+        return searchBarXSize + paddingUnscaled*2;
+    }
+
+    public int getCursorPos(int mouseX, int mouseY) {
+        int xComp = mouseX - x;
+        int yComp = mouseY - y;
+
+        int extraSize = (searchBarYSize-8)/2+8;
+
+        int lineNum = Math.round(((yComp - (searchBarYSize-8)/2))/extraSize);
+
+        Pattern patternControlCode = Pattern.compile("(?i)\\u00A7([^\\u00B6])(?!\\u00B6)");
+        String text = textField.getText();
+        String textNoColour = textField.getText();
+        while(true) {
+            Matcher matcher = patternControlCode.matcher(text);
+            if(!matcher.find() || matcher.groupCount() < 1) break;
+            String code = matcher.group(1);
+            text = matcher.replaceFirst("\u00A7"+code+"\u00B6"+code);
+        }
+        while(true) {
+            Matcher matcher = patternControlCode.matcher(textNoColour);
+            if(!matcher.find() || matcher.groupCount() < 1) break;
+            String code = matcher.group(1);
+            textNoColour = matcher.replaceFirst("\u00B6"+code);
+        }
+
+        int currentLine = 0;
+        int cursorIndex = 0;
+        for(; cursorIndex<textNoColour.length(); cursorIndex++) {
+            if(currentLine == lineNum) break;
+            if(textNoColour.charAt(cursorIndex) == '\n') {
+                currentLine++;
+            }
+        }
+        String textNC = textNoColour.substring(0, cursorIndex);
+        int colorCodes = StringUtils.countMatches(textNC, "\u00B6");
+        String line = text.substring(cursorIndex+colorCodes*2).split("\n")[0];
+        String trimmed = Minecraft.getMinecraft().fontRendererObj.trimStringToWidth(line, xComp-5);
+        int linePos = strLenNoColor(trimmed);
+        if(linePos != strLenNoColor(line)) {
+            char after = line.charAt(linePos);
+            int trimmedWidth = Minecraft.getMinecraft().fontRendererObj.getStringWidth(trimmed);
+            int charWidth = Minecraft.getMinecraft().fontRendererObj.getCharWidth(after);
+            if(trimmedWidth + charWidth/2 < xComp-5) {
+                linePos++;
+            }
+        }
+        cursorIndex += linePos;
+        return cursorIndex;
+    }
+
+    @Override
+    public void mouseClicked(int mouseX, int mouseY, int mouseButton) {
+        if(mouseButton == 1) {
+            textField.setText("");
+        } else {
+            textField.setCursorPosition(getCursorPos(mouseX, mouseY));
+        }
+        focus = true;
+    }
+
+    public void otherComponentClick() {
+        focus = false;
+        textField.setSelectionPos(textField.getCursorPosition());
+    }
+
+    public int strLenNoColor(String str) {
+        return str.replaceAll("(?i)\\u00A7.", "").length();
+    }
+
+    public void mouseClickMove(int mouseX, int mouseY, int clickedMouseButton, long timeSinceLastClick) {
+        if(focus) {
+            textField.setSelectionPos(getCursorPos(mouseX, mouseY));
+        }
+    }
+
+    @Override
+    public void keyTyped(char typedChar, int keyCode) {
+        if(focus) {
+            if((options & MULTILINE) != 0) { //Carriage return
+                Pattern patternControlCode = Pattern.compile("(?i)\\u00A7([^\\u00B6\n])(?!\\u00B6)");
+
+                String text = textField.getText();
+                String textNoColour = textField.getText();
+                while(true) {
+                    Matcher matcher = patternControlCode.matcher(text);
+                    if(!matcher.find() || matcher.groupCount() < 1) break;
+                    String code = matcher.group(1);
+                    text = matcher.replaceFirst("\u00A7"+code+"\u00B6"+code);
+                }
+                while(true) {
+                    Matcher matcher = patternControlCode.matcher(textNoColour);
+                    if(!matcher.find() || matcher.groupCount() < 1) break;
+                    String code = matcher.group(1);
+                    textNoColour = matcher.replaceFirst("\u00B6"+code);
+                }
+
+                if(keyCode == 28) {
+                    String before = textField.getText().substring(0, textField.getCursorPosition());
+                    String after = textField.getText().substring(textField.getCursorPosition());
+                    int pos = textField.getCursorPosition();
+                    textField.setText(before + "\n" + after);
+                    textField.setCursorPosition(pos+1);
+                    return;
+                } else if(keyCode == 200) { //Up
+                    String textNCBeforeCursor = textNoColour.substring(0, textField.getSelectionEnd());
+                    int colorCodes = StringUtils.countMatches(textNCBeforeCursor, "\u00B6");
+                    String textBeforeCursor = text.substring(0, textField.getSelectionEnd()+colorCodes*2);
+
+                    int numLinesBeforeCursor = StringUtils.countMatches(textBeforeCursor, "\n");
+
+                    String[] split = textBeforeCursor.split("\n");
+                    int textBeforeCursorWidth;
+                    String lineBefore;
+                    String thisLineBeforeCursor;
+                    if(split.length == numLinesBeforeCursor && split.length > 0) {
+                        textBeforeCursorWidth = 0;
+                        lineBefore = split[split.length-1];
+                        thisLineBeforeCursor = "";
+                    } else if(split.length > 1) {
+                        thisLineBeforeCursor = split[split.length-1];
+                        lineBefore = split[split.length-2];
+                        textBeforeCursorWidth = Minecraft.getMinecraft().fontRendererObj.getStringWidth(thisLineBeforeCursor);
+                    } else {
+                        return;
+                    }
+                    String trimmed = Minecraft.getMinecraft().fontRendererObj
+                            .trimStringToWidth(lineBefore, textBeforeCursorWidth);
+                    int linePos = strLenNoColor(trimmed);
+                    if(linePos != strLenNoColor(lineBefore)) {
+                        char after = lineBefore.charAt(linePos);
+                        int trimmedWidth = Minecraft.getMinecraft().fontRendererObj.getStringWidth(trimmed);
+                        int charWidth = Minecraft.getMinecraft().fontRendererObj.getCharWidth(after);
+                        if(trimmedWidth + charWidth/2 < textBeforeCursorWidth) {
+                            linePos++;
+                        }
+                    }
+                    int newPos = textField.getSelectionEnd()-strLenNoColor(thisLineBeforeCursor)
+                            -strLenNoColor(lineBefore)-1+linePos;
+
+                    if(GuiScreen.isShiftKeyDown()) {
+                        textField.setSelectionPos(newPos);
+                    } else {
+                        textField.setCursorPosition(newPos);
+                    }
+                } else if(keyCode == 208) { //Down
+                    String textNCBeforeCursor = textNoColour.substring(0, textField.getSelectionEnd());
+                    int colorCodes = StringUtils.countMatches(textNCBeforeCursor, "\u00B6");
+                    String textBeforeCursor = text.substring(0, textField.getSelectionEnd()+colorCodes*2);
+
+                    int numLinesBeforeCursor = StringUtils.countMatches(textBeforeCursor, "\n");
+
+                    String[] split = textBeforeCursor.split("\n");
+                    String thisLineBeforeCursor;
+                    int textBeforeCursorWidth;
+                    if(split.length == numLinesBeforeCursor) {
+                        thisLineBeforeCursor = "";
+                        textBeforeCursorWidth = 0;
+                    } else if(split.length > 0) {
+                        thisLineBeforeCursor = split[split.length-1];
+                        textBeforeCursorWidth = Minecraft.getMinecraft().fontRendererObj.getStringWidth(thisLineBeforeCursor);
+                    } else {
+                        return;
+                    }
+
+                    String[] split2 = textNoColour.split("\n");
+                    if(split2.length > numLinesBeforeCursor+1) {
+                        String lineAfter = split2[numLinesBeforeCursor+1];
+                        String trimmed = Minecraft.getMinecraft().fontRendererObj
+                                .trimStringToWidth(lineAfter, textBeforeCursorWidth);
+                        int linePos = strLenNoColor(trimmed);
+                        if(linePos != strLenNoColor(lineAfter)) {
+                            char after = lineAfter.charAt(linePos);
+                            int trimmedWidth = Minecraft.getMinecraft().fontRendererObj.getStringWidth(trimmed);
+                            int charWidth = Minecraft.getMinecraft().fontRendererObj.getCharWidth(after);
+                            if(trimmedWidth + charWidth/2 < textBeforeCursorWidth) {
+                                linePos++;
+                            }
+                        }
+                        int newPos = textField.getSelectionEnd()-strLenNoColor(thisLineBeforeCursor)
+                                +strLenNoColor(split2[numLinesBeforeCursor])+1+linePos;
+
+                        if(GuiScreen.isShiftKeyDown()) {
+                            textField.setSelectionPos(newPos);
+                        } else {
+                            textField.setCursorPosition(newPos);
+                        }
+                    }
+                }
+            }
+
+            String old = textField.getText();
+            if((options & FORCE_CAPS) != 0) typedChar = Character.toUpperCase(typedChar);
+            if((options & NO_SPACE) != 0 && typedChar == ' ') return;
+
+            textField.textboxKeyTyped(typedChar, keyCode);
+
+            if((options & COLOUR) != 0) {
+                if(typedChar == '&') {
+                    int pos = textField.getCursorPosition()-2;
+                    if(pos >= 0 && pos < textField.getText().length()) {
+                        if(textField.getText().charAt(pos) == '&') {
+                            String before = textField.getText().substring(0, pos);
+                            String after = "";
+                            if(pos+2 < textField.getText().length()) {
+                                after = textField.getText().substring(pos+2);
+                            }
+                            textField.setText(before + "\u00A7" + after);
+                            textField.setCursorPosition(pos+1);
+                        }
+                    }
+
+                }
+            }
+
+            if((options & NUM_ONLY) != 0 && textField.getText().matches("[^0-9]")) textField.setText(old);
+        }
+    }
+
+    public void render(int x, int y) {
+        this.x = x;
+        this.y = y;
+        drawTextbox(x, y, searchBarXSize, searchBarYSize, searchBarPadding, textField, focus);
+    }
+
+    private void drawTextbox(int x, int y, int searchBarXSize, int searchBarYSize, int searchBarPadding,
+                             GuiTextField textField, boolean focus) {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+
+        GlStateManager.disableLighting();
+
+        /**
+         * Search bar
+         */
+        int paddingUnscaled = searchBarPadding/scaledresolution.getScaleFactor();
+        if(paddingUnscaled < 1) paddingUnscaled = 1;
+
+        int numLines = StringUtils.countMatches(textField.getText(), "\n")+1;
+        int extraSize = (searchBarYSize-8)/2+8;
+        int bottomTextBox = y + searchBarYSize + extraSize*(numLines-1);
+
+        //Search bar background
+        drawRect(x - paddingUnscaled,
+                y - paddingUnscaled,
+                x + searchBarXSize + paddingUnscaled,
+                bottomTextBox + paddingUnscaled, focus ? Color.GREEN.getRGB() : Color.WHITE.getRGB());
+        drawRect(x,
+                y,
+                x + searchBarXSize,
+                bottomTextBox, Color.BLACK.getRGB());
+
+        //Search bar text
+        Pattern patternControlCode = Pattern.compile("(?i)\\u00A7([^\\u00B6\n])(?!\\u00B6)");
+
+        String text = textField.getText();
+        String textNoColor = textField.getText();
+        while(true) {
+            Matcher matcher = patternControlCode.matcher(text);
+            if(!matcher.find() || matcher.groupCount() < 1) break;
+            String code = matcher.group(1);
+            text = matcher.replaceFirst("\u00A7"+code+"\u00B6"+code);
+        }
+        while(true) {
+            Matcher matcher = patternControlCode.matcher(textNoColor);
+            if(!matcher.find() || matcher.groupCount() < 1) break;
+            String code = matcher.group(1);
+            textNoColor = matcher.replaceFirst("\u00B6"+code);
+        }
+
+        String[] texts = text.split("\n");
+        for(int yOffI = 0; yOffI < texts.length; yOffI++) {
+            int yOff = yOffI*extraSize;
+
+            Minecraft.getMinecraft().fontRendererObj.drawString(texts[yOffI], x + 5,
+                    y+(searchBarYSize-8)/2+yOff, Color.WHITE.getRGB());
+        }
+
+        if(focus && System.currentTimeMillis()%1000>500) {
+            String textNCBeforeCursor = textNoColor.substring(0, textField.getCursorPosition());
+            int colorCodes = StringUtils.countMatches(textNCBeforeCursor, "\u00B6");
+            String textBeforeCursor = text.substring(0, textField.getCursorPosition()+colorCodes*2);
+
+            int numLinesBeforeCursor = StringUtils.countMatches(textBeforeCursor, "\n");
+            int yOff = numLinesBeforeCursor*extraSize;
+
+            String[] split = textBeforeCursor.split("\n");
+            int textBeforeCursorWidth;
+            if(split.length <= numLinesBeforeCursor || split.length == 0) {
+                textBeforeCursorWidth = 0;
+            } else {
+                textBeforeCursorWidth = Minecraft.getMinecraft().fontRendererObj.getStringWidth(split[split.length-1]);
+            }
+            drawRect(x + 5 + textBeforeCursorWidth,
+                    y+(searchBarYSize-8)/2-1 + yOff,
+                    x + 5 + textBeforeCursorWidth+1,
+                    y+(searchBarYSize-8)/2+9 + yOff, Color.WHITE.getRGB());
+        }
+
+        String selectedText = textField.getSelectedText();
+        if(!selectedText.isEmpty()) {
+            int leftIndex = textField.getCursorPosition() < textField.getSelectionEnd() ?
+                    textField.getCursorPosition() : textField.getSelectionEnd();
+            int rightIndex = textField.getCursorPosition() > textField.getSelectionEnd() ?
+                    textField.getCursorPosition() : textField.getSelectionEnd();
+
+            int texX = 0;
+            int texY = 0;
+            for(int i=0; i<textNoColor.length(); i++) {
+                char c = textNoColor.charAt(i);
+                if(c == '\n') {
+                    if(i >= leftIndex && i < rightIndex) {
+                        drawRect(x + 5 + texX,
+                                y+(searchBarYSize-8)/2-1 + texY,
+                                x + 5 + texX + 3,
+                                y+(searchBarYSize-8)/2+9 + texY, Color.LIGHT_GRAY.getRGB());
+                    }
+
+                    texX = 0;
+                    texY += extraSize;
+                    continue;
+                }
+
+                int len = Minecraft.getMinecraft().fontRendererObj.getStringWidth(String.valueOf(c));
+                if(i >= leftIndex && i < rightIndex) {
+                    drawRect(x + 5 + texX,
+                            y+(searchBarYSize-8)/2-1 + texY,
+                            x + 5 + texX + len,
+                            y+(searchBarYSize-8)/2+9 + texY, Color.LIGHT_GRAY.getRGB());
+
+                    Minecraft.getMinecraft().fontRendererObj.drawString(String.valueOf(c),
+                            x + 5 + texX,
+                            y+(searchBarYSize-8)/2 + texY, Color.BLACK.getRGB());
+                }
+
+                texX += len;
+            }
+        }
+    }
+}
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/NEUItemEditor.java b/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/NEUItemEditor.java
new file mode 100644
index 00000000..6cc8aacd
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/itemeditor/NEUItemEditor.java
@@ -0,0 +1,417 @@
+package io.github.moulberry.notenoughupdates.itemeditor;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import io.github.moulberry.notenoughupdates.LerpingInteger;
+import io.github.moulberry.notenoughupdates.NEUManager;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.*;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.*;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fml.client.config.GuiUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.input.Mouse;
+import org.lwjgl.opengl.GL11;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.*;
+import java.util.List;
+import java.util.function.Supplier;
+import static io.github.moulberry.notenoughupdates.itemeditor.GuiElementTextField.*;
+
+public class NEUItemEditor extends GuiScreen {
+
+    private NEUManager manager;
+
+    private List<GuiElement> options = new ArrayList<>();
+    private List<GuiElement> rightOptions = new ArrayList<>();
+
+    private JsonObject item;
+
+    private static final int PADDING = 10;
+    private static final int SCROLL_AMOUNT = 20;
+
+    private LerpingInteger scrollHeight = new LerpingInteger(0);
+
+    private Supplier<String> internalname;
+    private Supplier<String> itemid;
+    private Supplier<String> displayname;
+    private Supplier<String> lore;
+    private Supplier<String> info;
+    private Supplier<String> clickcommand;
+    private Supplier<String> damage;
+    private NBTTagCompound nbttag;
+
+    public NEUItemEditor(NEUManager manager, String internalname, JsonObject item) {
+        this.manager = manager;
+        this.item = item;
+
+        if(item.has("nbttag")) {
+            try {
+                nbttag = JsonToNBT.getTagFromJson(item.get("nbttag").getAsString());
+            } catch(NBTException e) {}
+        }
+
+        internalname = internalname == null ? "" : internalname;
+        options.add(new GuiElementText("Internal Name: ", Color.WHITE.getRGB()));
+        this.internalname = addTextFieldWithSupplier(internalname, NO_SPACE | FORCE_CAPS);
+
+        options.add(new GuiElementText("Item ID: ", Color.WHITE.getRGB()));
+        String itemid = item.has("itemid") ? item.get("itemid").getAsString() : "";
+        this.itemid = addTextFieldWithSupplier(itemid, NO_SPACE);
+
+        options.add(new GuiElementText("Display name: ", Color.WHITE.getRGB()));
+        String displayname = item.has("displayname") ? item.get("displayname").getAsString() : "";
+        this.displayname = addTextFieldWithSupplier(displayname, COLOUR);
+
+        options.add(new GuiElementText("Lore: ", Color.WHITE.getRGB()));
+        JsonArray lore = item.has("lore") ? item.get("lore").getAsJsonArray() : new JsonArray();
+        String[] loreA = new String[lore.size()];
+        for(int i=0; i<lore.size(); i++) loreA[i] = lore.get(i).getAsString();
+        this.lore = addTextFieldWithSupplier(String.join("\n", loreA), COLOUR | MULTILINE);
+
+        options.add(new GuiElementText("Additional information: ", Color.WHITE.getRGB()));
+        this.info = addTextFieldWithSupplier("", COLOUR | MULTILINE);
+
+        options.add(new GuiElementText("Click-command (viewrecipe or viewpotion): ", Color.WHITE.getRGB()));
+        String clickcommand = item.has("clickcommand") ? item.get("clickcommand").getAsString() : "";
+        this.clickcommand = addTextFieldWithSupplier(clickcommand, NO_SPACE);
+
+        options.add(new GuiElementText("Damage: ", Color.WHITE.getRGB()));
+        String damage = item.has("damage") ? item.get("damage").getAsString() : "";
+        this.damage = addTextFieldWithSupplier(damage, NO_SPACE | NUM_ONLY);
+
+        rightOptions.add(new GuiElementButton("Close (discards changes)", Color.LIGHT_GRAY.getRGB(), () -> {
+            Minecraft.getMinecraft().displayGuiScreen(null);
+        }));
+        GuiElementButton button = new Object() { //Used to make the compiler shut the fuck up
+            GuiElementButton b = new GuiElementButton("Save to local disk", Color.GREEN.getRGB(), new Runnable() {
+                public void run() {
+                    if(save()) {
+                        b.setText("Save to local disk (SUCCESS)");
+                    } else {
+                        b.setText("Save to local disk (FAILED)");
+                    }
+                }
+            });
+        }.b;
+        rightOptions.add(button);
+
+        button = new Object() { //Used to make the compiler shut the fuck up
+            GuiElementButton b = new GuiElementButton("Upload", Color.YELLOW.getRGB(), new Runnable() {
+                public void run() {
+                    if(b.getText().equals("Upload")) {
+                        b.setText("Confirm upload?");
+                    } else {
+                        if(upload()) {
+                            b.setText("Uploaded");
+                        } else {
+                            b.setText("Upload failed.");
+                        }
+                    }
+                }
+            });
+        }.b;
+        rightOptions.add(button);
+
+        rightOptions.add(new GuiElementText("", Color.WHITE.getRGB()));
+
+        rightOptions.add(new GuiElementButton("Remove enchants", Color.RED.getRGB(), () -> {
+            nbttag.removeTag("ench");
+            nbttag.getCompoundTag("ExtraAttributes").removeTag("enchantments");
+        }));
+        rightOptions.add(new GuiElementButton("Add enchant glint", Color.ORANGE.getRGB(), () -> {
+            nbttag.setTag("ench", new NBTTagList());
+        }));
+
+        resetScrollToTop();
+    }
+
+    public boolean save() {
+        int damageI = 0;
+        try {
+            damageI = Integer.valueOf(damage.get());
+        } catch(NumberFormatException e) {}
+        resyncNbttag();
+        String[] infoA = info.get().trim().split("\n");
+        if(infoA.length == 0 || infoA[0].isEmpty()) {
+            infoA = new String[0];
+        }
+        return manager.writeItemJson(internalname.get(), itemid.get(), displayname.get(), lore.get().split("\n"),
+                infoA, clickcommand.get(), damageI, nbttag);
+    }
+
+    public boolean upload() {
+        int damageI = 0;
+        try {
+            damageI = Integer.valueOf(damage.get());
+        } catch(NumberFormatException e) {}
+        resyncNbttag();
+        String[] infoA = info.get().trim().split("\n");
+        if(infoA.length == 0 || infoA[0].isEmpty()) {
+            infoA = new String[0];
+        }
+        return manager.uploadItemJson(internalname.get(), itemid.get(), displayname.get(), lore.get().split("\n"),
+                infoA, clickcommand.get(), damageI, nbttag);
+    }
+
+    public void onGuiClosed() {
+        Keyboard.enableRepeatEvents(false);
+    }
+
+    public Supplier<String> addTextFieldWithSupplier(String initialText, int options) {
+        GuiElementTextField textField = new GuiElementTextField(initialText, options);
+        this.options.add(textField);
+        return () -> textField.toString();
+    }
+
+    public void resyncNbttag() {
+        if(nbttag == null) nbttag = new NBTTagCompound();
+
+        //Item lore
+        NBTTagList list = new NBTTagList();
+        for(String lore : this.lore.get().split("\n")) {
+            list.appendTag(new NBTTagString(lore));
+        }
+
+        NBTTagCompound display = nbttag.getCompoundTag("display");
+        display.setTag("Lore", list);
+
+        //Name
+        display.setString("Name", displayname.get());
+        nbttag.setTag("display", display);
+
+        //Internal ID
+        NBTTagCompound ea = nbttag.getCompoundTag("ExtraAttributes");
+        ea.setString("id", internalname.get());
+        nbttag.setTag("ExtraAttributes", ea);
+    }
+
+    public void resetScrollToTop() {
+        int totalHeight = PADDING;
+        for(GuiElement gui : options) {
+            totalHeight += gui.getHeight();
+        }
+
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int height = scaledresolution.getScaledHeight();
+
+        scrollHeight.setValue(totalHeight-height+PADDING);
+    }
+
+    public int calculateYScroll() {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int height = scaledresolution.getScaledHeight();
+
+        int totalHeight = PADDING;
+        for(GuiElement gui : options) {
+            totalHeight += gui.getHeight();
+        }
+
+        if(scrollHeight.getValue() < 0) scrollHeight.setValue(0);
+
+        int yScroll = 0;
+        if(totalHeight > height-PADDING) {
+            yScroll = totalHeight-height+PADDING-scrollHeight.getValue();
+        } else {
+            scrollHeight.setValue(0);
+        }
+        if(yScroll < 0) {
+            yScroll = 0;
+            scrollHeight.setValue(totalHeight-height+PADDING);
+        }
+
+        return yScroll;
+    }
+
+    @Override
+    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
+        scrollHeight.tick();
+
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int width = scaledresolution.getScaledWidth();
+        int height = scaledresolution.getScaledHeight();
+
+        GlStateManager.disableLighting();
+
+        Color backgroundColour = new Color(10, 10, 10, 240);
+        drawRect(0, 0, width, height, backgroundColour.getRGB());
+
+        int yScroll = calculateYScroll();
+        if(yScroll > 0){
+            //Render scroll bar
+        }
+
+        int currentY = PADDING-yScroll;
+        for(GuiElement gui : options) {
+            gui.render(PADDING, currentY);
+            currentY += gui.getHeight();
+        }
+
+        currentY = PADDING;
+        for(GuiElement gui : rightOptions) {
+            gui.render(width-PADDING-gui.getWidth(), currentY);
+            currentY += gui.getHeight();
+        }
+
+        int itemX = 424;
+        int itemY = 32;
+        int itemSize = 128;
+        Color itemBorder = new Color(100, 50, 150, 255);
+        Color itemBackground = new Color(120, 120, 120, 255);
+        drawRect(itemX-10, itemY-10, itemX+itemSize+10, itemY+itemSize+10, Color.DARK_GRAY.getRGB());
+        drawRect(itemX-9, itemY-9, itemX+itemSize+9, itemY+itemSize+9, itemBorder.getRGB());
+        drawRect(itemX-6, itemY-6, itemX+itemSize+6, itemY+itemSize+6, Color.DARK_GRAY.getRGB());
+        drawRect(itemX-5, itemY-5, itemX+itemSize+5, itemY+itemSize+5, itemBackground.getRGB());
+        ItemStack stack = new ItemStack(Item.itemRegistry.getObject(new ResourceLocation(itemid.get())));
+
+        if(stack.getItem() != null) {
+            try {
+                stack.setItemDamage(Integer.valueOf(damage.get()));
+            } catch(NumberFormatException e) {}
+
+            resyncNbttag();
+            stack.setTagCompound(nbttag);
+
+            int scaleFactor = itemSize/16;
+            GL11.glPushMatrix();
+            GlStateManager.scale(scaleFactor, scaleFactor, 1);
+            drawItemStack(stack, itemX/scaleFactor, itemY/scaleFactor, null);
+            GL11.glPopMatrix();
+        }
+
+        //Tooltip
+        List<String> text = new ArrayList<>();
+        text.add(displayname.get());
+        text.addAll(Arrays.asList(lore.get().split("\n")));
+
+        GuiUtils.drawHoveringText(text, itemX-20, itemY+itemSize+28, width, height, -1,
+                Minecraft.getMinecraft().fontRendererObj);
+
+        GlStateManager.disableLighting();
+    }
+
+    @Override
+    protected void keyTyped(char typedChar, int keyCode) {
+        for(GuiElement gui : options) {
+            gui.keyTyped(typedChar, keyCode);
+        }
+    }
+
+    @Override
+    protected void mouseClickMove(int mouseX, int mouseY, int clickedMouseButton, long timeSinceLastClick) {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int width = scaledresolution.getScaledWidth();
+
+        int yScroll = calculateYScroll();
+        int currentY = PADDING-yScroll;
+        for(GuiElement gui : options) {
+            if(mouseY > currentY && mouseY < currentY+gui.getHeight()
+                    && mouseX < gui.getWidth()) {
+                gui.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick);
+                return;
+            }
+            currentY += gui.getHeight();
+        }
+
+        currentY = PADDING;
+        for(GuiElement gui : rightOptions) {
+            if(mouseY > currentY && mouseY < currentY+gui.getHeight()
+                    && mouseX > width-PADDING-gui.getWidth()) {
+                gui.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick);
+                return;
+            }
+            currentY += gui.getHeight();
+        }
+    }
+
+    @Override
+    public void handleMouseInput() throws IOException {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+
+        int maxWidth = 0;
+        for(GuiElement gui : options) {
+            if(gui.getWidth() > maxWidth) maxWidth = gui.getWidth();
+        }
+
+        if(Mouse.getX() < maxWidth*scaledresolution.getScaleFactor()) {
+            int dWheel = Mouse.getEventDWheel();
+
+            if(dWheel < 0) {
+                scrollHeight.setTarget(scrollHeight.getTarget()-SCROLL_AMOUNT);
+                scrollHeight.resetTimer();
+            } else if(dWheel > 0) {
+                scrollHeight.setTarget(scrollHeight.getTarget()+SCROLL_AMOUNT);
+                scrollHeight.resetTimer();
+            }
+        }
+
+        super.handleMouseInput();
+    }
+
+    @Override
+    protected void mouseClicked(int mouseX, int mouseY, int mouseButton) {
+        ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
+        int width = scaledresolution.getScaledWidth();
+
+        int yScroll = calculateYScroll();
+        int currentY = PADDING-yScroll;
+        for(GuiElement gui : options) {
+            if(mouseY > currentY && mouseY < currentY+gui.getHeight()
+                    && mouseX < gui.getWidth()) {
+                gui.mouseClicked(mouseX, mouseY, mouseButton);
+                for(GuiElement gui2 : options) {
+                    if(gui2 != gui) {
+                        gui2.otherComponentClick();
+                    }
+                }
+                for(GuiElement gui2 : rightOptions) {
+                    if(gui2 != gui) {
+                        gui2.otherComponentClick();
+                    }
+                }
+                return;
+            }
+            currentY += gui.getHeight();
+        }
+
+        currentY = PADDING;
+        for(GuiElement gui : rightOptions) {
+            if(mouseY > currentY && mouseY < currentY+gui.getHeight()
+                    && mouseX > width-PADDING-gui.getWidth()) {
+                gui.mouseClicked(mouseX, mouseY, mouseButton);
+                for(GuiElement gui2 : options) {
+                    if(gui2 != gui) {
+                        gui2.otherComponentClick();
+                    }
+                }
+                for(GuiElement gui2 : rightOptions) {
+                    if(gui2 != gui) {
+                        gui2.otherComponentClick();
+                    }
+                }
+                return;
+            }
+            currentY += gui.getHeight();
+        }
+    }
+
+    private void drawItemStack(ItemStack stack, int x, int y, String altText) {
+        RenderItem itemRender = Minecraft.getMinecraft().getRenderItem();
+        FontRenderer font = Minecraft.getMinecraft().fontRendererObj;
+
+        RenderHelper.enableGUIStandardItemLighting();
+        itemRender.renderItemAndEffectIntoGUI(stack, x, y);
+        RenderHelper.disableStandardItemLighting();
+
+        itemRender.renderItemOverlayIntoGUI(font, stack, x, y, altText);
+    }
+
+}
diff --git a/src/main/resources/assets/notenoughupdates/item_edit.png b/src/main/resources/assets/notenoughupdates/item_edit.png
new file mode 100644
index 00000000..6ab71631
--- /dev/null
+++ b/src/main/resources/assets/notenoughupdates/item_edit.png
diff --git a/src/main/resources/assets/notenoughupdates/item_pane_tab_arrow.png b/src/main/resources/assets/notenoughupdates/item_pane_tab_arrow.png
new file mode 100644
index 00000000..d8fc8530
--- /dev/null
+++ b/src/main/resources/assets/notenoughupdates/item_pane_tab_arrow.png
diff --git a/src/main/resources/assets/notenoughupdates/next.png b/src/main/resources/assets/notenoughupdates/next.png
new file mode 100644
index 00000000..8e4a96cc
--- /dev/null
+++ b/src/main/resources/assets/notenoughupdates/next.png
diff --git a/src/main/resources/assets/notenoughupdates/next_pow2.png b/src/main/resources/assets/notenoughupdates/next_pow2.png
new file mode 100644
index 00000000..03365e1c
--- /dev/null
+++ b/src/main/resources/assets/notenoughupdates/next_pow2.png
diff --git a/src/main/resources/assets/notenoughupdates/prev.png b/src/main/resources/assets/notenoughupdates/prev.png
new file mode 100644
index 00000000..a4cef66d
--- /dev/null
+++ b/src/main/resources/assets/notenoughupdates/prev.png
diff --git a/src/main/resources/assets/notenoughupdates/prev_pow2.png b/src/main/resources/assets/notenoughupdates/prev_pow2.png
new file mode 100644
index 00000000..3b756716
--- /dev/null
+++ b/src/main/resources/assets/notenoughupdates/prev_pow2.png
diff --git a/src/main/resources/mcmod.info b/src/main/resources/mcmod.info
new file mode 100644
index 00000000..d8192fc8
--- /dev/null
+++ b/src/main/resources/mcmod.info
@@ -0,0 +1,16 @@
+[
+{
+  "modid": "notenoughupdates",
+  "name": "NotEnoughUpdates",
+  "description": "Mod that shows recipes and useful info for Hypixel's Skyblock gamemode.",
+  "version": "${version}",
+  "mcversion": "${mcversion}",
+  "url": "",
+  "updateUrl": "",
+  "authorList": ["Moulberry"],
+  "credits": "Nullzee for listening to me rant. Contributors, etc. <3",
+  "logoFile": "",
+  "screenshots": [],
+  "dependencies": []
+}
+]