aboutsummaryrefslogtreecommitdiff
path: root/src/main/java/io/github/moulberry/notenoughupdates/miscgui/hex/GuiCustomHex.java
diff options
context:
space:
mode:
Diffstat (limited to 'src/main/java/io/github/moulberry/notenoughupdates/miscgui/hex/GuiCustomHex.java')
-rw-r--r--src/main/java/io/github/moulberry/notenoughupdates/miscgui/hex/GuiCustomHex.java4794
1 files changed, 4794 insertions, 0 deletions
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscgui/hex/GuiCustomHex.java b/src/main/java/io/github/moulberry/notenoughupdates/miscgui/hex/GuiCustomHex.java
new file mode 100644
index 00000000..39374f9d
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/miscgui/hex/GuiCustomHex.java
@@ -0,0 +1,4794 @@
+/*
+ * Copyright (C) 2022 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.miscgui.hex;
+
+import com.google.common.collect.Lists;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import io.github.moulberry.notenoughupdates.NotEnoughUpdates;
+import io.github.moulberry.notenoughupdates.core.GlScissorStack;
+import io.github.moulberry.notenoughupdates.core.GuiElementTextField;
+import io.github.moulberry.notenoughupdates.core.util.lerp.LerpingFloat;
+import io.github.moulberry.notenoughupdates.core.util.lerp.LerpingInteger;
+import io.github.moulberry.notenoughupdates.miscfeatures.SlotLocking;
+import io.github.moulberry.notenoughupdates.miscgui.CalendarOverlay;
+import io.github.moulberry.notenoughupdates.miscgui.util.OrbDisplay;
+import io.github.moulberry.notenoughupdates.mixins.AccessorGuiContainer;
+import io.github.moulberry.notenoughupdates.options.NEUConfig;
+import io.github.moulberry.notenoughupdates.util.Constants;
+import io.github.moulberry.notenoughupdates.util.Utils;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.gui.Gui;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.model.ModelBook;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.inventory.ContainerChest;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.play.client.C0EPacketClickWindow;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.ResourceLocation;
+import org.apache.commons.lang3.text.WordUtils;
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.input.Mouse;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.util.glu.Project;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.text.NumberFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Random;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class GuiCustomHex extends Gui {
+ private static final GuiCustomHex INSTANCE = new GuiCustomHex();
+ private static final ResourceLocation TEXTURE = new ResourceLocation("notenoughupdates:custom_enchant_gui.png");
+ private static final ResourceLocation ENCHANTMENT_TABLE_BOOK_TEXTURE = new ResourceLocation(
+ "textures/entity/enchanting_table_book.png");
+ private static final ModelBook MODEL_BOOK = new ModelBook();
+
+ private static final int EXPERIENCE_ORB_COUNT = 30;
+
+ private static final Pattern XP_COST_PATTERN = Pattern.compile("\\u00a73(\\d+) Exp Levels");
+ private static final Pattern ENCHANT_LEVEL_PATTERN = Pattern.compile("(.*)_(.*)");
+ private static final Pattern ENCHANT_NAME_PATTERN = Pattern.compile("([^IVX]*) ([IVX]*)");
+
+ public static final NumberFormat numberFormat = NumberFormat.getInstance(Locale.US);
+
+ public class Enchantment {
+ public int slotIndex;
+ public String enchantName;
+ public String enchId;
+ public List<String> displayLore;
+ public int level;
+ public int xpCost = -1;
+ public boolean overMaxLevel = false;
+ public boolean conflicts = false;
+ public int price = -1;
+
+ public Enchantment(
+ int slotIndex, String enchantName, String enchId, List<String> displayLore, int level,
+ boolean useMaxLevelForCost, boolean checkConflicts
+ ) {
+ this.slotIndex = slotIndex;
+ this.enchantName = enchantName;
+ this.enchId = enchId;
+ this.displayLore = displayLore;
+ this.level = level;
+ boolean isUlt = false;
+ for (String lore : displayLore) {
+ if (lore.contains("§l")) isUlt = true;
+ break;
+ }
+ JsonObject bazaarInfo = NotEnoughUpdates.INSTANCE.manager.auctionManager.getBazaarInfo(
+ (isUlt ? "ULTIMATE_" : "") + enchId.toUpperCase() + ";" + level);
+ if (bazaarInfo != null && bazaarInfo.get("curr_buy") != null) {
+ this.price = bazaarInfo.get("curr_buy").getAsInt();
+ }
+ if (this.enchId.equals("prosecute")) {
+ this.enchId = "PROSECUTE";
+ }
+
+ if (Constants.ENCHANTS != null) {
+ if (checkConflicts && Constants.ENCHANTS.has("enchant_pools")) {
+ JsonArray pools = Constants.ENCHANTS.getAsJsonArray("enchant_pools");
+ out:
+ for (int i = 0; i < pools.size(); i++) {
+ JsonArray pool = pools.get(i).getAsJsonArray();
+
+ boolean hasThis = false;
+ boolean hasApplied = false;
+
+ for (int j = 0; j < pool.size(); j++) {
+ String enchIdPoolElement = pool.get(j).getAsString();
+ if (enchId.equalsIgnoreCase(enchIdPoolElement)) {
+ hasThis = true;
+ } else if (playerEnchantIds.containsKey(enchIdPoolElement)) {
+ hasApplied = true;
+ }
+ if (hasThis && hasApplied) {
+ this.conflicts = true;
+ break out;
+ }
+ }
+ }
+ }
+
+ if (level >= 1 && Constants.ENCHANTS.has("enchants_xp_cost")) {
+ JsonObject allCosts = Constants.ENCHANTS.getAsJsonObject("enchants_xp_cost");
+ if (allCosts.has(enchId)) {
+ JsonArray costs = allCosts.getAsJsonArray(enchId);
+
+ if (costs.size() >= 1) {
+ if (useMaxLevelForCost) {
+ this.xpCost = costs.get(costs.size() - 1).getAsInt();
+ } else if (level - 1 < costs.size()) {
+ this.xpCost = costs.get(level - 1).getAsInt();
+ } else {
+ overMaxLevel = true;
+ }
+ }
+ }
+
+ }
+ }
+ }
+ }
+
+ public OrbDisplay orbDisplay = new OrbDisplay();
+
+ private int guiLeft;
+ private int guiTop;
+ private boolean shouldOverrideFast = false;
+ private boolean shouldOverrideET = false;
+ private boolean shouldOverrideGemstones = false;
+ private boolean shouldOverrideXp = false;
+ public float pageOpen;
+ public float pageOpenLast;
+ public float pageOpenRandom;
+ public float pageOpenVelocity;
+ public float bookOpen;
+ public float bookOpenLast;
+
+ private int currentPage;
+ private int expectedMaxPage;
+
+ private boolean isScrollingLeft = true;
+
+ private ItemStack enchantingItem = null;
+
+ private int removingEnchantPlayerLevel = -1;
+
+ private final GuiElementTextField searchField = new GuiElementTextField("", GuiElementTextField.SCISSOR_TEXT);
+
+ private final HashMap<String, Integer> playerEnchantIds = new HashMap<>();
+
+ private boolean searchRemovedFromApplicable = false;
+ private boolean searchRemovedFromRemovable = false;
+ private final List<Enchantment> applicable = new ArrayList<>();
+ private final List<Enchantment> removable = new ArrayList<>();
+
+ private final List<HexItem> applicableItem = new ArrayList<>();
+ private final List<HexItem> removableItem = new ArrayList<>();
+ private final HashMap<Integer, Enchantment> enchanterEnchLevels = new HashMap<>();
+ private final HashMap<Integer, HexItem> enchanterItemLevels = new HashMap<>();
+ private Enchantment enchanterCurrentEnch = null;
+ private HexItem enchanterCurrentItem = null;
+
+ public Random random = new Random();
+
+ private EnchantState currentState = EnchantState.NO_ITEM;
+ private EnchantState lastState = EnchantState.NO_ITEM;
+
+ private final LerpingInteger leftScroll = new LerpingInteger(0, 150);
+ private final LerpingInteger rightScroll = new LerpingInteger(0, 150);
+
+ private final LerpingFloat arrowAmount = new LerpingFloat(0, 100);
+
+ private static final int X_SIZE = 364;
+ private static final int Y_SIZE = 215;
+
+ private int clickedScrollOffset = -1;
+ private boolean isClickedScrollLeft = true;
+
+ private boolean isChangingEnchLevel = false;
+
+ private long cancelButtonAnimTime = 0;
+ private long confirmButtonAnimTime = 0;
+
+ public static GuiCustomHex getInstance() {
+ return INSTANCE;
+ }
+
+ public boolean shouldOverride(String containerName) {
+ CalendarOverlay.ableToClickCalendar = true;
+ if (containerName == null) {
+ shouldOverrideET = false;
+ shouldOverrideFast = false;
+ shouldOverrideGemstones = false;
+ shouldOverrideXp = false;
+ searchField.setText("");
+ return false;
+ }
+ boolean config = NotEnoughUpdates.INSTANCE.config.enchantingSolvers.enableTableGUI;
+ final List<String> gemList = new ArrayList<>(Arrays.asList(
+ "\u2764",
+ "\u2748",
+ "\u270e",
+ "\u2618",
+ "\u2e15",
+ "\u2727",
+ "\u2741",
+ "\u2742"
+ ));
+ shouldOverrideFast = config &&
+ (containerName.length() >= 7 && Objects.equals("The Hex", containerName.substring(0, "The Hex".length()))) &&
+ NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard();
+
+ shouldOverrideET = config &&
+ (containerName.length() >= 12 && Objects.equals(
+ "Enchant Item",
+ containerName.substring(0, "Enchant Item".length())
+ )) && NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard();
+
+ shouldOverrideGemstones = config &&
+ (containerName.length() >= 12 && Objects.equals(
+ "Gemstones ➜",
+ containerName.substring(0, "Gemstones ➜".length())
+ )) && NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard();
+ if (shouldOverrideGemstones) {
+ for (String string : gemList) {
+ if (containerName.contains(string)) {
+ shouldOverrideGemstones = false;
+ break;
+ }
+ }
+ }
+
+ shouldOverrideXp = config &&
+ (containerName.length() >= 21 && Objects.equals("Bottles of Enchanting", containerName.substring(0, "Bottles of Enchanting".length()))) &&
+ NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard();
+ GuiContainer chest = ((GuiContainer) Minecraft.getMinecraft().currentScreen);
+ ContainerChest cc = (ContainerChest) chest.inventorySlots;
+ ItemStack hexStack = cc.getLowerChestInventory().getStackInSlot(50);
+ CalendarOverlay.ableToClickCalendar = !(shouldOverrideET || shouldOverrideFast || shouldOverrideGemstones || shouldOverrideXp);
+ if (hexStack != null && hexStack.getItem() == Items.experience_bottle)
+ return (shouldOverrideET || shouldOverrideFast);
+ if (!shouldOverrideFast && !shouldOverrideET && !shouldOverrideGemstones && !shouldOverrideXp) {
+ currentState = EnchantState.NO_ITEM;
+ applicable.clear();
+ removable.clear();
+ applicableItem.clear();
+ removableItem.clear();
+ expectedMaxPage = 1;
+ enchanterCurrentItem = null;
+ searchField.setText("");
+ }
+ return (shouldOverrideFast || shouldOverrideGemstones || shouldOverrideXp);
+ }
+
+ private int tickCounter = 0;
+
+ public void tick(String containerName) {
+ if (containerName.equals("The Hex")) {
+ currentState = EnchantState.HAS_ITEM_IN_HEX;
+ tickHex();
+ } else if (containerName.contains("Enchant Item")) {
+ tickEnchants();
+ } else if (containerName.contains("Books") || containerName.contains("Modifiers") || containerName.contains(
+ "Reforges") || containerName.contains("Item Upgrades") || containerName.equals("Bottles of Enchanting")) {
+ tickBooks();
+ } else if (containerName.contains("Gemstones")) {
+ tickGemstones();
+ } else {
+ tickBooks();
+ }
+ }
+
+ private void tickEnchants() {
+ GuiContainer chest = ((GuiContainer) Minecraft.getMinecraft().currentScreen);
+ ContainerChest cc = (ContainerChest) chest.inventorySlots;
+
+ //ItemStack hexStack = cc.getLowerChestInventory().getStackInSlot(12);
+ ItemStack enchantingItemStack = cc.getLowerChestInventory().getStackInSlot(19);
+ //ItemStack stack = cc.getLowerChestInventory().getStackInSlot(23);
+ ItemStack hopperStack = cc.getLowerChestInventory().getStackInSlot(51);
+
+ int lastPage = currentPage;
+
+ this.lastState = currentState;
+
+ if (hopperStack != null && hopperStack.getItem() != Item.getItemFromBlock(Blocks.hopper) &&
+ enchantingItem != null) {
+ currentState = EnchantState.ADDING_ENCHANT;
+ } else if (enchantingItemStack == null) {
+ if (currentState == EnchantState.SWITCHING_DONT_UPDATE || currentState == EnchantState.NO_ITEM) {
+ currentState = EnchantState.NO_ITEM;
+ } else {
+ currentState = EnchantState.SWITCHING_DONT_UPDATE;
+ }
+ } else {
+ ItemStack sanityCheckStack = cc.getLowerChestInventory().getStackInSlot(12);
+ if (sanityCheckStack == null || sanityCheckStack.getItem() == Items.enchanted_book) {
+ currentState = EnchantState.HAS_ITEM;
+ enchantingItem = enchantingItemStack;
+ } else {
+ currentState = EnchantState.SWITCHING_DONT_UPDATE;
+ }
+ }
+
+ if (currentState == EnchantState.HAS_ITEM) {
+ ItemStack pageUpStack = cc.getLowerChestInventory().getStackInSlot(17);
+ ItemStack pageDownStack = cc.getLowerChestInventory().getStackInSlot(35);
+ if (pageUpStack != null && pageDownStack != null) {
+ currentPage = 0;
+ boolean upIsGlass = pageUpStack.getItem() == Item.getItemFromBlock(Blocks.stained_glass_pane);
+ boolean downIsGlass = pageDownStack.getItem() == Item.getItemFromBlock(Blocks.stained_glass_pane);
+ int page = -1;
+
+ expectedMaxPage = 1;
+ if (!downIsGlass) {
+ try {
+ page = Integer.parseInt(Utils.getRawTooltip(pageDownStack).get(1).substring(11)) - 1;
+ expectedMaxPage = page + 1;
+ } catch (Exception ignored) {
+ }
+ }
+ if (page == -1 && !upIsGlass) {
+ try {
+ page = Integer.parseInt(Utils.getRawTooltip(pageUpStack).get(1).substring(11)) + 1;
+ expectedMaxPage = page;
+ } catch (Exception ignored) {
+ }
+ }
+ if (page == -1) {
+ currentPage = 1;
+ } else {
+ currentPage = page;
+ }
+ }
+ }
+
+ orbDisplay.physicsTickOrbs();
+
+ if (++tickCounter >= 20) {
+ tickCounter = 0;
+ }
+
+ boolean updateItems = tickCounter == 0;
+
+ if (currentState == EnchantState.ADDING_ENCHANT) {
+ if (arrowAmount.getTarget() != 1) {
+ arrowAmount.setTarget(1);
+ arrowAmount.resetTimer();
+ }
+ } else {
+ if (arrowAmount.getTarget() != 0) {
+ arrowAmount.setTarget(0);
+ arrowAmount.resetTimer();
+ }
+ }
+
+ // Set<EnchantState> allowedSwitchStates = Sets.newHashSet(EnchantState.ADDING_ENCHANT, EnchantState.HAS_ITEM, EnchantState.SWITCHING_DONT_UPDATE);
+ if (lastState != currentState || lastPage != currentPage) {
+ // if (!allowedSwitchStates.contains(lastState) || !allowedSwitchStates.contains(currentState)) {
+ leftScroll.setValue(0);
+ rightScroll.setValue(0);
+ // }
+ updateItems = true;
+ }
+
+ if (updateItems && currentState != EnchantState.SWITCHING_DONT_UPDATE) {
+ enchanterEnchLevels.clear();
+
+ if (enchantingItem != null) {
+ playerEnchantIds.clear();
+ NBTTagCompound tag = enchantingItem.getTagCompound();
+ if (tag != null) {
+ NBTTagCompound ea = tag.getCompoundTag("ExtraAttributes");
+ if (ea != null) {
+ NBTTagCompound enchantments = ea.getCompoundTag("enchantments");
+ if (enchantments != null) {
+ for (String enchId : enchantments.getKeySet()) {
+ playerEnchantIds.put(enchId, enchantments.getInteger(enchId));
+ }
+ }
+ }
+ }
+ }
+
+ if (currentState == EnchantState.ADDING_ENCHANT) {
+ removingEnchantPlayerLevel = -1;
+ boolean updateLevel = enchanterCurrentEnch == null;
+ boolean hasXpBottle = false;
+ for (int i = 0; i < 27; i++) {
+ int slotIndex = 9 + i;
+ ItemStack book = cc.getLowerChestInventory().getStackInSlot(slotIndex);
+ ItemStack xpBottle = cc.getLowerChestInventory().getStackInSlot(50);
+ if (!hasXpBottle && xpBottle != null &&
+ xpBottle.getItem() == Items.experience_bottle) { //Make show when in dungeon screen
+ String name = "Buy Xp Bottles";
+ String id = "XP_BOTTLE";
+ Enchantment xpBottleEnch = new Enchantment(50, name, id,
+ Utils.getRawTooltip(xpBottle), 1, true, false
+ );
+ boolean hasHasXpBottle = false;
+ for (Enchantment ench : applicable) {
+ if (ench.enchId.equals("XP_BOTTLE")) {
+ hasHasXpBottle = true;
+ break;
+ }
+ }
+ if (!hasHasXpBottle) applicable.add(xpBottleEnch);
+ hasXpBottle = true;
+ }
+ if (book != null && book.getItem() == Items.enchanted_book) {
+ NBTTagCompound tagBook = book.getTagCompound();
+ if (tagBook != null) {
+ NBTTagCompound ea = tagBook.getCompoundTag("ExtraAttributes");
+ if (ea != null) {
+ NBTTagCompound enchantments = ea.getCompoundTag("enchantments");
+ if (enchantments != null) {
+ String enchId = Utils.cleanColour(book.getDisplayName()).toLowerCase().replace(" ", "_").replace(
+ "-",
+ "_"
+ );
+ String name = Utils.cleanColour(book.getDisplayName());
+ int enchLevel = -1;
+ if (name.equalsIgnoreCase("Bane of Arthropods")) {
+ name = "Bane of Arth.";
+ } else if (name.equalsIgnoreCase("Projectile Protection")) {
+ name = "Projectile Prot";
+ } else if (name.equalsIgnoreCase("Blast Protection")) {
+ name = "Blast Prot";
+ } else if (name.equalsIgnoreCase("Turbo-Mushrooms")) {
+ name = "Turbo-Mush";
+ }
+ Matcher levelMatcher = ENCHANT_LEVEL_PATTERN.matcher(enchId);
+ if (levelMatcher.matches()) {
+ enchLevel = Utils.parseRomanNumeral(levelMatcher.group(2).toUpperCase());
+ enchId = levelMatcher.group(1);
+ }
+ Enchantment enchantment = new Enchantment(slotIndex, name, enchId,
+ Utils.getRawTooltip(book), enchLevel, false, true
+ );
+ int index = 0;
+ for (String lore : enchantment.displayLore) {
+ if (lore.contains("N/A") && enchantment.price > 0) {
+ String price = numberFormat.format(enchantment.price);
+ enchantment.displayLore.set(index, "\u00a76" + price + ".0 Coins");
+ }
+ index++;
+ }
+ enchantment.displayLore.remove(0);
+
+ if (removingEnchantPlayerLevel == -1 && playerEnchantIds.containsKey(enchId)) {
+ removingEnchantPlayerLevel = playerEnchantIds.get(enchId);
+ }
+
+ if (removingEnchantPlayerLevel >= 0 && enchantment.level < removingEnchantPlayerLevel) {
+ continue;
+ }
+
+ if (enchanterCurrentEnch == null) {
+ enchanterCurrentEnch = enchantment;
+ } else if (updateLevel) {
+ if (removingEnchantPlayerLevel < 0 && enchantment.level > enchanterCurrentEnch.level) {
+ enchanterCurrentEnch = enchantment;
+ } else if (removingEnchantPlayerLevel >= 0 && enchantment.level < enchanterCurrentEnch.level) {
+ enchanterCurrentEnch = enchantment;
+ }
+ }
+
+ enchanterEnchLevels.put(enchantment.level, enchantment);
+ }
+ }
+ }
+ }
+ }
+ if (enchanterCurrentEnch != null && removingEnchantPlayerLevel >= 0) {
+ for (String line : enchanterCurrentEnch.displayLore) {
+ Matcher matcher = XP_COST_PATTERN.matcher(line);
+ if (matcher.find()) {
+ enchanterCurrentEnch.xpCost = Integer.parseInt(matcher.group(1));
+ }
+ }
+ }
+ } else {
+ isChangingEnchLevel = false;
+ enchanterCurrentEnch = null;
+
+ searchRemovedFromRemovable = false;
+ searchRemovedFromApplicable = false;
+ applicable.clear();
+ removable.clear();
+ boolean hasXpBottle = false;
+ if (currentState == EnchantState.HAS_ITEM) {
+ for (int i = 0; i < 15; i++) {
+ int slotIndex = 12 + (i % 5) + (i / 5) * 9;
+ ItemStack book = cc.getLowerChestInventory().getStackInSlot(slotIndex);
+ ItemStack xpBottle = cc.getLowerChestInventory().getStackInSlot(50);
+ if (!hasXpBottle && xpBottle != null &&
+ xpBottle.getItem() == Items.experience_bottle) { //Make show when in dungeon screen
+ String name = "Buy Xp Bottles";
+ String id = "XP_BOTTLE";
+ Enchantment xpBottleEnch = new Enchantment(50, name, id,
+ Utils.getRawTooltip(xpBottle), 1, true, false
+ );
+ applicable.add(xpBottleEnch);
+ hasXpBottle = true;
+ }
+ if (book != null) {
+ NBTTagCompound tagBook = book.getTagCompound();
+ if (tagBook != null) {
+ NBTTagCompound ea = tagBook.getCompoundTag("ExtraAttributes");
+ if (ea != null) {
+ NBTTagCompound enchantments = ea.getCompoundTag("enchantments");
+ if (enchantments != null) {
+ String enchId = Utils
+ .cleanColour(book.getDisplayName())
+ .toLowerCase()
+ .replace(" ", "_")
+ .replace("-", "_");
+ if (enchId.equalsIgnoreCase("_")) continue;
+ if (enchId.equals("prosecute")) {
+ enchId = "PROSECUTE";
+ }
+ String name = Utils.cleanColour(book.getDisplayName());
+
+ if (searchField.getText().trim().isEmpty() ||
+ name.toLowerCase().contains(searchField.getText().trim().toLowerCase())) {
+ if (name.equalsIgnoreCase("Bane of Arthropods")) {
+ name = "Bane of Arth.";
+ } else if (name.equalsIgnoreCase("Projectile Protection")) {
+ name = "Projectile Prot";
+ } else if (name.equalsIgnoreCase("Blast Protection")) {
+ name = "Blast Prot";
+ } else if (name.equalsIgnoreCase("Turbo-Mushrooms")) {
+ name = "Turbo-Mush";
+ }
+ Matcher nameMatcher = ENCHANT_NAME_PATTERN.matcher(name);
+ if (nameMatcher.matches()) {
+ name = nameMatcher.group(1);
+ }
+
+ if (playerEnchantIds.containsKey(enchId)) {
+ Enchantment enchantment = new Enchantment(slotIndex, name, enchId,
+ Utils.getRawTooltip(book), playerEnchantIds.get(enchId), false, false
+ );
+ if (!enchantment.overMaxLevel) {
+ removable.add(enchantment);
+ }
+ } else {
+ Enchantment enchantment = new Enchantment(slotIndex, name, enchId,
+ Utils.getRawTooltip(book), 1, true, true
+ );
+ applicable.add(enchantment);
+ }
+ } else {
+ if (playerEnchantIds.containsKey(enchId)) {
+ searchRemovedFromRemovable = true;
+ } else {
+ searchRemovedFromApplicable = true;
+ }
+ }
+
+ }
+ }
+ }
+ }
+ }
+ NEUConfig cfg = NotEnoughUpdates.INSTANCE.config;
+ int mult = cfg.enchantingSolvers.enchantOrdering == 0 ? 1 : -1;
+ Comparator<Enchantment> comparator = cfg.enchantingSolvers.enchantSorting == 0 ?
+ Comparator.comparingInt(e -> mult * e.xpCost) :
+ (c1, c2) -> mult *
+ c1.enchId.toLowerCase().compareTo(c2.enchId.toLowerCase());
+ removable.sort(comparator);
+ applicable.sort(comparator);
+ }
+ }
+ }
+
+ //Update book model state
+ if (lastState != currentState) {
+ do {
+ this.pageOpenRandom += (float) (this.random.nextInt(4) - this.random.nextInt(4));
+
+ } while (!(this.pageOpen > this.pageOpenRandom + 1.0F) && !(this.pageOpen < this.pageOpenRandom - 1.0F));
+ }
+
+ this.pageOpenLast = this.pageOpen;
+ this.bookOpenLast = this.bookOpen;
+
+ if (currentState == EnchantState.HAS_ITEM || currentState == EnchantState.ADDING_ENCHANT) {
+ this.bookOpen += 0.2F;
+ } else {
+ this.bookOpen -= 0.2F;
+ }
+
+ this.bookOpen = MathHelper.clamp_float(this.bookOpen, 0.0F, 1.0F);
+ float f1 = (this.pageOpenRandom - this.pageOpen) * 0.4F;
+ f1 = MathHelper.clamp_float(f1, -0.2F, 0.2F);
+ this.pageOpenVelocity += (f1 - this.pageOpenVelocity) * 0.9F;
+ this.pageOpen += this.pageOpenVelocity;
+ }
+
+ private void tickBooks() {
+ GuiContainer chest = ((GuiContainer) Minecraft.getMinecraft().currentScreen);
+ ContainerChest cc = (ContainerChest) chest.inventorySlots;
+
+ ItemStack enchantingItemStack = cc.getLowerChestInventory().getStackInSlot(19);
+ ItemStack anvilStack = cc.getLowerChestInventory().getStackInSlot(28);
+
+ this.lastState = currentState;
+
+ if (anvilStack != null && anvilStack.getItem() == Item.getItemFromBlock(Blocks.anvil) &&
+ currentState != EnchantState.ADDING_BOOK) {
+ currentState = EnchantState.HAS_ITEM_IN_BOOKS;
+ enchantingItem = enchantingItemStack;
+ } else if (currentState == EnchantState.HAS_ITEM_IN_BOOKS && enchantingItem == null &&
+ enchantingItemStack != null) {
+ enchantingItem = enchantingItemStack;
+ } else if (anvilStack != null && anvilStack.getItem() == Item.getItemFromBlock(Blocks.enchanting_table) &&
+ currentState != EnchantState.ADDING_BOOK) {
+ currentState = EnchantState.HAS_ITEM_IN_BOOKS;
+ enchantingItem = enchantingItemStack;
+ }
+
+ orbDisplay.physicsTickOrbs();
+
+ if (++tickCounter >= 20) {
+ tickCounter = 0;
+ }
+
+ if (currentState == EnchantState.ADDING_BOOK) {
+ if (arrowAmount.getTarget() != 1) {
+ arrowAmount.setTarget(1);
+ arrowAmount.resetTimer();
+ }
+ } else {
+ if (arrowAmount.getTarget() != 0) {
+ arrowAmount.setTarget(0);
+ arrowAmount.resetTimer();
+ }
+ }
+
+ isChangingEnchLevel = false;
+
+ searchRemovedFromRemovable = false;
+ searchRemovedFromApplicable = false;
+ if (applicableItem.size() < 6) leftScroll.setValue(0);
+ applicableItem.clear();
+ removableItem.clear();
+ if (currentState == EnchantState.HAS_ITEM_IN_BOOKS || currentState == EnchantState.ADDING_BOOK) {
+ boolean hasRandomReforge = false;
+ for (int i = 0; i < 15; i++) {
+ int slotIndex = 12 + (i % 5) + (i / 5) * 9;
+ ItemStack book = cc.getLowerChestInventory().getStackInSlot(slotIndex);
+ ItemStack randomReforge = cc.getLowerChestInventory().getStackInSlot(48);
+ if (!hasRandomReforge && randomReforge != null &&
+ randomReforge.getItem() == Item.getItemFromBlock(Blocks.anvil)) { //Make show when in dungeon screen
+ String name = Utils.cleanColour(randomReforge.getDisplayName());
+ String id = Utils.cleanColour(randomReforge.getDisplayName());
+ if (name.equals("Convert to Dungeon Item")) {
+ name = "Dungeonize Item";
+ id = "CONVERT_TO_DUNGEON";
+ } else if (name.equals("Random Basic Reforge")) {
+ name = "Basic Reforge";
+ id = "RANDOM_REFORGE";
+ }
+ HexItem reforgeItem = new HexItem(48, name, id,
+ Utils.getRawTooltip(randomReforge), true, true
+ );
+ boolean hasAdded = false;
+ for (String lore : reforgeItem.displayLore) {
+ if (lore.contains("This item is already a Dungeon")) {
+ removableItem.add(reforgeItem);
+ hasAdded = true;
+ break;
+ }
+ }
+ if (!hasAdded) applicableItem.add(reforgeItem);
+ hasRandomReforge = true;
+ }
+ if (book != null) {
+ NBTTagCompound tagBook = book.getTagCompound();
+ if (tagBook != null) {
+ NBTTagCompound ea = tagBook.getCompoundTag("ExtraAttributes");
+ if (ea != null) {
+ NBTTagCompound enchantments = ea.getCompoundTag("enchantments");
+ if (enchantments != null) {
+ String itemId = Utils.cleanColour(book.getDisplayName()).toUpperCase().replace(" ", "_").replace(
+ "-",
+ "_"
+ );
+ String name = Utils.cleanColour(book.getDisplayName());
+ if (itemId.equalsIgnoreCase("_")) continue;
+ if (itemId.equalsIgnoreCase("Item_Maxed_Out")) continue;
+ if (searchField.getText().trim().isEmpty() ||
+ name.toLowerCase().contains(searchField.getText().trim().toLowerCase())) {
+ if (name.equalsIgnoreCase("Hot Potato Book")) {
+ name = "Hot Potato";
+ } else if (name.equalsIgnoreCase("Fuming Potato Book")) {
+ name = "Fuming Potato";
+ } else if (name.equalsIgnoreCase("Recombobulator 3000")) {
+ name = "Recombobulator";
+ } else if (name.contains("Power Scroll")) {
+ name = name.replace("Power ", "");
+ } else if (name.contains("\u272a")) {
+ name = name.replaceAll("[^✪]*", "");
+ } else if (name.equalsIgnoreCase("First Master Star")) {
+ name = "Master Star \u00a7c➊";
+ } else if (name.equalsIgnoreCase("Second Master Star")) {
+ name = "Master Star \u00a7c➋";
+ } else if (name.equalsIgnoreCase("Third Master Star")) {
+ name = "Master Star \u00a7c➌";
+ } else if (name.equalsIgnoreCase("Fourth Master Star")) {
+ name = "Master Star \u00a7c➍";
+ } else if (name.equalsIgnoreCase("Fifth Master Star")) {
+ name = "Master Star \u00a7c➎";
+ } else if (name.equalsIgnoreCase("The Art Of Peace")) {
+ name = "Art Of Peace";
+ } else if (name.equalsIgnoreCase("Mana Disintegrator")) {
+ name = "M Disintegrator";
+ }
+ /*if (playerEnchantIds.containsKey(itemId)) {
+ HexItem item = new HexItem(slotIndex, name, itemId,
+ Utils.getRawTooltip(book), false, false
+ );
+ if (!item.overMaxLevel) {
+ removableItem.add(item);
+ }
+ enchanterItemLevels.put(item.level, item);
+ } else */
+ {
+ HexItem item = new HexItem(slotIndex, name, itemId,
+ Utils.getRawTooltip(book), true, true
+ );
+ enchanterItemLevels.put(item.level, item);
+ if (item.itemType != ItemType.UNKNOWN) {
+ int potatoCount = 0;
+ int killCount = 0;
+ int warCount = 0;
+ int ffdCount = 0;
+ int recombCount = 0;
+ int effLevel = 0;
+ int starCount = 0;
+ int singularityCount = 0;
+ int tunerCount = 0;
+ int peaceCount = 0;
+ int manaDisintegratorCount = 0;
+ boolean shadowWarp = false;
+ boolean witherShield = false;
+ boolean implosion = false;
+ String reforge = "";
+ if (enchantingItem != null) {
+ NBTTagCompound tagItem = enchantingItem.getTagCompound();
+ if (tagItem != null) {
+ NBTTagCompound extra = tagItem.getCompoundTag("ExtraAttributes");
+ if (extra != null) {
+ potatoCount = extra.getInteger("hot_potato_count");
+ killCount = extra.getInteger("stats_book");
+ warCount = extra.getInteger("art_of_war_count");
+ ffdCount = extra.getInteger("farming_for_dummies_count");
+ recombCount = extra.getInteger("rarity_upgrades");
+ starCount = extra.getInteger("upgrade_level");
+ singularityCount = extra.getInteger("wood_singularity_count");
+ tunerCount = extra.getInteger("tuned_transmission");
+ peaceCount = extra.getInteger("art_of_peace_count");
+ manaDisintegratorCount = extra.getInteger("mana_disintegrator_count");
+ reforge = extra.getString("modifier");
+ NBTTagCompound enchs = extra.getCompoundTag("enchantments");
+ NBTTagList scrolls = extra.getTagList("ability_scroll", 8);
+ if (enchs != null) {
+ effLevel = enchs.getInteger("efficiency");
+ }
+ if (scrolls != null) {
+ for (int index = 0; index < scrolls.tagCount(); index++) {
+ if (scrolls.getStringTagAt(index).equals("IMPLOSION_SCROLL")) {
+ implosion = true;
+ } else if (scrolls.getStringTagAt(index).equals("SHADOW_WARP_SCROLL")) {
+ shadowWarp = true;
+ } else if (scrolls.getStringTagAt(index).equals("WITHER_SHIELD_SCROLL")) {
+ witherShield = true;
+ }
+ }
+ }
+ }
+ }
+ }
+ if (item.itemName.length() > 14) item.itemName = item.itemName.substring(0, 14);
+
+ if (item.itemType == ItemType.HOT_POTATO) {
+ if (potatoCount < 10) applicableItem.add(item);
+ else removableItem.add(item);
+
+ } else if (item.itemType == ItemType.FUMING_POTATO) {
+ if (potatoCount >= 10 && potatoCount < 15) applicableItem.add(item);
+ else if (potatoCount >= 15) removableItem.add(item);
+
+ } else if (item.itemType == ItemType.BOOK_OF_STATS) {
+ if (killCount > 0) removableItem.add(item);
+ else applicableItem.add(item);
+
+ } else if (item.itemType == ItemType.ART_OF_WAR) {
+ if (warCount > 0) removableItem.add(item);
+ else applicableItem.add(item);
+
+ } else if (item.itemType == ItemType.FARMING_DUMMY) {
+ if (ffdCount < 5) applicableItem.add(item);
+ else removableItem.add(item);
+
+ } else if (item.itemType == ItemType.RECOMB) {
+ if (recombCount > 0) removableItem.add(item);
+ else applicableItem.add(item);
+
+ } else if (item.itemType == ItemType.SILEX) {
+ if (effLevel >= 5 && effLevel < 10) applicableItem.add(item);
+ else if (effLevel == 10) removableItem.add(item);
+
+ } else if (item.isPowerScroll()) {
+ applicableItem.add(item);
+
+ } else if (item.isMasterStar()) {
+ applicableItem.add(item);
+
+ } else if (item.isDungeonStar()) {
+ if (starCount >= item.itemType.getStarLevel()) removableItem.add(item);
+ else applicableItem.add(item);
+
+ } else if (item.itemType == ItemType.WOOD_SINGULARITY) {
+ if (singularityCount > 0) removableItem.add(item);
+ else applicableItem.add(item);
+
+ } else if (item.isHypeScroll()) {
+ if (shadowWarp) removableItem.add(item);
+ else if (implosion) removableItem.add(item);
+ else if (witherShield) removableItem.add(item);
+ else applicableItem.add(item);
+
+ } else if (item.itemType == ItemType.TUNER) {
+ if (tunerCount >= 4) removableItem.add(item);
+ else applicableItem.add(item);
+
+ } else if (item.itemType == ItemType.REFORGE) {
+ if (item.getReforge().equalsIgnoreCase(reforge) && !reforge.equals("")) removableItem.add(item);
+ else applicableItem.add(item);
+
+ } else if (item.itemType == ItemType.ART_OF_PEACE) {
+ if (peaceCount > 0) removableItem.add(item);
+ else applicableItem.add(item);
+
+ } else if (item.itemType == ItemType.MANA_DISINTEGRATOR) {
+ if (manaDisintegratorCount >= 10) removableItem.add(item);
+ else applicableItem.add(item);
+
+ } else {
+ applicableItem.add(item);
+ }
+ } else {
+ applicableItem.add(item);
+ }
+ }
+ } else {
+ if (playerEnchantIds.containsKey(itemId)) {
+ searchRemovedFromRemovable = true;
+ } else {
+ searchRemovedFromApplicable = true;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ NEUConfig cfg = NotEnoughUpdates.INSTANCE.config;
+ int mult = cfg.enchantingSolvers.enchantOrdering == 0 ? 1 : -1;
+ Comparator<HexItem> comparator = cfg.enchantingSolvers.enchantSorting == 0 ?
+ Comparator.comparingInt(e -> (int) (mult * e.price)) :
+ (c1, c2) -> mult *
+ c1.itemId.toLowerCase().compareTo(c2.itemId.toLowerCase());
+ removableItem.sort(comparator);
+ applicableItem.sort(comparator);
+ }
+ }
+
+ private void tickHex() {
+ GuiContainer chest = ((GuiContainer) Minecraft.getMinecraft().currentScreen);
+ ContainerChest cc = (ContainerChest) chest.inventorySlots;
+
+ ItemStack enchantingItemStack = cc.getLowerChestInventory().getStackInSlot(22);
+ ItemStack glassStack = cc.getLowerChestInventory().getStackInSlot(12);
+ //ItemStack anvilStack = cc.getLowerChestInventory().getStackInSlot(28);
+
+ this.lastState = currentState;
+
+ if (enchantingItemStack != null) {
+ if (glassStack.getItem() != null && glassStack.getItem() == Item.getItemFromBlock(Blocks.stained_glass_pane)) {
+ if (glassStack.getItemDamage() == 14) {
+