From ae5bace43a14f2d8be9f1c1d9c644cc5dabd5d2f Mon Sep 17 00:00:00 2001 From: unknown Date: Sun, 29 Mar 2020 15:32:45 +1100 Subject: Initial (1.0-BETA) --- .../moulberry/notenoughupdates/LerpingFloat.java | 68 ++ .../moulberry/notenoughupdates/LerpingInteger.java | 68 ++ .../github/moulberry/notenoughupdates/NEUIO.java | 98 +++ .../moulberry/notenoughupdates/NEUManager.java | 627 ++++++++++++++++ .../moulberry/notenoughupdates/NEUOverlay.java | 804 +++++++++++++++++++++ .../notenoughupdates/NotEnoughUpdates.java | 159 ++++ .../notenoughupdates/itemeditor/GuiElement.java | 15 + .../itemeditor/GuiElementButton.java | 35 + .../itemeditor/GuiElementText.java | 42 ++ .../itemeditor/GuiElementTextField.java | 407 +++++++++++ .../notenoughupdates/itemeditor/NEUItemEditor.java | 417 +++++++++++ 11 files changed, 2740 insertions(+) create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/LerpingFloat.java create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/LerpingInteger.java create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/NEUIO.java create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/NEUManager.java create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/NEUOverlay.java create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/NotEnoughUpdates.java create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElement.java create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementButton.java create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementText.java create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/itemeditor/GuiElementTextField.java create mode 100644 src/main/java/io/github/moulberry/notenoughupdates/itemeditor/NEUItemEditor.java (limited to 'src/main/java') 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 getChangedItems(Map oldShas) { + HashMap 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 getItemsDownload(Set filename) { + HashMap 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 itemMap = new TreeMap<>(); + + private TreeMap> tagWordMap = new TreeMap<>(); + private TreeMap>> titleWordMap = new TreeMap<>(); + private TreeMap>> 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 oldShas = new HashMap<>(); + for(Map.Entry entry : itemShaConfig.entrySet()) { + if(new File(itemsLocation, entry.getKey()+".json").exists()) { + oldShas.put(entry.getKey()+".json", entry.getValue().getAsString()); + } + } + Map changedFiles = neuio.getChangedItems(oldShas); + for(Map.Entry 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 downloads = neuio.getItemsDownload(changedFiles.keySet()); + + String startMessage = "NotEnoughUpdates: Syncing with remote repository ("; + int downloaded = 0; + + for(Map.Entry 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 search(String query) { + LinkedHashSet 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 search(String query, TreeMap>> wordMap) { + HashMap> matches = null; + + query = clean(query).toLowerCase(); + for(String queryWord : query.split(" ")) { + HashMap> matchesToKeep = new HashMap<>(); + for(HashMap> 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 Map subMapWithKeysThatAreSuffixes(String prefix, NavigableMap 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 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 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 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 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 itemsMatch = manager.search(textField.getText()); + for(String item : itemsMatch) { + searchedItems.put(item, manager.getItemInformation().get(item)); + } + } + + public Collection 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 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 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(scal