diff options
Diffstat (limited to 'src/main')
63 files changed, 3524 insertions, 154 deletions
diff --git a/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt b/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt index 6c05aadbd..d7d68ba78 100644 --- a/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt +++ b/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt @@ -11,12 +11,14 @@ import at.hannibal2.skyhanni.config.SackData import at.hannibal2.skyhanni.config.commands.Commands.init import at.hannibal2.skyhanni.data.ActionBarData import at.hannibal2.skyhanni.data.ActionBarStatsData +import at.hannibal2.skyhanni.data.BitsAPI import at.hannibal2.skyhanni.data.BlockData import at.hannibal2.skyhanni.data.BossbarData import at.hannibal2.skyhanni.data.ChatManager import at.hannibal2.skyhanni.data.CropAccessoryData import at.hannibal2.skyhanni.data.EntityData import at.hannibal2.skyhanni.data.EntityMovementData +import at.hannibal2.skyhanni.data.FameRanks import at.hannibal2.skyhanni.data.FriendAPI import at.hannibal2.skyhanni.data.GardenComposterUpgradesData import at.hannibal2.skyhanni.data.GardenCropMilestones @@ -30,7 +32,8 @@ import at.hannibal2.skyhanni.data.ItemClickData import at.hannibal2.skyhanni.data.ItemRenderBackground import at.hannibal2.skyhanni.data.ItemTipHelper import at.hannibal2.skyhanni.data.LocationFixData -import at.hannibal2.skyhanni.data.MayorElection +import at.hannibal2.skyhanni.data.MaxwellAPI +import at.hannibal2.skyhanni.data.MayorAPI import at.hannibal2.skyhanni.data.MinecraftData import at.hannibal2.skyhanni.data.OtherInventoryData import at.hannibal2.skyhanni.data.OwnInventoryData @@ -38,6 +41,7 @@ import at.hannibal2.skyhanni.data.PartyAPI import at.hannibal2.skyhanni.data.PetAPI import at.hannibal2.skyhanni.data.ProfileStorageData import at.hannibal2.skyhanni.data.PurseAPI +import at.hannibal2.skyhanni.data.QuiverAPI import at.hannibal2.skyhanni.data.RenderData import at.hannibal2.skyhanni.data.SackAPI import at.hannibal2.skyhanni.data.ScoreboardData @@ -284,6 +288,8 @@ import at.hannibal2.skyhanni.features.misc.TpsCounter import at.hannibal2.skyhanni.features.misc.compacttablist.AdvancedPlayerList import at.hannibal2.skyhanni.features.misc.compacttablist.TabListReader import at.hannibal2.skyhanni.features.misc.compacttablist.TabListRenderer +import at.hannibal2.skyhanni.features.gui.customscoreboard.CustomScoreboard +import at.hannibal2.skyhanni.features.gui.customscoreboard.ScoreboardPattern import at.hannibal2.skyhanni.features.misc.discordrpc.DiscordRPCManager import at.hannibal2.skyhanni.features.misc.items.AuctionHouseCopyUnderbidPrice import at.hannibal2.skyhanni.features.misc.items.EstimatedItemValue @@ -445,7 +451,6 @@ class SkyHanniMod { loadModule(GetFromSackAPI) loadModule(UpdateManager) loadModule(CropAccessoryData()) - loadModule(MayorElection()) loadModule(GardenComposterUpgradesData()) loadModule(ActionBarStatsData) loadModule(GardenCropMilestoneInventory()) @@ -464,6 +469,7 @@ class SkyHanniMod { loadModule(GardenBestCropTime()) loadModule(ActionBarData) loadModule(TrackerManager) + loadModule(ScoreboardPattern) loadModule(UtilsPatterns) loadModule(PetAPI) loadModule(BossbarData) @@ -485,7 +491,12 @@ class SkyHanniMod { loadModule(RiftAPI) loadModule(SackAPI) loadModule(BingoAPI) + loadModule(FameRanks) loadModule(FishingAPI) + loadModule(MaxwellAPI) + loadModule(QuiverAPI) + loadModule(BitsAPI) + loadModule(MayorAPI) loadModule(SkillAPI) loadModule(IsFishingDetection) loadModule(LorenzUtils) @@ -748,6 +759,7 @@ class SkyHanniMod { loadModule(DungeonFinderFeatures()) loadModule(PabloHelper()) loadModule(FishingBaitWarnings()) + loadModule(CustomScoreboard()) loadModule(RepoPatternManager) loadModule(PestSpawn()) loadModule(PestSpawnTimer) diff --git a/src/main/java/at/hannibal2/skyhanni/config/Storage.java b/src/main/java/at/hannibal2/skyhanni/config/Storage.java index 597d3a7eb..95286550c 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/Storage.java +++ b/src/main/java/at/hannibal2/skyhanni/config/Storage.java @@ -1,5 +1,6 @@ package at.hannibal2.skyhanni.config; +import at.hannibal2.skyhanni.data.FameRank; import at.hannibal2.skyhanni.api.SkillAPI; import at.hannibal2.skyhanni.data.model.ComposterUpgrade; import at.hannibal2.skyhanni.features.bingo.card.goals.BingoGoal; @@ -78,6 +79,9 @@ public class Storage { @Expose public Map<UUID, PlayerSpecific> players = new HashMap<>(); + @Expose + public String currentFameRank = null; + public static class PlayerSpecific { @Expose @@ -147,6 +151,39 @@ public class Storage { public String currentPet = ""; @Expose + public MaxwellPowerStorage maxwell = new MaxwellPowerStorage(); + + public static class MaxwellPowerStorage { + @Expose + public String currentPower = null; + + @Expose + public int magicalPower = -1; + } + + @Expose + public ArrowsStorage arrows = new ArrowsStorage(); + + public static class ArrowsStorage { + @Expose + public String currentArrow = null; + + @Expose + public Map<NEUInternalName, Float> arrowAmount = new HashMap<>(); + } + + @Expose + public BitsStorage bits = new BitsStorage(); + + public static class BitsStorage { + @Expose + public int bits = -1; + + @Expose + public int bitsToClaim = -1; + } + + @Expose public Map<LorenzVec, MinionConfig> minions = new HashMap<>(); public static class MinionConfig { diff --git a/src/main/java/at/hannibal2/skyhanni/config/core/config/gui/GuiPositionEditor.kt b/src/main/java/at/hannibal2/skyhanni/config/core/config/gui/GuiPositionEditor.kt index f6765ca2b..88264e994 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/core/config/gui/GuiPositionEditor.kt +++ b/src/main/java/at/hannibal2/skyhanni/config/core/config/gui/GuiPositionEditor.kt @@ -19,6 +19,7 @@ package at.hannibal2.skyhanni.config.core.config.gui import at.hannibal2.skyhanni.config.core.config.Position +import at.hannibal2.skyhanni.data.GuiEditManager import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getAbsX import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getAbsY import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getDummySize @@ -216,6 +217,7 @@ class GuiPositionEditor(private val positions: List<Position>, private val borde val elementHeight = position.getDummySize(true).y grabbedX += position.moveX(mouseX - grabbedX, elementWidth) grabbedY += position.moveY(mouseY - grabbedY, elementHeight) + GuiEditManager.handleGuiPositionMoved(position.internalName) } } diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/dev/DevConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/dev/DevConfig.java index 89170c027..3b5200c39 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/features/dev/DevConfig.java +++ b/src/main/java/at/hannibal2/skyhanni/config/features/dev/DevConfig.java @@ -44,6 +44,11 @@ public class DevConfig { @ConfigEditorBoolean public boolean worldEdit = false; + @Expose + @ConfigOption(name = "Bow Sound distance", desc = "The distance in blocks where the sound of shooting a bow will be used for the QuiverAPI.") + @ConfigEditorSlider(minValue = 0, maxValue = 50, minStep = 1) + public int bowSoundDistance = 5; + @ConfigOption(name = "Parkour Waypoints", desc = "") @Accordion @Expose diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/gui/GUIConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/gui/GUIConfig.java index 4eeadf221..10b6cdde1 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/features/gui/GUIConfig.java +++ b/src/main/java/at/hannibal2/skyhanni/config/features/gui/GUIConfig.java @@ -2,9 +2,11 @@ package at.hannibal2.skyhanni.config.features.gui; import at.hannibal2.skyhanni.config.FeatureToggle; import at.hannibal2.skyhanni.config.core.config.Position; +import at.hannibal2.skyhanni.config.features.gui.customscoreboard.CustomScoreboardConfig; import at.hannibal2.skyhanni.data.GuiEditManager; import com.google.gson.annotations.Expose; import io.github.moulberry.moulconfig.annotations.Accordion; +import io.github.moulberry.moulconfig.annotations.Category; import io.github.moulberry.moulconfig.annotations.ConfigEditorBoolean; import io.github.moulberry.moulconfig.annotations.ConfigEditorButton; import io.github.moulberry.moulconfig.annotations.ConfigEditorKeybind; @@ -29,6 +31,10 @@ public class GUIConfig { public float globalScale = 1F; @Expose + @Category(name = "Custom Scoreboard", desc = "Custom Scoreboard Settings") + public CustomScoreboardConfig customScoreboard = new CustomScoreboardConfig(); + + @Expose @ConfigOption(name = "Modify Visual Words", desc = "") @Accordion public ModifyWordsConfig modifyWords = new ModifyWordsConfig(); diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/AlignmentConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/AlignmentConfig.java new file mode 100644 index 000000000..a5a8170f3 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/AlignmentConfig.java @@ -0,0 +1,20 @@ +package at.hannibal2.skyhanni.config.features.gui.customscoreboard; + +import com.google.gson.annotations.Expose; +import io.github.moulberry.moulconfig.annotations.ConfigEditorBoolean; +import io.github.moulberry.moulconfig.annotations.ConfigOption; + +public class AlignmentConfig { + // TODO: Switch to Dropdowns with multiple different alignment ways in the future + // Horizontal: Left, Center, Right + // Vertical: Top, Center, Bottom + @Expose + @ConfigOption(name = "Align to the right", desc = "Align the scoreboard to the right side of the screen.") + @ConfigEditorBoolean + public boolean alignRight = true; + + @Expose + @ConfigOption(name = "Align to the center vertically", desc = "Align the scoreboard to the center of the screen vertically.") + @ConfigEditorBoolean + public boolean alignCenterVertically = true; +} diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/BackgroundConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/BackgroundConfig.java new file mode 100644 index 000000000..3b4924511 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/BackgroundConfig.java @@ -0,0 +1,66 @@ +package at.hannibal2.skyhanni.config.features.gui.customscoreboard; + +import com.google.gson.annotations.Expose; +import io.github.moulberry.moulconfig.annotations.ConfigEditorBoolean; +import io.github.moulberry.moulconfig.annotations.ConfigEditorColour; +import io.github.moulberry.moulconfig.annotations.ConfigEditorInfoText; +import io.github.moulberry.moulconfig.annotations.ConfigEditorSlider; +import io.github.moulberry.moulconfig.annotations.ConfigOption; + +public class BackgroundConfig { + @Expose + @ConfigOption( + name = "Enabled", + desc = "Show a background behind the scoreboard." + ) + @ConfigEditorBoolean + public boolean enabled = true; + + @Expose + @ConfigOption( + name = "Background Color", + desc = "The color of the background." + ) + @ConfigEditorColour + public String color = "0:102:0:0:0"; + + @Expose + @ConfigOption( + name = "Background Border Size", + desc = "The size of the border around the background." + ) + @ConfigEditorSlider( + minValue = 0, + maxValue = 20, + minStep = 1 + ) + public int borderSize = 5; + + @Expose + @ConfigOption( + name = "Rounded Corner Smoothness", + desc = "The smoothness of the rounded corners." + ) + @ConfigEditorSlider( + minValue = 0, + maxValue = 30, + minStep = 1 + ) + public int roundedCornerSmoothness = 10; + + @Expose + @ConfigOption( + name = "Use Custom Background Image", + desc = "Put that image into a resource pack, using the path \"skyhanni/scoreboard.png\"." + ) + @ConfigEditorBoolean + public boolean useCustomBackgroundImage = false; + + @Expose + @ConfigOption( + name = "Custom Background", + desc = "Add an image named \"scoreboard.png\" to your texture pack at \"\\assets\\skyhanni\\scoreboard.png.\" Activate the texture pack in Minecraft, then reload the game." + ) + @ConfigEditorInfoText + public String useless; +} diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/CustomScoreboardConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/CustomScoreboardConfig.java new file mode 100644 index 000000000..4941caf5c --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/CustomScoreboardConfig.java @@ -0,0 +1,65 @@ +package at.hannibal2.skyhanni.config.features.gui.customscoreboard; + +import at.hannibal2.skyhanni.config.FeatureToggle; +import at.hannibal2.skyhanni.config.core.config.Position; +import at.hannibal2.skyhanni.features.gui.customscoreboard.ScoreboardElement; +import com.google.gson.annotations.Expose; +import io.github.moulberry.moulconfig.annotations.Accordion; +import io.github.moulberry.moulconfig.annotations.ConfigEditorBoolean; +import io.github.moulberry.moulconfig.annotations.ConfigEditorDraggableList; +import io.github.moulberry.moulconfig.annotations.ConfigOption; + +import java.util.ArrayList; +import java.util.List; + +public class CustomScoreboardConfig { + @Expose + @ConfigOption( + name = "Enabled", + desc = "Show a custom scoreboard instead of the vanilla one." + ) + @ConfigEditorBoolean + @FeatureToggle + public boolean enabled = false; + + @Expose + @ConfigOption( + name = "Appearance", + desc = "Drag text to change the appearance of the advanced scoreboard." // supporting both custom & advanced search + ) + @ConfigEditorDraggableList() + public List<ScoreboardElement> scoreboardEntries = new ArrayList<>(ScoreboardElement.getEntries()); + + @Expose + @ConfigOption(name = "Display Options", desc = "") + @Accordion + public DisplayConfig displayConfig = new DisplayConfig(); + + @Expose + @ConfigOption(name = "Information Filtering", desc = "") + @Accordion + public InformationFilteringConfig informationFilteringConfig = new InformationFilteringConfig(); + + @Expose + @ConfigOption(name = "Background Options", desc = "") + @Accordion + public BackgroundConfig backgroundConfig = new BackgroundConfig(); + + @Expose + @ConfigOption(name = "Party Options", desc = "") + @Accordion + public PartyConfig partyConfig = new PartyConfig(); + + @Expose + @ConfigOption(name = "Mayor Options", desc = "") + @Accordion + public MayorConfig mayorConfig = new MayorConfig(); + + @Expose + @ConfigOption(name = "Unknown Lines warning", desc = "Gives a chat warning when unknown lines are found in the scoreboard.") + @ConfigEditorBoolean + public boolean unknownLinesWarning = true; + + @Expose + public Position position = new Position(10, 80, false, true); +} diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/DisplayConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/DisplayConfig.java new file mode 100644 index 000000000..f009533ba --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/DisplayConfig.java @@ -0,0 +1,96 @@ +package at.hannibal2.skyhanni.config.features.gui.customscoreboard; + +import at.hannibal2.skyhanni.config.FeatureToggle; +import com.google.gson.annotations.Expose; +import io.github.moulberry.moulconfig.annotations.Accordion; +import io.github.moulberry.moulconfig.annotations.ConfigEditorBoolean; +import io.github.moulberry.moulconfig.annotations.ConfigEditorDropdown; +import io.github.moulberry.moulconfig.annotations.ConfigOption; + +public class DisplayConfig { + @Expose + @ConfigOption(name = "Hide Vanilla Scoreboard", desc = "Hide the vanilla scoreboard.") + @ConfigEditorBoolean + @FeatureToggle + public boolean hideVanillaScoreboard = true; + + @Expose + @ConfigOption(name = "Display Numbers First", desc = "Determines whether the number or line name displays first. " + + "§eNote: Will not update the preview above!") + @ConfigEditorBoolean + public boolean displayNumbersFirst = false; + + @Expose + @ConfigOption(name = "Show unclaimed bits", desc = "Show the amount of available Bits that can still be claimed.") + @ConfigEditorBoolean + public boolean showUnclaimedBits = false; + + @Expose + @ConfigOption(name = "Show all active events", desc = "Show all active events in the scoreboard instead of one.") + @ConfigEditorBoolean + public boolean showAllActiveEvents = false; + + @Expose + @ConfigOption(name = "Cache Scoreboard on Island Switch", + desc = "Will stop the Scoreboard from updating while switching islands.\nRemoves the shaking when loading data.") + @ConfigEditorBoolean + public boolean cacheScoreboardOnIslandSwitch = false; + + @Expose + @ConfigOption(name = "Number Format", desc = "") + @ConfigEditorDropdown + public NumberFormat numberFormat = NumberFormat.LONG; + + public enum NumberFormat { + LONG("1,234,567"), + SHORT("1.2M"); + + private final String str; + + NumberFormat(String str) { + this.str = str; + } + + @Override + public String toString() { + return str; + } + } + + @Expose + @ConfigOption(name = "Arrow Amount Display", desc = "Determines how the arrow amount is displayed.") + @ConfigEditorDropdown + public ArrowAmountDisplay arrowAmountDisplay = ArrowAmountDisplay.NUMBER; + + public enum ArrowAmountDisplay { + NUMBER("Number"), + PERCENTAGE("Percentage"), + ; + + private final String str; + + ArrowAmountDisplay(String str) { + this.str = str; + } + + @Override + public String toString() { + return str; + } + } + + @Expose + @ConfigOption(name = "Color Arrow Amount", desc = "Color the arrow amount based on the percentage.") + @ConfigEditorBoolean + public boolean colorArrowAmount = false; + + @Expose + @ConfigOption(name = "Alignment Options", desc = "") + @Accordion + public AlignmentConfig alignment = new AlignmentConfig(); + + @Expose + @ConfigOption(name = "Title and Footer Options", desc = "") + @Accordion + public TitleAndFooterConfig titleAndFooter = new TitleAndFooterConfig(); +} diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/InformationFilteringConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/InformationFilteringConfig.java new file mode 100644 index 000000000..02a8f83a0 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/InformationFilteringConfig.java @@ -0,0 +1,23 @@ +package at.hannibal2.skyhanni.config.features.gui.customscoreboard; + +import com.google.gson.annotations.Expose; +import io.github.moulberry.moulconfig.annotations.ConfigEditorBoolean; +import io.github.moulberry.moulconfig.annotations.ConfigOption; + +public class InformationFilteringConfig { + @Expose + @ConfigOption(name = "Hide lines with no info", desc = "Hide lines that have no info to display, like hiding the party when not being in one.") + @ConfigEditorBoolean + public boolean hideEmptyLines = true; + + @Expose + @ConfigOption(name = "Hide consecutive empty lines", desc = "Hide lines that are empty and have an empty line above them.") + @ConfigEditorBoolean + public boolean hideConsecutiveEmptyLines = true; + + @Expose + @ConfigOption(name = "Hide non relevant info", desc = "Hide lines that are not relevant to the current location." + + "\n§cIt's generally not recommended to turn this off.") + @ConfigEditorBoolean + public boolean hideIrrelevantLines = true; +} diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/MayorConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/MayorConfig.java new file mode 100644 index 000000000..5a47e5a48 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/MayorConfig.java @@ -0,0 +1,17 @@ +package at.hannibal2.skyhanni.config.features.gui.customscoreboard; + +import com.google.gson.annotations.Expose; +import io.github.moulberry.moulconfig.annotations.ConfigEditorBoolean; +import io.github.moulberry.moulconfig.annotations.ConfigOption; + +public class MayorConfig { + @Expose + @ConfigOption(name = "Show Mayor Perks", desc = "Show the perks of the current mayor.") + @ConfigEditorBoolean + public boolean showMayorPerks = true; + + @Expose + @ConfigOption(name = "Show Time till next mayor", desc = "Show the time till the next mayor is elected.") + @ConfigEditorBoolean + public boolean showTimeTillNextMayor = true; +} diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/PartyConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/PartyConfig.java new file mode 100644 index 000000000..2850882b7 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/PartyConfig.java @@ -0,0 +1,23 @@ +package at.hannibal2.skyhanni.config.features.gui.customscoreboard; + +import com.google.gson.annotations.Expose; +import io.github.moulberry.moulconfig.annotations.ConfigEditorBoolean; +import io.github.moulberry.moulconfig.annotations.ConfigEditorSlider; +import io.github.moulberry.moulconfig.annotations.ConfigOption; +import io.github.moulberry.moulconfig.observer.Property; + +public class PartyConfig { + @Expose + @ConfigOption(name = "Max Party List", desc = "Max number of party members to show in the party list (You are not included).") + @ConfigEditorSlider( + minValue = 1, + maxValue = 25, // why do I even set it so high + minStep = 1 + ) + public Property<Integer> maxPartyList = Property.of(4); + + @Expose + @ConfigOption(name = "Show Party everywhere", desc = "Show the party list everywhere.\nIf disabled, it will only show in Dungeon hub, Crimson Isle & Kuudra.") + @ConfigEditorBoolean + public boolean showPartyEverywhere = false; +} diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/TitleAndFooterConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/TitleAndFooterConfig.java new file mode 100644 index 000000000..d88115dff --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/config/features/gui/customscoreboard/TitleAndFooterConfig.java @@ -0,0 +1,32 @@ +package at.hannibal2.skyhanni.config.features.gui.customscoreboard; + +import at.hannibal2.skyhanni.utils.RenderUtils; +import com.google.gson.annotations.Expose; +import io.github.moulberry.moulconfig.annotations.ConfigEditorBoolean; +import io.github.moulberry.moulconfig.annotations.ConfigEditorDropdown; +import io.github.moulberry.moulconfig.annotations.ConfigEditorText; +import io.github.moulberry.moulconfig.annotations.ConfigOption; +import io.github.moulberry.moulconfig.observer.Property; + +public class TitleAndFooterConfig { + @Expose + @ConfigOption(name = "Title and Footer Alignment", desc = "Align the title and footer in the scoreboard.") + @ConfigEditorDropdown + public RenderUtils.HorizontalAlignment alignTitleAndFooter = RenderUtils.HorizontalAlignment.CENTER; + + @Expose + @ConfigOption(name = "Custom Title", desc = "What should be displayed as the title of the scoreboard.\nUse & for colors.") + @ConfigEditorText + public Property<String> customTitle = Property.of("&6&lSKYBLOCK"); + + @Expose + @ConfigOption(name = "Hypixel's Title Animation", desc = "Will overwrite the custom title with Hypixel's title animation." + + "\nWill also include \"COOP\" if you are in a coop.") + @ConfigEditorBoolean + public boolean useHypixelTitleAnimation = false; + + @Expose + @ConfigOption(name = "Custom Footer", desc = "What should be displayed as the footer of the scoreboard.\nUse & for colors.") + @ConfigEditorText + public Property<String> customFooter = Property.of("&ewww.hypixel.net"); +} diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/misc/MiscConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/misc/MiscConfig.java index 077bd8303..40b078961 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/features/misc/MiscConfig.java +++ b/src/main/java/at/hannibal2/skyhanni/config/features/misc/MiscConfig.java @@ -137,7 +137,7 @@ public class MiscConfig { public boolean hidePiggyScoreboard = true; @Expose - @ConfigOption(name = "Color Month Names", desc = "Color the month names in the Scoreboard.") + @ConfigOption(name = "Color Month Names", desc = "Color the month names in the Scoreboard.\nAlso applies to the Custom Scoreboard.") @ConfigEditorBoolean @FeatureToggle public boolean colorMonthNames = false; diff --git a/src/main/java/at/hannibal2/skyhanni/data/ArrowType.kt b/src/main/java/at/hannibal2/skyhanni/data/ArrowType.kt new file mode 100644 index 000000000..5ce7dd33f --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/ArrowType.kt @@ -0,0 +1,9 @@ +package at.hannibal2.skyhanni.data + +import at.hannibal2.skyhanni.utils.NEUInternalName + +data class ArrowType(val arrow: String, val internalName: NEUInternalName) { + override fun toString(): String { + return internalName.asString() + } +} diff --git a/src/main/java/at/hannibal2/skyhanni/data/BitsAPI.kt b/src/main/java/at/hannibal2/skyhanni/data/BitsAPI.kt new file mode 100644 index 000000000..2802399bf --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/BitsAPI.kt @@ -0,0 +1,200 @@ +package at.hannibal2.skyhanni.data + +import at.hannibal2.skyhanni.SkyHanniMod +import at.hannibal2.skyhanni.data.FameRanks.getFameRankByNameOrNull +import at.hannibal2.skyhanni.events.InventoryFullyOpenedEvent +import at.hannibal2.skyhanni.events.LorenzChatEvent +import at.hannibal2.skyhanni.events.ScoreboardChangeEvent +import at.hannibal2.skyhanni.test.command.ErrorManager +import at.hannibal2.skyhanni.utils.ChatUtils +import at.hannibal2.skyhanni.utils.ItemUtils.getLore +import at.hannibal2.skyhanni.utils.LorenzUtils +import at.hannibal2.skyhanni.utils.NumberUtil.formatInt +import at.hannibal2.skyhanni.utils.StringUtils.matchMatcher +import at.hannibal2.skyhanni.utils.StringUtils.matches +import at.hannibal2.skyhanni.utils.StringUtils.removeResets +import at.hannibal2.skyhanni.utils.StringUtils.trimWhiteSpace +import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent + +object BitsAPI { + private val profileStorage get() = ProfileStorageData.profileSpecific?.bits + private val playerStorage get() = SkyHanniMod.feature.storage + + var bits: Int + get() = profileStorage?.bits ?: 0 + private set(value) { + profileStorage?.bits = value + } + var currentFameRank: FameRank? + get() = playerStorage?.currentFameRank?.let { getFameRankByNameOrNull(it) } + private set(value) { + if (value != null) { + playerStorage?.currentFameRank = value.name + } + } + var bitsToClaim: Int + get() = profileStorage?.bitsToClaim ?: 0 + private set(value) { + profileStorage?.bitsToClaim = value + } + + private const val defaultcookiebits = 4800 + + private val bitsDataGroup = RepoPattern.group("data.bits") + + // Scoreboard patterns + val bitsScoreboardPattern by bitsDataGroup.pattern( + "scoreboard", + "^Bits: §b(?<amount>[\\d,.]+).*$" + ) + + // Chat patterns + private val bitsChatGroup = bitsDataGroup.group("chat") + + private val bitsFromFameRankUpChatPattern by bitsChatGroup.pattern( + "famerankup", + "§eYou gained §3(?<amount>.*) Bits Available §ecompounded from all your §epreviously eaten §6cookies§e! Click here to open §6cookie menu§e!" + ) + + private val boosterCookieAte by bitsChatGroup.pattern( + "boostercookieate", + "§eYou consumed a §6Booster Cookie§e!.*" + ) + + // GUI patterns + private val bitsGuiGroup = bitsDataGroup.group("gui") + + private val bitsAvailableMenuPattern by bitsGuiGroup.pattern( + "availablemenu", + "§7Bits Available: §b(?<toClaim>[\\d,]+)(§3.+)?" + ) + + private val fameRankSbMenuPattern by bitsGuiGroup.pattern( + "sbmenufamerank", + "§7Your rank: §e(?<rank>.*)" + ) + + private val fameRankCommunityShopPattern by bitsGuiGroup.pattern( + "communityshopfamerank", + "§7Fame Rank: §e(?<rank>.*)" + ) + + private val bitsGuiNamePattern by bitsGuiGroup.pattern( + "mainmenuname", + "^SkyBlock Menu$" + ) + + private val bitsGuiStackPattern by bitsGuiGroup.pattern( + "mainmenustack", + "^§6Booster Cookie$" + ) + + private val fameRankGuiNamePattern by bitsGuiGroup.pattern( + "famerankmenuname", + "^(Community Shop|Booster Cookie)$" + ) + + private val fameRankGuiStackPattern by bitsGuiGroup.pattern( + "famerankmenustack", + "^(§aCommunity Shop|§eFame Rank)$" + ) + + @SubscribeEvent + fun onScoreboardChange(event: ScoreboardChangeEvent) { + if (!isEnabled()) return + for (line in event.newList) { + val message = line.trimWhiteSpace().removeResets() + + bitsScoreboardPattern.matchMatcher(message) { + val amount = group("amount").formatInt() + + if (amount > bits) { + bitsToClaim -= amount - bits + ChatUtils.debug("You have gained §3${amount - bits} Bits §7according to the scoreboard!") + } + bits = amount + + return + } + } + } + + @SubscribeEvent + fun onChat(event: LorenzChatEvent) { + if (!isEnabled()) return + val message = event.message.trimWhiteSpace().removeResets() + + bitsFromFameRankUpChatPattern.matchMatcher(message) { + val amount = group("amount").formatInt() + bitsToClaim += amount + + return + } + + boosterCookieAte.matchMatcher(message) { + bitsToClaim += (defaultcookiebits * (currentFameRank?.bitsMultiplier ?: return)).toInt() + + return + } + } + + @SubscribeEvent + fun onInventoryFullyLoaded(event: InventoryFullyOpenedEvent) { + if (!isEnabled()) return + + val stacks = event.inventoryItems + + if (bitsGuiNamePattern.matches(event.inventoryName)) { + val cookieStack = stacks.values.lastOrNull { bitsGuiStackPattern.matches(it.displayName) } ?: return + for (line in cookieStack.getLore()) { + bitsAvailableMenuPattern.matchMatcher(line) { + bitsToClaim = group("toClaim").formatInt() + + return + } + } + return + } + + if (fameRankGuiNamePattern.matches(event.inventoryName)) { + val fameRankStack = stacks.values.lastOrNull { fameRankGuiStackPattern.matches(it.displayName) } ?: return + + line@ for (line in fameRankStack.getLore()) { + fameRankCommunityShopPattern.matchMatcher(line) { + val rank = group("rank") + + currentFameRank = getFameRankByNameOrNull(rank) + ?: return ErrorManager.logErrorWithData( + FameRankNotFoundException(rank), + "FameRank $rank not found", + "Rank" to rank, + "Lore" to fameRankStack.getLore(), + "FameRanks" to FameRanks.fameRanks + ) + + continue@line + } + + fameRankSbMenuPattern.matchMatcher(line) { + val rank = group("rank") + + currentFameRank = getFameRankByNameOrNull(rank) + ?: return ErrorManager.logErrorWithData( + FameRankNotFoundException(rank), + "FameRank $rank not found", + "Rank" to rank, + "Lore" to fameRankStack.getLore(), + "FameRanks" to FameRanks.fameRanks + ) + + continue@line + } + } + } + } + + fun isEnabled() = LorenzUtils.inSkyBlock && profileStorage != null + + class FameRankNotFoundException(rank: String) : Exception("FameRank not found: $rank") +} diff --git a/src/main/java/at/hannibal2/skyhanni/data/FameRanks.kt b/src/main/java/at/hannibal2/skyhanni/data/FameRanks.kt new file mode 100644 index 000000000..663e2b970 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/FameRanks.kt @@ -0,0 +1,26 @@ +package at.hannibal2.skyhanni.data + +import at.hannibal2.skyhanni.data.jsonobjects.repo.FameRankJson +import at.hannibal2.skyhanni.events.RepositoryReloadEvent +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent + +object FameRanks { + var fameRanks = emptyMap<String, FameRank>() + private set + + fun getFameRankByNameOrNull(name: String) = fameRanks[name] + + @SubscribeEvent + fun onRepoReload(event: RepositoryReloadEvent) { + val ranks = event.getConstant<FameRankJson>("FameRank") + fameRanks = ranks.fame_rank.values.map { FameRank(it.name, it.fame_required, it.bits_multiplier, it.votes) } + .associateBy { it.name } + } +} + +data class FameRank( + val name: String, + val fameRequired: Int, + val bitsMultiplier: Double, + val electionVotes: Int +) diff --git a/src/main/java/at/hannibal2/skyhanni/data/GuiEditManager.kt b/src/main/java/at/hannibal2/skyhanni/data/GuiEditManager.kt index 4fbebe958..ee9a6a23a 100644 --- a/src/main/java/at/hannibal2/skyhanni/data/GuiEditManager.kt +++ b/src/main/java/at/hannibal2/skyhanni/data/GuiEditManager.kt @@ -3,8 +3,10 @@ package at.hannibal2.skyhanni.data import at.hannibal2.skyhanni.SkyHanniMod import at.hannibal2.skyhanni.config.core.config.Position import at.hannibal2.skyhanni.config.core.config.gui.GuiPositionEditor +import at.hannibal2.skyhanni.events.GuiPositionMovedEvent import at.hannibal2.skyhanni.events.GuiRenderEvent import at.hannibal2.skyhanni.events.LorenzKeyPressEvent +import at.hannibal2.skyhanni.events.LorenzTickEvent import at.hannibal2.skyhanni.test.SkyHanniDebugsAndTests import at.hannibal2.skyhanni.utils.ChatUtils import at.hannibal2.skyhanni.utils.LorenzUtils.isRancherSign @@ -51,11 +53,20 @@ class GuiEditManager { currentPositions.clear() } + @SubscribeEvent + fun onTick(event: LorenzTickEvent) { + lastMovedGui?.let { + GuiPositionMovedEvent(it).postAndCatch() + lastMovedGui = null + } + } + companion object { var currentPositions = mutableMapOf<String, Position>() private var latestPositions = mapOf<String, Position>() private var currentBorderSize = mutableMapOf<String, Pair<Int, Int>>() + private var lastMovedGui: String? = null @JvmStatic fun add(position: Position, posLabel: String, x: Int, y: Int) { @@ -116,6 +127,10 @@ class GuiEditManager { fun GuiProfileViewer.anyTextBoxFocused() = this.getPropertiesWithType<GuiElementTextField>().any { it.focus } + + fun handleGuiPositionMoved(guiName: String) { + lastMovedGui = guiName + } } } diff --git a/src/main/java/at/hannibal2/skyhanni/data/HypixelData.kt b/src/main/java/at/hannibal2/skyhanni/data/HypixelData.kt index b206eb565..c347fcdba 100644 --- a/src/main/java/at/hannibal2/skyhanni/data/HypixelData.kt +++ b/src/main/java/at/hannibal2/skyhanni/data/HypixelData.kt @@ -300,9 +300,12 @@ class HypixelData { private fun checkIsland() { var newIsland = "" var guesting = false + TabListData.fullyLoaded = false + for (line in TabListData.getTabList()) { islandNamePattern.matchMatcher(line) { newIsland = group("island").removeColor() + TabListData.fullyLoaded = true } if (line == " Status: §r§9Guest") { guesting = true diff --git a/src/main/java/at/hannibal2/skyhanni/data/MaxwellAPI.kt b/src/main/java/at/hannibal2/skyhanni/data/MaxwellAPI.kt new file mode 100644 index 000000000..0f19854f7 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/MaxwellAPI.kt @@ -0,0 +1,152 @@ +package at.hannibal2.skyhanni.data + +import at.hannibal2.skyhanni.data.jsonobjects.repo.MaxwellPowersJson +import at.hannibal2.skyhanni.events.InventoryFullyOpenedEvent +import at.hannibal2.skyhanni.events.LorenzChatEvent +import at.hannibal2.skyhanni.events.RepositoryReloadEvent +import at.hannibal2.skyhanni.test.command.ErrorManager +import at.hannibal2.skyhanni.utils.ItemUtils.getLore +import at.hannibal2.skyhanni.utils.LorenzUtils +import at.hannibal2.skyhanni.utils.LorenzUtils.isInIsland +import at.hannibal2.skyhanni.utils.NumberUtil.formatInt +import at.hannibal2.skyhanni.utils.StringUtils.matchMatcher +import at.hannibal2.skyhanni.utils.StringUtils.matches +import at.hannibal2.skyhanni.utils.StringUtils.removeColor +import at.hannibal2.skyhanni.utils.StringUtils.removeResets +import at.hannibal2.skyhanni.utils.StringUtils.trimWhiteSpace +import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern +import net.minecraft.enchantment.Enchantment +import net.minecraft.enchantment.Enchantment.power +import net.minecraft.item.ItemStack +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent + +object MaxwellAPI { + + private val storage get() = ProfileStorageData.profileSpecific + + var currentPower: String? + get() = storage?.maxwell?.currentPower + set(value) { + storage?.maxwell?.currentPower = value ?: return + } + var magicalPower: Int? + get() = storage?.maxwell?.magicalPower + set(value) { + storage?.maxwell?.magicalPower = value ?: return + } + + private var powers = mutableListOf<String>() + + private val group = RepoPattern.group("data.maxwell") + private val chatPowerpattern by group.pattern( + "chat.power", + "§eYou selected the §a(?<power>.*) §e(power )?for your §aAccessory Bag§e!" + ) + private val inventoryPowerPattern by group.pattern( + "inventory.power", + "§7Selected Power: §a(?<power>.*)" + ) + private val inventoryMPPattern by group.pattern( + "inventory.magicalpower", + "§7Magical Power: §6(?<mp>[\\d,]+)" + ) + private val thaumaturgyGuiPattern by group.pattern( + "gui.thaumaturgy", + "Accessory Bag Thaumaturgy" + ) + private val yourBagsGuiPattern by group.pattern( + "gui.yourbags", + "Your Bags" + ) + private val powerSelectedPattern by group.pattern( + "gui.selectedpower", + "§aPower is selected!" + ) + + @SubscribeEvent + fun onChat(event: LorenzChatEvent) { + if (!isEnabled()) return + val message = event.message.trimWhiteSpace().removeResets() + + chatPowerpattern.matchMatcher(message) { + val power = group("power") + currentPower = getPowerByNameOrNull(power) + ?: return ErrorManager.logErrorWithData( + UnknownMaxwellPower("Unknown power: $power"), + "Unknown power: $power", + "power" to power, + "message" to message + ) + } + } + + @SubscribeEvent + fun onInventoryFullyLoaded(event: InventoryFullyOpenedEvent) { + if (!isEnabled()) return + + if (thaumaturgyGuiPattern.matches(event.inventoryName)) { + val selectedPowerStack = + event.inventoryItems.values.find { + powerSelectedPattern.matches(it.getLore().lastOrNull()) + } ?: return + val displayName = selectedPowerStack.displayName.removeColor() + + currentPower = getPowerByNameOrNull(displayName) + ?: return ErrorManager.logErrorWithData( + UnknownMaxwellPower("Unknown power: $power"), + "Unknown power: $power", + "power" to power, + "displayName" to displayName, + "lore" to selectedPowerStack.getLore() + ) + return + } + + if (yourBagsGuiPattern.matches(event.inventoryName)) { + val stacks = event.inventoryItems + + for (stack in stacks.values) { + processStack(stack) + } + } + } + + private fun processStack(stack: ItemStack) { + for (line in stack.getLore()) { + inventoryMPPattern.matchMatcher(line) { + // MagicalPower is boosted in catacombs + if (IslandType.CATACOMBS.isInIsland()) return@matchMatcher + + val mp = group("mp") + magicalPower = mp.formatInt() + return@matchMatcher + } + + inventoryPowerPattern.matchMatcher(line) { + val power = group("power") + currentPower = getPowerByNameOrNull(power) + ?: return@matchMatcher ErrorManager.logErrorWithData( + UnknownMaxwellPower("Unknown power: ${Enchantment.power}"), + "Unknown power: ${Enchantment.power}", + "power" to Enchantment.power, + "displayName" to stack.displayName, + "lore" to stack.getLore() + ) + return@matchMatcher + } + } + } + + private fun getPowerByNameOrNull(name: String) = powers.find { it == name } + + fun isEnabled() = LorenzUtils.inSkyBlock && storage != null + + // Load powers from repo + @SubscribeEvent + fun onRepoLoad(event: RepositoryReloadEvent) { + val data = event.getConstant<MaxwellPowersJson>("MaxwellPowers") + powers = data.powers + } + + class UnknownMaxwellPower(message: String) : Exception(message) +} diff --git a/src/main/java/at/hannibal2/skyhanni/data/MayorAPI.kt b/src/main/java/at/hannibal2/skyhanni/data/MayorAPI.kt new file mode 100644 index 000000000..bc937a5a2 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/MayorAPI.kt @@ -0,0 +1,121 @@ +package at.hannibal2.skyhanni.data + +import at.hannibal2.skyhanni.SkyHanniMod +import at.hannibal2.skyhanni.config.ConfigManager +import at.hannibal2.skyhanni.data.Mayor.Companion.setMayorWithActivePerks +import at.hannibal2.skyhanni.data.jsonobjects.local.MayorJson +import at.hannibal2.skyhanni.events.DebugDataCollectEvent +import at.hannibal2.skyhanni.events.LorenzTickEvent +import at.hannibal2.skyhanni.utils.APIUtil +import at.hannibal2.skyhanni.utils.CollectionUtils.put +import at.hannibal2.skyhanni.utils.LorenzUtils +import at.hannibal2.skyhanni.utils.SimpleTimeMark +import at.hannibal2.skyhanni.utils.SimpleTimeMark.Companion.asTimeMark +import io.github.moulberry.notenoughupdates.util.SkyBlockTime +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent +import kotlin.time.Duration +import kotlin.time.Duration.Companion.minutes + +object MayorAPI { + var lastUpdate = SimpleTimeMark.farPast() + private var dispatcher = Dispatchers.IO + + private var rawMayorData: MayorJson? = null + var candidates = mapOf<Int, MayorJson.Candidate>() + private set + var currentMayor: Mayor? = null + private set + var timeTillNextMayor = Duration.ZERO + private set + + private const val ELECTION_END_MONTH = 3 //Late Spring + private const val ELECTION_END_DAY = 27 + + /** + * @param input: The name of the mayor + * @return: The neu color of the mayor; If no mayor was found, it will return "§cUnknown: §7" + */ + fun mayorNameToColorCode(input: String): String { + return Mayor.getMayorFromName(input).color + } + + /** + * @param input: The name of the mayor + * @return: The neu color of the mayor + the name of the mayor; If no mayor was found, it will return "§cUnknown: §7[input]" + */ + fun mayorNameWithColorCode(input: String) = mayorNameToColorCode(input) + input + + @SubscribeEvent + fun onTick(event: LorenzTickEvent) { + if (!LorenzUtils.onHypixel) return + + if (event.repeatSeconds(2)) { + checkHypixelAPI() + getTimeTillNextMayor() + } + } + + private fun calculateNextMayorTime(): SimpleTimeMark { + var mayorYear = SkyBlockTime.now().year + + // Check if either the month is already over or the day is after 27th in the third month + if (SkyBlockTime.now().month > ELECTION_END_MONTH || (SkyBlockTime.now().day >= ELECTION_END_DAY && SkyBlockTime.now().month == ELECTION_END_MONTH)) { + // If so, the next mayor will be in the next year + mayorYear++ + } + + return SkyBlockTime(mayorYear, ELECTION_END_MONTH, day = ELECTION_END_DAY).asTimeMark() + } + + private fun getTimeTillNextMayor() { + val nextMayorTime = calculateNextMayorTime() + timeTillNextMayor = nextMayorTime - SimpleTimeMark.now() + } + + private fun checkCurrentMayor() { + val nextMayorTime = calculateNextMayorTime() + + // Check if it is still the mayor from the old SkyBlock year + currentMayor = candidates[nextMayorTime.toSkyBlockTime().year - 1]?.let { + // TODO: Once Jerry is active, add the sub mayor perks in here + setMayorWithActivePerks(it.name, it.perks) + } + } + + private fun checkHypixelAPI() { + if (lastUpdate.passedSince() < 20.minutes) return + lastUpdate = SimpleTimeMark.now() + + SkyHanniMod.coroutineScope.launch { + val url = "https://api.hypixel.net/v2/resources/skyblock/election" + val jsonObject = withContext(dispatcher) { APIUtil.getJSONResponse(url) } + rawMayorData = ConfigManager.gson.fromJson(jsonObject, MayorJson::class.java) + val data = rawMayorData ?: return@launch + val map = mutableMapOf<Int, MayorJson.Candidate>() + map put data.mayor.election.getPairs() + data.current?.let { + map put data.current.getPairs() + } + candidates = map + checkCurrentMayor() + } + } + + private fun MayorJson.Election.getPairs() = year + 1 to candidates.bestCandidate() + + private fun List<MayorJson.Candidate>.bestCandidate() = maxBy { it.votes } + + @SubscribeEvent + fun onDebugDataCollect(event: DebugDataCollectEvent) { + event.title("Mayor") + event.addIrrelevant { + add("Current Mayor: ${currentMayor?.name ?: "Unknown"}") + add("Active Perks: ${currentMayor?.activePerks}") + add("Last Update: $lastUpdate (${lastUpdate.passedSince()} ago)") + add("Time Till Next Mayor: $timeTillNextMayor") + } + } +} diff --git a/src/main/java/at/hannibal2/skyhanni/data/MayorElection.kt b/src/main/java/at/hannibal2/skyhanni/data/MayorElection.kt deleted file mode 100644 index e73a6bf14..000000000 --- a/src/main/java/at/hannibal2/skyhanni/data/MayorElection.kt +++ /dev/null @@ -1,79 +0,0 @@ -package at.hannibal2.skyhanni.data - -import at.hannibal2.skyhanni.SkyHanniMod -import at.hannibal2.skyhanni.config.ConfigManager -import at.hannibal2.skyhanni.data.jsonobjects.local.MayorJson -import at.hannibal2.skyhanni.events.LorenzTickEvent -import at.hannibal2.skyhanni.utils.APIUtil -import at.hannibal2.skyhanni.utils.CollectionUtils.put -import at.hannibal2.skyhanni.utils.LorenzUtils -import at.hannibal2.skyhanni.utils.SimpleTimeMark -import io.github.moulberry.notenoughupdates.util.SkyBlockTime -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.launch -import kotlinx.coroutines.withContext -import net.minecraftforge.fml.common.eventhandler.SubscribeEvent -import kotlin.time.Duration.Companion.minutes - -class MayorElection { - - private var lastUpdate = SimpleTimeMark.farPast() - private var dispatcher = Dispatchers.IO - - companion object { - - var rawMayorData: MayorJson? = null - var candidates = mapOf<Int, MayorJson.Candidate>() - var currentCandidate: MayorJson.Candidate? = null - - fun isPerkActive(mayor: String, perk: String) = currentCandidate?.let { currentCandidate -> - currentCandidate.name == mayor && currentCandidate.perks.any { it.name == perk } - } ?: false - } - - @SubscribeEvent - fun onTick(event: LorenzTickEvent) { - if (!LorenzUtils.onHypixel) return - - if (event.repeatSeconds(3)) { - check() - } - } - - private fun check() { - if (lastUpdate.passedSince() < 20.minutes) return - lastUpdate = SimpleTimeMark.now() - - SkyHanniMod.coroutineScope.launch { - val url = "https://api.hypixel.net/v2/resources/skyblock/election" - val jsonObject = withContext(dispatcher) { APIUtil.getJSONResponse(url) } - rawMayorData = ConfigManager.gson.fromJson(jsonObject, MayorJson::class.java) - val data = rawMayorData ?: return@launch - val map = mutableMapOf<Int, MayorJson.Candidate>() - map put data.mayor.election.getPairs() - data.current?.let { - map put data.current.getPairs() - } - candidates = map - checkCurrentMayor() - } - } - - private fun checkCurrentMayor() { - var currentYear = SkyBlockTime.now().year - - // The time in the current SkyBlock year when the election circle will restart - val month = 3 // Late Spring - val nextMayorTime = SkyBlockTime(currentYear, month, day = 27).toMillis() - - // Is it still the mayor from old sb year? - if (nextMayorTime > System.currentTimeMillis()) { - currentYear-- - } - currentCandidate = candidates[currentYear] - } - - private fun MayorJson.Election.getPairs() = year + 1 to candidates.bestCandidate() - - private fun List<MayorJson.Candidate>.bestCandidate() = maxBy { it.votes } -} diff --git a/src/main/java/at/hannibal2/skyhanni/data/Mayors.kt b/src/main/java/at/hannibal2/skyhanni/data/Mayors.kt new file mode 100644 index 000000000..cd6205c7a --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/Mayors.kt @@ -0,0 +1,105 @@ +package at.hannibal2.skyhanni.data + +import at.hannibal2.skyhanni.data.jsonobjects.local.MayorJson + +enum class Mayor( + val mayorName: String, + val color: String, + private vararg val perks: Perk, +) { + AATROX("Aatrox", "§3", Perk.SLASHED_PRICING, Perk.SLAYER_XP_BUFF, Perk.PATHFINDER), + COLE("Cole", "§e", Perk.PROSPECTION, Perk.MINING_XP_BUFF, Perk.MINING_FIESTA), + DIANA("Diana", "§2", Perk.LUCKY, Perk.MYTHOLOGICAL_RITUAL, Perk.PET_XP_BUFF), + DIAZ("Diaz", "§6", Perk.BARRIER_STREET, Perk.SHOPPING_SPREE), + FINNEGAN("Finnegan", "§c", Perk.FARMING_SIMULATOR, Perk.PELT_POCALYPSE, Perk.GOATED), + FOXY("Foxy", "§d", Perk.SWEET_TOOTH, Perk.BENEVOLENCE, Perk.EXTRA_EVENT), + MARINA("Marina", "§b", Perk.FISHING_XP_BUFF, Perk.LUCK_OF_THE_SEA, Perk.FISHING_FESTIVAL), + PAUL("Paul", "§c", Perk.MARAUDER, Perk.EZPZ, Perk.BENEDICTION), + + SCORPIUS("Scorpius", "§d", Perk.BRIBE, Perk.DARKER_AUCTIONS), + JERRY("Jerry", "§d", Perk.PERKPOCALYPSE, Perk.STATSPOCALYPSE, Perk.JERRYPOCALYPSE), + DERPY("Derpy", "§d", Perk.TURBO_MINIONS, Perk.AH_CLOSED, Perk.DOUBLE_MOBS_HP, Perk.MOAR_SKILLZ), + + UNKNOWN("Unknown", "§c"), + ; + + val activePerks: MutableList<Perk> = mutableListOf() + + companion object { + fun getMayorFromName(name: String) = entries.firstOrNull { it.mayorName == name } ?: UNKNOWN + + fun setMayorWithActivePerks(name: String, perks: ArrayList<MayorJson.Perk>): Mayor { + val mayor = getMayorFromName(name) + + mayor.perks.forEach { it.isActive = false } + mayor.activePerks.clear() + perks.mapNotNull { perk -> Perk.entries.firstOrNull { it.perkName == perk.name } } + .filter { mayor.perks.contains(it) }.forEach { + it.isActive = true + mayor.activePerks.add(it) + } + + return mayor + } + } +} + +enum class Perk(val perkName: String) { + // Aatrox + SLASHED_PRICING("SLASHED Pricing"), + SLAYER_XP_BUFF("Slayer XP Buff"), + PATHFINDER("Pathfinder"), + + // Cole + PROSPECTION("Prospection"), + MINING_XP_BUFF("Mining XP Buff"), + MINING_FIESTA("Mining Fiesta"), + + // Diana + LUCKY("Lucky!"), + MYTHOLOGICAL_RITUAL("Mythological Ritual"), + PET_XP_BUFF("Pet XP Buff"), + + // Diaz + BARRIER_STREET("Barrier Street"), + SHOPPING_SPREE("Shopping Spree"), + + // Finnegan + FARMING_SIMULATOR("Farming Simulator"), + PELT_POCALYPSE("Pelt-pocalypse"), + GOATED("GOATed"), + + // Foxy + SWEET_TOOTH("Sweet Tooth"), + BENEVOLENCE("Benevolence"), + EXTRA_EVENT("Extra Event"), + + // Marina + FISHING_XP_BUFF("Fishing XP Buff"), + LUCK_OF_THE_SEA("Luck of the Sea 2.0"), + FISHING_FESTIVAL("Fishing Festival"), + + // Paul + MARAUDER("Marauder"), + EZPZ("EZPZ"), + BENEDICTION("Benediction"), + + + // Scorpius + BRIBE("Bribe"), + DARKER_AUCTIONS("Darker Auctions"), + + // Jerry + PERKPOCALYPSE("Perkpocalypse"), + STATSPOCALYPSE("Statspocalypse"), + JERRYPOCALYPSE("Jerrypocalypse"), + + // Derpy + TURBO_MINIONS("TURBO MINIONS!!!"), + AH_CLOSED("AH CLOSED!!!"), + DOUBLE_MOBS_HP("DOUBLE MOBS HP!!!"), + MOAR_SKILLZ("MOAR SKILLZ!!!"), + ; + + var isActive = false +} diff --git a/src/main/java/at/hannibal2/skyhanni/data/PartyAPI.kt b/src/main/java/at/hannibal2/skyhanni/data/PartyAPI.kt index 22fb8e4f8..ace56f67f 100644 --- a/src/main/java/at/hannibal2/skyhanni/data/PartyAPI.kt +++ b/src/main/java/at/hannibal2/skyhanni/data/PartyAPI.kt @@ -8,7 +8,7 @@ import at.hannibal2.skyhanni.utils.StringUtils.cleanPlayerName import at.hannibal2.skyhanni.utils.StringUtils.matchMatcher import at.hannibal2.skyhanni.utils.StringUtils.removeColor import at.hannibal2.skyhanni.utils.StringUtils.removeResets -import at.hannibal2.skyhanni.utils.StringUtils.trimWhiteSpaceAndResets +import at.hannibal2.skyhanni.utils.StringUtils.trimWhiteSpace import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern import net.minecraftforge.fml.common.eventhandler.SubscribeEvent import kotlin.random.Random @@ -94,7 +94,7 @@ object PartyAPI { @SubscribeEvent fun onChat(event: LorenzChatEvent) { - val message = event.message.trimWhiteSpaceAndResets().removeResets() + val message = event.message.trimWhiteSpace().removeResets() // new member joined youJoinedPartyPattern.matchMatcher(message) { diff --git a/src/main/java/at/hannibal2/skyhanni/data/PurseAPI.kt b/src/main/java/at/hannibal2/skyhanni/data/PurseAPI.kt index 90ea15627..f4266f800 100644 --- a/src/main/java/at/hannibal2/skyhanni/data/PurseAPI.kt +++ b/src/main/java/at/hannibal2/skyhanni/data/PurseAPI.kt @@ -4,8 +4,8 @@ import at.hannibal2.skyhanni.events.InventoryCloseEvent import at.hannibal2.skyhanni.events.LorenzTickEvent import at.hannibal2.skyhanni.events.PurseChangeCause import at.hannibal2.skyhanni.events.PurseChangeEvent -import at.hannibal2.skyhanni.utils.NumberUtil.formatNumber -import at.hannibal2.skyhanni.utils.NumberUtil.milion +import at.hannibal2.skyhanni.utils.NumberUtil.formatDouble +import at.hannibal2.skyhanni.utils.NumberUtil.million import at.hannibal2.skyhanni.utils.StringUtils.matchMatcher import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern import net.minecraft.client.Minecraft @@ -13,7 +13,7 @@ import net.minecraftforge.fml.common.eventhandler.SubscribeEvent object PurseAPI { private val patternGroup = RepoPattern.group("data.purse") - private val coinsPattern by patternGroup.pattern( + val coinsPattern by patternGroup.pattern( "coins", "(§.)*(Piggy|Purse): §6(?<coins>[\\d,.]+)( ?(§.)*\\([+-](?<earned>[\\d,.]+)\\)?|.*)?$" ) @@ -22,8 +22,9 @@ object PurseAPI { "Piggy: (?<coins>.*)" ) - private var currentPurse = 0.0 private var inventoryCloseTime = 0L + var currentPurse = 0.0 + private set @SubscribeEvent fun onInventoryClose(event: InventoryCloseEvent) { @@ -32,10 +33,9 @@ object PurseAPI { @SubscribeEvent fun onTick(event: LorenzTickEvent) { - for (line in ScoreboardData.sidebarLinesFormatted) { val newPurse = coinsPattern.matchMatcher(line) { - group("coins").formatNumber().toDouble() + group("coins").formatDouble() } ?: continue val diff = newPurse - currentPurse if (diff == 0.0) continue @@ -52,7 +52,7 @@ object PurseAPI { return PurseChangeCause.GAIN_TALISMAN_OF_COINS } - if (diff == 15.milion || diff == 100.milion) { + if (diff == 15.million || diff == 100.million) { return PurseChangeCause.GAIN_DICE_ROLL } diff --git a/src/main/java/at/hannibal2/skyhanni/data/QuiverAPI.kt b/src/main/java/at/hannibal2/skyhanni/data/QuiverAPI.kt new file mode 100644 index 000000000..603b9963b --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/QuiverAPI.kt @@ -0,0 +1,256 @@ +package at.hannibal2.skyhanni.data + +import at.hannibal2.skyhanni.SkyHanniMod +import at.hannibal2.skyhanni.data.jsonobjects.repo.ArrowTypeJson +import at.hannibal2.skyhanni.data.jsonobjects.repo.ItemsJson +import at.hannibal2.skyhanni.events.InventoryFullyOpenedEvent +import at.hannibal2.skyhanni.events.LorenzChatEvent +import at.hannibal2.skyhanni.events.PlaySoundEvent +import at.hannibal2.skyhanni.events.RepositoryReloadEvent +import at.hannibal2.skyhanni.test.command.ErrorManager +import at.hannibal2.skyhanni.utils.CollectionUtils.addOrPut +import at.hannibal2.skyhanni.utils.InventoryUtils +import at.hannibal2.skyhanni.utils.ItemCategory +import at.hannibal2.skyhanni.utils.ItemUtils.getInternalNameOrNull +import at.hannibal2.skyhanni.utils.ItemUtils.getItemCategoryOrNull +import at.hannibal2.skyhanni.utils.LorenzUtils +import at.hannibal2.skyhanni.utils.LorenzUtils.round +import at.hannibal2.skyhanni.utils.NEUInternalName +import at.hannibal2.skyhanni.utils.NEUInternalName.Companion.asInternalName +import at.hannibal2.skyhanni.utils.NumberUtil.formatNumber +import at.hannibal2.skyhanni.utils.SkyBlockItemModifierUtils.getEnchantments +import at.hannibal2.skyhanni.utils.StringUtils.matchMatcher +import at.hannibal2.skyhanni.utils.StringUtils.matches +import at.hannibal2.skyhanni.utils.StringUtils.removeResets +import at.hannibal2.skyhanni.utils.StringUtils.trimWhiteSpace +import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern +import net.minecraft.client.Minecraft +import net.minecraft.item.ItemBow +import net.minecraftforge.fml.common.eventhandler.EventPriority +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent + +private var infinityQuiverLevelMultiplier = 0.03f + +object QuiverAPI { + private val storage get() = ProfileStorageData.profileSpecific + var currentArrow: ArrowType? + get() = storage?.arrows?.currentArrow?.asInternalName()?.let { getArrowByNameOrNull(it) } ?: NONE_ARROW_TYPE + set(value) { + storage?.arrows?.currentArrow = value?.toString() ?: return + } + var arrowAmount: MutableMap<NEUInternalName, Float> + get() = storage?.arrows?.arrowAmount ?: mutableMapOf() + set(value) { + storage?.arrows?.arrowAmount = value + } + var currentAmount: Int + get() = arrowAmount[currentArrow?.internalName]?.toInt() ?: 0 + set(value) { + arrowAmount[currentArrow?.internalName ?: return] = value.toFloat() + } + + private var arrows: List<ArrowType> = listOf() + + const val MAX_ARROW_AMOUNT = 2880 + private val SKELETON_MASTER_CHESTPLATE = "SKELETON_MASTER_CHESTPLATE".asInternalName() + + var NONE_ARROW_TYPE: ArrowType? = null + private var FLINT_ARROW_TYPE: ArrowType? = null + + private val group = RepoPattern.group("data.quiver") + private val chatGroup = group.group("chat") + private val selectPattern by chatGroup.pattern("select", "§aYou set your selected arrow type to §f(?<arrow>.*)§a!") + private val fillUpJaxPattern by chatGroup.pattern( + "fillupjax", + "(§.)*Jax forged (§.)*(?<type>.*?)(§.)* x(?<amount>[\\d,]+)( (§.)*for (§.)*(?<coins>[\\d,]+) Coins)?(§.)*!" + ) + private val fillUpPattern by chatGroup.pattern( + "fillup", + "§aYou filled your quiver with §f(?<flintAmount>.*) §aextra arrows!" + ) + private val clearedPattern by chatGroup.pattern("cleared", "§aCleared your quiver!") + private val arrowResetPattern by chatGroup.pattern("arrowreset", "§cYour favorite arrow has been reset!") + private val addedToQuiverPattern by chatGroup.pattern( + "addedtoquiver", + "(§.)*You've added (§.)*(?<type>.*) x(?<amount>.*) (§.)*to your quiver!" + ) + + // Bows that don't use the players arrows, checked using the SkyBlock Id + private val fakeBowsPattern by group.pattern("fakebows", "^(BOSS_SPIRIT_BOW|CRYPT_BOW)$") + private val quiverInventoryNamePattern by group.pattern("quivername", "^Quiver$") + + @SubscribeEvent + fun onChat(event: LorenzChatEvent) { + if (!isEnabled()) return + val message = event.message.trimWhiteSpace().removeResets() + + selectPattern.matchMatcher(message) { + val type = group("arrow") + currentArrow = getArrowByNameOrNull(type) + ?: return ErrorManager.logErrorWithData( + UnknownArrowType("Unknown arrow type: $type"), + "Unknown arrow type: $type", + "message" to message, + ) + return + } + + fillUpJaxPattern.matchMatcher(message) { + val type = group("type") + val amount = group("amount").formatNumber().toFloat() + val filledUpType = getArrowByNameOrNull(type) + ?: return ErrorManager.logErrorWithData( + UnknownArrowType("Unknown arrow type: $type"), + "Unknown arrow type: $type", + "message" to message, + ) + + arrowAmount.addOrPut(filledUpType.internalName, amount) + return + } + + fillUpPattern.matchMatcher(message) { + val flintAmount = group("flintAmount").formatNumber().toFloat() + + FLINT_ARROW_TYPE?.let { arrowAmount.addOrPut(it.internalName, flintAmount) } + return + } + + addedToQuiverPattern.matchMatcher(message) { + val type = group("type") + val amount = group("amount").formatNumber().toFloat() + + val filledUpType = getArrowByNameOrNull(type) + ?: return ErrorManager.logErrorWithData( + UnknownArrowType("Unknown arrow type: $type"), + "Unknown arrow type: $type", + "message" to message, + ) + + arrowAmount.addOrPut(filledUpType.internalName, amount) + return + } + + clearedPattern.matchMatcher(message) { + currentAmount = 0 + arrowAmount.clear() + + return + } + + arrowResetPattern.matchMatcher(message) { + currentArrow = NONE_ARROW_TYPE + currentAmount = 0 + + return + } + } + + @SubscribeEvent + fun onInventoryFullyLoaded(event: InventoryFullyOpenedEvent) { + if (!isEnabled()) return + if (!quiverInventoryNamePattern.matches(event.inventoryName)) return + + // clear to prevent duplicates + currentAmount = 0 + arrowAmount.clear() + + val stacks = event.inventoryItems + for (stack in stacks.values) { + if (stack.getItemCategoryOrNull() != ItemCategory.ARROW) continue + + val arrow = stack.getInternalNameOrNull() ?: continue + + val arrowType = getArrowByNameOrNull(arrow) ?: continue + + arrowAmount.addOrPut(arrowType.internalName, stack.stackSize.toFloat()) + } + } + + /* + Modified method to remove arrows from SkyblockFeatures QuiverOverlay + Original method source: + https://github.com/MrFast-js/SkyblockFeatures/blob/ae4bf0b91ed0fb17114d9cdaccaa9aef9a6c8d01/src/main/java/mrfast/sbf/features/overlays/QuiverOverlay.java#L127 + + Changes made: + - Added "fake bows" check + - Added "infinite quiver" check + - Added "sneaking" check + - Added "bow sound distance" check + - Added "skeleton master chestplate" check + */ + @SubscribeEvent(priority = EventPriority.HIGHEST) + fun onPlaySound(event: PlaySoundEvent) { + if (!isEnabled()) return + if (event.soundName != "random.bow") return + + val holdingBow = InventoryUtils.getItemInHand()?.item is ItemBow + && !fakeBowsPattern.matches(InventoryUtils.getItemInHand()?.getInternalNameOrNull()?.asString() ?: "") + + if (!holdingBow) return + + // check if sound location is more than configAmount block away from player + val soundLocation = event.distanceToPlayer + if (soundLocation > SkyHanniMod.feature.dev.bowSoundDistance) return + + val arrowType = currentArrow?.internalName ?: return + val amount = arrowAmount[arrowType] ?: return + if (amount <= 0) return + + if (InventoryUtils.getChestplate() + // The chestplate has the ability to not use arrows + // https://hypixel-skyblock.fandom.com/wiki/Skeleton_Master_Armor + ?.getInternalNameOrNull() == SKELETON_MASTER_CHESTPLATE + ) return + + val infiniteQuiverLevel = InventoryUtils.getItemInHand()?.getEnchantments()?.get("infinite_quiver") ?: 0 + + val amountToRemove = { + when (Minecraft.getMinecraft().thePlayer.isSneaking) { + true -> 1.0f + false -> { + when (infiniteQuiverLevel) { + in 1..10 -> 1 - (infinityQuiverLevelMultiplier * infiniteQuiverLevel) + else -> 1.0f + } + } + } + } + + arrowAmount[arrowType] = amount - amountToRemove() + } + + fun Int.asArrowPercentage() = ((this.toFloat() / MAX_ARROW_AMOUNT) * 100).round(1) + + fun hasBowInInventory(): Boolean { + return InventoryUtils.getItemsInOwnInventory().any { it.item is ItemBow } + } + + fun getArrowByNameOrNull(name: String): ArrowType? { + return arrows.firstOrNull { it.arrow == name } + } + + fun getArrowByNameOrNull(internalName: NEUInternalName): ArrowType? { + return arrows.firstOrNull { it.internalName == internalName } + } + + private fun NEUInternalName.asArrowTypeOrNull() = getArrowByNameOrNull(this) + + fun isEnabled() = LorenzUtils.inSkyBlock && storage != null + + + // Load arrows from repo + @SubscribeEvent + fun onRepoReload(event: RepositoryReloadEvent) { + val itemData = event.getConstant<ItemsJson>("Items") + infinityQuiverLevelMultiplier = itemData.enchant_multiplier["infinite_quiver"] ?: 0.03f + + val arrowData = event.getConstant<ArrowTypeJson>("ArrowTypes") + arrows = arrowData.arrows.map { ArrowType(it.value.arrow, it.key.asInternalName()) } + + NONE_ARROW_TYPE = getArrowByNameOrNull("NONE".asInternalName()) + FLINT_ARROW_TYPE = getArrowByNameOrNull("FLINT".asInternalName()) + } + + class UnknownArrowType(message: String) : Exception(message) +} diff --git a/src/main/java/at/hannibal2/skyhanni/data/ScoreboardData.kt b/src/main/java/at/hannibal2/skyhanni/data/ScoreboardData.kt index 661330f92..b2cb66ef0 100644 --- a/src/main/java/at/hannibal2/skyhanni/data/ScoreboardData.kt +++ b/src/main/java/at/hannibal2/skyhanni/data/ScoreboardData.kt @@ -35,13 +35,23 @@ class ScoreboardData { fun formatLines(rawList: List<String>): List<String> { val list = mutableListOf<String>() for (line in rawList) { - val seperator = splitIcons.find { line.contains(it) } ?: continue - val split = line.split(seperator) + val separator = splitIcons.find { line.contains(it) } ?: continue + val split = line.split(separator) val start = split[0] var end = split[1] - if (end.length >= 2) { - end = end.substring(2) + // get last color code in start + val lastColorIndex = start.lastIndexOf('§') + val lastColor = when { + lastColorIndex != -1 && lastColorIndex + 1 < start.length && (start[lastColorIndex + 1] in '0'..'9' || start[lastColorIndex + 1] in 'a'..'f') -> start.substring( + lastColorIndex, + lastColorIndex + 2 + ) + else -> "" } + + // remove first color code from end, when it is the same as the last color code in start + end = end.removePrefix(lastColor) + list.add(start + end) } diff --git a/src/main/java/at/hannibal2/skyhanni/data/SlayerAPI.kt b/src/main/java/at/hannibal2/skyhanni/data/SlayerAPI.kt index 296e2db65..6ecf6935c 100644 --- a/src/main/java/at/hannibal2/skyhanni/data/SlayerAPI.kt +++ b/src/main/java/at/hannibal2/skyhanni/data/SlayerAPI.kt @@ -30,7 +30,7 @@ object SlayerAPI { var latestSlayerCategory = "" private var latestProgressChangeTime = 0L var latestWrongAreaWarning = 0L - private var latestSlayerProgress = "" + var latestSlayerProgress = "" fun hasActiveSlayerQuest() = latestSlayerCategory != "" diff --git a/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/ArrowTypeJson.java b/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/ArrowTypeJson.java new file mode 100644 index 000000000..3388cb62c --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/ArrowTypeJson.java @@ -0,0 +1,14 @@ +package at.hannibal2.skyhanni.data.jsonobjects.repo; + +import com.google.gson.annotations.Expose; +import java.util.Map; + +public class ArrowTypeJson { + @Expose + public Map<String, ArrowAttributes> arrows; + + public static class ArrowAttributes { + @Expose + public String arrow; + } +} diff --git a/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/FameRankJson.java b/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/FameRankJson.java new file mode 100644 index 000000000..e060d55d1 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/FameRankJson.java @@ -0,0 +1,24 @@ +package at.hannibal2.skyhanni.data.jsonobjects.repo; + +import com.google.gson.annotations.Expose; + +import java.util.Map; + +public class FameRankJson { + @Expose + public Map<String, FameRank> fame_rank; + + public static class FameRank { + @Expose + public String name; + + @Expose + public int fame_required; + + @Expose + public double bits_multiplier; + + @Expose + public int votes; + } +} diff --git a/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/ItemsJson.java b/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/ItemsJson.java index ddd814159..0efeeb9fd 100644 --- a/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/ItemsJson.java +++ b/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/ItemsJson.java @@ -14,6 +14,9 @@ public class ItemsJson { public Map<String, Integer> crimson_tiers; @Expose + public Map<String, Float> enchant_multiplier; + + @Expose public List<NEUInternalName> lava_fishing_rods; @Expose diff --git a/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/MaxwellPowersJson.java b/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/MaxwellPowersJson.java new file mode 100644 index 000000000..6ac70abb6 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/MaxwellPowersJson.java @@ -0,0 +1,10 @@ +package at.hannibal2.skyhanni.data.jsonobjects.repo; + +import com.google.gson.annotations.Expose; + +import java.util.List; + +public class MaxwellPowersJson { + @Expose + public List<String> powers; +} diff --git a/src/main/java/at/hannibal2/skyhanni/events/GuiPositionMovedEvent.kt b/src/main/java/at/hannibal2/skyhanni/events/GuiPositionMovedEvent.kt new file mode 100644 index 000000000..3d8fe02f9 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/events/GuiPositionMovedEvent.kt @@ -0,0 +1,3 @@ +package at.hannibal2.skyhanni.events + +class GuiPositionMovedEvent(val guiName: String) : LorenzEvent() diff --git a/src/main/java/at/hannibal2/skyhanni/features/bingo/BingoAPI.kt b/src/main/java/at/hannibal2/skyhanni/features/bingo/BingoAPI.kt index fc884c91d..bee916507 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/bingo/BingoAPI.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/bingo/BingoAPI.kt @@ -72,6 +72,8 @@ object BingoAPI { fun getRankFromScoreboard(text: String) = if (detectionPattern.matches(text)) getRank(text) else null + fun getIconFromScoreboard(text: String) = getRankFromScoreboard(text)?.let { getIcon(it) } + fun getRank(text: String) = ranks.entries.find { text.contains(it.key) }?.value fun getIcon(searchRank: Int) = ranks.entries.find { it.value == searchRank }?.key diff --git a/src/main/java/at/hannibal2/skyhanni/features/event/diana/DianaAPI.kt b/src/main/java/at/hannibal2/skyhanni/features/event/diana/DianaAPI.kt index 7a6fa1d17..e1e420ab4 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/event/diana/DianaAPI.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/event/diana/DianaAPI.kt @@ -2,7 +2,7 @@ package at.hannibal2.skyhanni.features.event.diana import at.hannibal2.skyhanni.SkyHanniMod import at.hannibal2.skyhanni.data.IslandType -import at.hannibal2.skyhanni.data.MayorElection +import at.hannibal2.skyhanni.data.Perk import at.hannibal2.skyhanni.data.PetAPI import at.hannibal2.skyhanni.utils.InventoryUtils import at.hannibal2.skyhanni.utils.ItemUtils.getInternalName @@ -16,8 +16,8 @@ object DianaAPI { fun hasSpadeInHand() = InventoryUtils.itemInHandId == spade - private fun isRitualActive() = MayorElection.isPerkActive("Diana", "Mythological Ritual") || - MayorElection.isPerkActive("Jerry", "Perkpocalypse") || SkyHanniMod.feature.event.diana.alwaysDiana + private fun isRitualActive() = Perk.MYTHOLOGICAL_RITUAL.isActive || + Perk.PERKPOCALYPSE.isActive || SkyHanniMod.feature.event.diana.alwaysDiana fun hasGriffinPet() = PetAPI.isCurrentPet("Griffin") diff --git a/src/main/java/at/hannibal2/skyhanni/features/garden/contest/FarmingContestAPI.kt b/src/main/java/at/hannibal2/skyhanni/features/garden/contest/FarmingContestAPI.kt index 399967809..f9999fe2c 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/garden/contest/FarmingContestAPI.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/garden/contest/FarmingContestAPI.kt @@ -33,7 +33,7 @@ object FarmingContestAPI { "crop", "§8(?<crop>.*) Contest" ) - private val sidebarCropPattern by patternGroup.pattern( + val sidebarCropPattern by patternGroup.pattern( "sidebarcrop", "(?:§e○|§6☘) §f(?<crop>.*) §a.*" ) diff --git a/src/main/java/at/hannibal2/skyhanni/features/garden/farming/GardenCropSpeed.kt b/src/main/java/at/hannibal2/skyhanni/features/garden/farming/GardenCropSpeed.kt index 2da5a21eb..7dc92b8d9 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/garden/farming/GardenCropSpeed.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/garden/farming/GardenCropSpeed.kt @@ -4,7 +4,7 @@ import at.hannibal2.skyhanni.config.ConfigUpdaterMigrator import at.hannibal2.skyhanni.data.ClickType import at.hannibal2.skyhanni.data.GardenCropMilestones.getCounter import at.hannibal2.skyhanni.data.GardenCropMilestones.setCounter -import at.hannibal2.skyhanni.data.MayorElection +import at.hannibal2.skyhanni.data.Perk import at.hannibal2.skyhanni.data.jsonobjects.repo.DicerDropsJson import at.hannibal2.skyhanni.data.jsonobjects.repo.DicerDropsJson.DicerType import at.hannibal2.skyhanni.events.CropClickEvent @@ -175,7 +175,7 @@ object GardenCropSpeed { fun finneganPerkActive(): Boolean { val forcefullyEnabledAlwaysFinnegan = config.forcefullyEnabledAlwaysFinnegan - val perkActive = MayorElection.isPerkActive("Finnegan", "Farming Simulator") + val perkActive = Perk.FARMING_SIMULATOR.isActive return forcefullyEnabledAlwaysFinnegan || perkActive } diff --git a/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/CustomScoreboard.kt b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/CustomScoreboard.kt new file mode 100644 index 000000000..5e15166c0 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/CustomScoreboard.kt @@ -0,0 +1,130 @@ +// +// TODO LIST +// V2 RELEASE +// - Soulflow API +// - Bank API (actually maybe not, I like the current design) +// - beacon power +// - skyblock level +// - more bg options (round, blurr, outline) +// - countdown events like fishing festival + fiesta when its not on tablist +// - CookieAPI https://discord.com/channels/997079228510117908/1162844830360146080/1195695210433351821 +// - Rng meter display +// - shorten time till next mayor https://discord.com/channels/997079228510117908/1162844830360146080/1216440046320746596 +// - option to hide coins earned +// - color options in the purse etc lines +// - choose the amount of decimal places in shorten nums +// - very important bug fix: duplex is weird :( +// + +package at.hannibal2.skyhanni.features.gui.customscoreboard + +import at.hannibal2.skyhanni.SkyHanniMod +import at.hannibal2.skyhanni.events.GuiPositionMovedEvent +import at.hannibal2.skyhanni.events.GuiRenderEvent +import at.hannibal2.skyhanni.events.LorenzTickEvent +import at.hannibal2.skyhanni.utils.ChatUtils +import at.hannibal2.skyhanni.utils.LorenzUtils +import at.hannibal2.skyhanni.utils.RenderUtils.HorizontalAlignment +import at.hannibal2.skyhanni.utils.RenderUtils.renderStringsAlignedWidth +import at.hannibal2.skyhanni.utils.TabListData +import net.minecraftforge.client.GuiIngameForge +import net.minecraftforge.client.event.RenderGameOverlayEvent +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent + +typealias ScoreboardElementType = Pair<String, HorizontalAlignment> + +class CustomScoreboard { + + private var display = emptyList<ScoreboardElementType>() + private var cache = emptyList<ScoreboardElementType>() + private val guiName = "Custom Scoreboard" + + @SubscribeEvent + fun onRenderOverlay(event: GuiRenderEvent.GuiOverlayRenderEvent) { + if (!isEnabled()) return + if (display.isEmpty()) return + + RenderBackground().renderBackground() + + val render = + if (!TabListData.fullyLoaded && config.displayConfig.cacheScoreboardOnIslandSwitch && cache.isNotEmpty()) { + cache + } else { + display + } + config.position.renderStringsAlignedWidth(render, posLabel = guiName) + } + + @SubscribeEvent + fun onGuiPositionMoved(event: GuiPositionMovedEvent) { + if (event.guiName == guiName) { + val alignmentConfig = config.displayConfig.alignment + if (alignmentConfig.alignRight || alignmentConfig.alignCenterVertically) { + alignmentConfig.alignRight = false + alignmentConfig.alignCenterVertically = false + ChatUtils.chat("Disabled Custom Scoreboard auto-alignment.") + } + } + } + + @SubscribeEvent + fun onTick(event: LorenzTickEvent) { + if (!isEnabled()) return + + // Creating the lines + if (event.isMod(5)) { + display = createLines() + if (TabListData.fullyLoaded) { + cache = display.toList() + } + } + + // Remove Known Lines, so we can get the unknown ones + UnknownLinesHandler.handleUnknownLines() + } + + companion object { + internal val config get() = SkyHanniMod.feature.gui.customScoreboard + internal val displayConfig get() = config.displayConfig + internal val informationFilteringConfig get() = config.informationFilteringConfig + internal val backgroundConfig get() = config.backgroundConfig + } + + private fun createLines() = buildList<ScoreboardElementType> { + for (element in config.scoreboardEntries) { + val line = element.getVisiblePair() + + // Hide consecutive empty lines + if ( + config.informationFilteringConfig.hideConsecutiveEmptyLines && + line.isNotEmpty() && line[0].first == "<empty>" && lastOrNull()?.first?.isEmpty() == true + ) { + continue + } + + // Adds empty lines + if (line[0].first == "<empty>") { + add("" to HorizontalAlignment.LEFT) + continue + } + + // Does not display this line + if (line.any { it.first == "<hidden>" }) { + continue + } + + addAll(line) + } + } + + // Thank you Apec for showing that the ElementType of the stupid scoreboard is FUCKING HELMET WTF + @SubscribeEvent + fun onRenderScoreboard(event: RenderGameOverlayEvent.Post) { + if (event.type == RenderGameOverlayEvent.ElementType.HELMET) { + GuiIngameForge.renderObjective = !isHideVanillaScoreboardEnabled() + } + } + + private fun isEnabled() = LorenzUtils.inSkyBlock && config.enabled + private fun isHideVanillaScoreboardEnabled() = isEnabled() && config.displayConfig.hideVanillaScoreboard +} diff --git a/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/CustomScoreboardUtils.kt b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/CustomScoreboardUtils.kt new file mode 100644 index 000000000..74ba89dd6 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/CustomScoreboardUtils.kt @@ -0,0 +1,53 @@ +package at.hannibal2.skyhanni.features.gui.customscoreboard + +import at.hannibal2.skyhanni.config.features.gui.customscoreboard.DisplayConfig +import at.hannibal2.skyhanni.data.HypixelData +import at.hannibal2.skyhanni.data.ScoreboardData +import at.hannibal2.skyhanni.features.bingo.BingoAPI +import at.hannibal2.skyhanni.features.gui.customscoreboard.CustomScoreboard.Companion.config +import at.hannibal2.skyhanni.utils.NumberUtil +import at.hannibal2.skyhanni.utils.NumberUtil.addSeparators +import at.hannibal2.skyhanni.utils.NumberUtil.formatDouble +import at.hannibal2.skyhanni.utils.StringUtils.matchMatcher +import at.hannibal2.skyhanni.utils.StringUtils.removeResets +import at.hannibal2.skyhanni.utils.StringUtils.trimWhiteSpace +import at.hannibal2.skyhanni.utils.TabListData +import java.util.regex.Pattern + +object CustomScoreboardUtils { + private val numberFormat get() = config.displayConfig.numberFormat + + internal fun getGroupFromPattern(list: List<String>, pattern: Pattern, group: String) = list.map { + it.removeResets().trimWhiteSpace() + }.firstNotNullOfOrNull { line -> + pattern.matchMatcher(line) { + group(group) + } + } ?: "0" + + fun getProfileTypeSymbol() = when { + HypixelData.ironman -> "§7♲ " + HypixelData.stranded -> "§a☀ " + HypixelData.bingo -> ScoreboardData.sidebarLinesFormatted.firstNotNullOfOrNull { + BingoAPI.getIconFromScoreboard(it)?.plus(" ") + } ?: "§e❤ " + + else -> "§e" + } + + fun getTablistFooter(): String { + val tabList = TabListData.getPlayerTabOverlay() + if (tabList.footer_skyhanni == null) return "" + return tabList.footer_skyhanni.formattedText.replace("§r", "") + } + + internal fun Number.formatNum(): String = when (numberFormat) { + DisplayConfig.NumberFormat.SHORT -> NumberUtil.format(this) + DisplayConfig.NumberFormat.LONG -> this.addSeparators() + else -> "0" + } + + internal fun String.formatNum() = this.formatDouble().formatNum() + + class UndetectedScoreboardLines(message: String) : Exception(message) +} diff --git a/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/RenderBackground.kt b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/RenderBackground.kt new file mode 100644 index 000000000..2a2f009ac --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/RenderBackground.kt @@ -0,0 +1,87 @@ +package at.hannibal2.skyhanni.features.gui.customscoreboard + +import at.hannibal2.skyhanni.config.core.config.Position +import at.hannibal2.skyhanni.data.GuiEditManager +import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getAbsX +import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getAbsY +import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getDummySize +import at.hannibal2.skyhanni.features.gui.customscoreboard.CustomScoreboard.Companion.backgroundConfig +import at.hannibal2.skyhanni.features.gui.customscoreboard.CustomScoreboard.Companion.config +import at.hannibal2.skyhanni.utils.RenderUtils +import at.hannibal2.skyhanni.utils.SpecialColour +import io.github.moulberry.notenoughupdates.util.Utils +import net.minecraft.client.Minecraft +import net.minecraft.client.gui.ScaledResolution +import net.minecraft.client.renderer.GlStateManager +import net.minecraft.util.ResourceLocation +import org.lwjgl.opengl.GL11 + +class RenderBackground { + fun renderBackground() { + val position = config.position + val border = 5 + + val x = position.getAbsX() + val y = position.getAbsY() + + val elementWidth = position.getDummySize().x + val elementHeight = position.getDummySize().y + + val scaledWidth = ScaledResolution(Minecraft.getMinecraft()).scaledWidth + val scaledHeight = ScaledResolution(Minecraft.getMinecraft()).scaledHeight + + // Update the position to the alignment options + if ( + config.displayConfig.alignment.alignRight + || config.displayConfig.alignment.alignCenterVertically + ) { + position.set( + Position( + if (config.displayConfig.alignment.alignRight) + scaledWidth - elementWidth - (backgroundConfig.borderSize * 2) + else x, + if (config.displayConfig.alignment.alignCenterVertically) + scaledHeight / 2 - elementHeight / 2 + else y, + position.getScale(), + position.isCenter + ) + ) + } + + if (GuiEditManager.isInGui()) return + + GlStateManager.pushMatrix() + GlStateManager.pushAttrib() + + GlStateManager.color(1f, 1f, 1f, 1f) + + + if (backgroundConfig.enabled) { + if (backgroundConfig.useCustomBackgroundImage) { + val textureLocation = ResourceLocation("skyhanni", "scoreboard.png") + Minecraft.getMinecraft().textureManager.bindTexture(textureLocation) + + Utils.drawTexturedRect( + (x - backgroundConfig.borderSize).toFloat(), + (y - backgroundConfig.borderSize).toFloat(), + (elementWidth + backgroundConfig.borderSize * 3).toFloat(), + (elementHeight + border * 2).toFloat(), + GL11.GL_NEAREST + ) + } else { + RenderUtils.drawRoundRect( + x - backgroundConfig.borderSize, + y - backgroundConfig.borderSize, + elementWidth + backgroundConfig.borderSize * 3, + elementHeight + backgroundConfig.borderSize * 2, + SpecialColour.specialToChromaRGB(backgroundConfig.color), + backgroundConfig.roundedCornerSmoothness + ) + } + } + + GlStateManager.popMatrix() + GlStateManager.popAttrib() + } +} diff --git a/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/ScoreboardElements.kt b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/ScoreboardElements.kt new file mode 100644 index 000000000..801ba3249 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/ScoreboardElements.kt @@ -0,0 +1,635 @@ +package at.hannibal2.skyhanni.features.gui.customscoreboard + +import at.hannibal2.skyhanni.config.features.gui.customscoreboard.DisplayConfig.ArrowAmountDisplay +import at.hannibal2.skyhanni.data.BitsAPI +import at.hannibal2.skyhanni.data.HypixelData +import at.hannibal2.skyhanni.data.IslandType +import at.hannibal2.skyhanni.data.MaxwellAPI +import at.hannibal2.skyhanni.data.MayorAPI +import at.hannibal2.skyhanni.data.PartyAPI +import at.hannibal2.skyhanni.data.PurseAPI +import at.hannibal2.skyhanni.data.QuiverAPI +import at.hannibal2.skyhanni.data.QuiverAPI.NONE_ARROW_TYPE +import at.hannibal2.skyhanni.data.QuiverAPI.asArrowPercentage +import at.hannibal2.skyhanni.data.ScoreboardData +import at.hannibal2.skyhanni.data.SlayerAPI +import at.hannibal2.skyhanni.features.gui.customscoreboard.CustomScoreboard.Companion.config +import at.hannibal2.skyhanni.features.gui.customscoreboard.CustomScoreboard.Companion.displayConfig +import at.hannibal2.skyhanni.features.gui.customscoreboard.CustomScoreboard.Companion.informationFilteringConfig +import at.hannibal2.skyhanni.features.gui.customscoreboard.CustomScoreboardUtils.formatNum +import at.hannibal2.skyhanni.features.gui.customscoreboard.CustomScoreboardUtils.getGroupFromPattern +import at.hannibal2.skyhanni.mixins.hooks.tryToReplaceScoreboardLine +import at.hannibal2.skyhanni.test.command.ErrorManager +import at.hannibal2.skyhanni.utils.CollectionUtils.nextAfter +import at.hannibal2.skyhanni.utils.LorenzUtils.inAdvancedMiningIsland +import at.hannibal2.skyhanni.utils.LorenzUtils.inAnyIsland +import at.hannibal2.skyhanni.utils.LorenzUtils.inDungeons +import at.hannibal2.skyhanni.utils.NumberUtil.addSeparators +import at.hannibal2.skyhanni.utils.NumberUtil.percentageColor +import at.hannibal2.skyhanni.utils.RenderUtils.HorizontalAlignment +import at.hannibal2.skyhanni.utils.StringUtils.firstLetterUppercase +import at.hannibal2.skyhanni.utils.StringUtils.matches +import at.hannibal2.skyhanni.utils.TabListData +import at.hannibal2.skyhanni.utils.TimeUtils.format +import at.hannibal2.skyhanni.utils.TimeUtils.formatted +import io.github.moulberry.notenoughupdates.util.SkyBlockTime +import java.util.function.Supplier + +internal var unknownLines = listOf<String>() +internal var amountOfUnknownLines = 0 + +enum class ScoreboardElement( + private val displayPair: Supplier<List<ScoreboardElementType>>, + private val showWhen: () -> Boolean, + private val configLine: String +) { + TITLE( + ::getTitleDisplayPair, + { true }, + "§6§lSKYBLOCK" + ), + PROFILE( + ::getProfileDisplayPair, + { true }, + "§7♲ Blueberry" + ), + PURSE( + ::getPurseDisplayPair, + ::getPurseShowWhen, + "Purse: §652,763,737" + ), + MOTES( + ::getMotesDisplayPair, + ::getMotesShowWhen, + "Motes: §d64,647" + ), + BANK( + ::getBankDisplayPair, + ::getBankShowWhen, + "Bank: §6249M" + ), + BITS( + ::getBitsDisplayPair, + ::getBitsShowWhen, + "Bits: §b59,264" + ), + COPPER( + ::getCopperDisplayPair, + ::getCopperShowWhen, + "Copper: §c23,495" + ), + GEMS( + ::getGemsDisplayPair, + ::getGemsShowWhen, + "Gems: §a57,873" + ), + HEAT( + ::getHeatDisplayPair, + ::getHeatShowWhen, + "Heat: §c♨ 0" + ), + NORTH_STARS( + ::getNorthStarsDisplayPair, + ::getNorthStarsShowWhen, + "North Stars: §d756" + ), + EMPTY_LINE( + ::getEmptyLineDisplayPair, + { true }, "" + ), + ISLAND( + ::getIslandDisplayPair, + { true }, + "§7㋖ §aHub" + ), + LOCATION( + ::getLocationDisplayPair, + { true }, + "§7⏣ §bVillage" + ), + VISITING( + ::getVisitDisplayPair, + ::getVisitShowWhen, + " §a✌ §7(§a1§7/6)" + ), + DATE( + ::getDateDisplayPair, + { true }, + "Late Summer 11th" + ), + TIME( + ::getTimeDisplayPair, + { true }, + "§710:40pm §b☽" + ), + LOBBY_CODE( + ::getLobbyDisplayPair, + { true }, + "§8m77CK" + ), + POWER( + ::getPowerDisplayPair, + ::getPowerShowWhen, + "Power: Sighted" + ), + COOKIE( + ::getCookieDisplayPair, + ::getCookieShowWhen, + "§d§lCookie Buff\n §f3days, 17hours" + ), + EMPTY_LINE2( + ::getEmptyLineDisplayPair, + { true }, "" + ), + OBJECTIVE( + ::getObjectiveDisplayPair, + ::getObjectiveShowWhen, + "Objective:\n§eStar SkyHanni on Github" + ), + SLAYER( + ::getSlayerDisplayPair, + ::getSlayerShowWhen, + "Slayer Quest\n §7- §cVoidgloom Seraph III\n §7- §e12§7/§c120 §7Kills" + ), + EMPTY_LINE3( + ::getEmptyLineDisplayPair, + { true }, + "" + ), + QUIVER( + ::getQuiverDisplayPair, + ::getQuiverShowWhen, + "Flint Arrow: §f1,234" + ), + POWDER( + ::getPowderDisplayPair, + ::getPowderShowWhen, + "§9§lPowder\n §7- §fMithril: §254,646\n §7- §fGemstone: §d51,234" + ), + EVENTS( + ::getEventsDisplayPair, + ::getEventsShowWhen, + "§7Wide Range of Events\n§7(too much to show all)" + ), + MAYOR( + ::getMayorDisplayPair, + ::getMayorShowWhen, + "§2Diana:\n §7- §eLucky!\n §7- §eMythological Ritual\n §7- §ePet XP Buff" + ), + PARTY( + ::getPartyDisplayPair, + ::getPartyShowWhen, + "§9§lParty (4):\n §7- §fhannibal2\n §7- §fMoulberry\n §7- §fVahvl\n §7- §fJ10a1n15" + ), + FOOTER( + ::getFooterDisplayPair, + { true }, + "§ewww.hypixel.net" + ), + EXTRA( + ::getExtraDisplayPair, + ::getExtraShowWhen, + "§cUnknown lines the mod is not detecting" + ), + ; + + override fun toString(): String { + return configLine + } + + fun getVisiblePair() = if (isVisible()) getPair() else listOf("<hidden>" to HorizontalAlignment.LEFT) + + private fun getPair(): List<ScoreboardElementType> { + return try { + displayPair.get() + } catch (e: NoSuchElementException) { + listOf("<hidden>" to HorizontalAlignment.LEFT) + } + } + + private fun isVisible(): Boolean { + if (!informationFilteringConfig.hideIrrelevantLines) return true + return showWhen() + } +} + + +private fun getTitleDisplayPair() = if (displayConfig.titleAndFooter.useHypixelTitleAnimation) { + listOf(ScoreboardData.objectiveTitle to displayConfig.titleAndFooter.alignTitleAndFooter) +} else { + listOf( + displayConfig.titleAndFooter.customTitle.get().toString() + .replace("&", "§") to displayConfig.titleAndFooter.alignTitleAndFooter + ) +} + +private fun getProfileDisplayPair() = + listOf(CustomScoreboardUtils.getProfileTypeSymbol() + HypixelData.profileName.firstLetterUppercase() to HorizontalAlignment.LEFT) + +private fun getPurseDisplayPair(): List<ScoreboardElementType> { + var purse = PurseAPI.currentPurse.formatNum() + + val earned = getGroupFromPattern(ScoreboardData.sidebarLinesFormatted, PurseAPI.coinsPattern, "earned") + + if (earned != "0") { + purse += " §7(§e+$earned§7)§6" + } + + return listOf( + when { + informationFilteringConfig.hideEmptyLines && purse == "0" -> "<hidden>" + displayConfig.displayNumbersFirst -> "§6$purse Purse" + else -> "Purse: §6$purse" + } to HorizontalAlignment.LEFT + ) +} + +private fun getPurseShowWhen() = !inAnyIsland(IslandType.THE_RIFT) + +private fun getMotesDisplayPair(): List<ScoreboardElementType> { + val motes = getGroupFromPattern(ScoreboardData.sidebarLinesFormatted, ScoreboardPattern.motesPattern, "motes") + .formatNum() + + return listOf( + when { + informationFilteringConfig.hideEmptyLines && motes == "0" -> "<hidden>" + displayConfig.displayNumbersFirst -> "§d$motes Motes" + else -> "Motes: §d$motes" + } to HorizontalAlignment.LEFT + ) +} + +private fun getMotesShowWhen() = inAnyIsland(IslandType.THE_RIFT) + +private fun getBankDisplayPair(): List<ScoreboardElementType> { + val bank = getGroupFromPattern(TabListData.getTabList(), ScoreboardPattern.bankPattern, "bank") + + return listOf( + when { + informationFilteringConfig.hideEmptyLines && bank == "0" -> "<hidden>" + displayConfig.displayNumbersFirst -> "§6$bank Bank" + else -> "Bank: §6$bank" + } to HorizontalAlignment.LEFT + ) +} + +private fun getBankShowWhen() = !inAnyIsland(IslandType.THE_RIFT) + +private fun getBitsDisplayPair(): List<ScoreboardElementType> { + val bits = BitsAPI.bits.coerceAtLeast(0).formatNum() + val bitsToClaim = if (BitsAPI.bitsToClaim == -1) { + "§cOpen Sbmenu§b" + } else { + BitsAPI.bitsToClaim.coerceAtLeast(0).formatNum() + } + + return listOf( + when { + informationFilteringConfig.hideEmptyLines && bits == "0" && bitsToClaim == "0" -> "<hidden>" + displayConfig.displayNumbersFirst -> { + if (displayConfig.showUnclaimedBits) { + "§b$bits§7/${if (bitsToClaim == "0") "§30" else "§b${bitsToClaim}"} §bBits" + } else { + "§b$bits Bits" + } + } + + else -> { + if (displayConfig.showUnclaimedBits) { + "Bits: §b$bits§7/${if (bitsToClaim == "0") "§30" else "§b${bitsToClaim}"}" + } else { + "Bits: §b$bits" + } + } + } to HorizontalAlignment.LEFT + ) +} + +private fun getBitsShowWhen() = !HypixelData.bingo && !inAnyIsland(IslandType.CATACOMBS, IslandType.KUUDRA_ARENA) + +private fun getCopperDisplayPair(): List<ScoreboardElementType> { + val copper = getGroupFromPattern(ScoreboardData.sidebarLinesFormatted, ScoreboardPattern.copperPattern, "copper") + .formatNum() + + return listOf( + when { + informationFilteringConfig.hideEmptyLines && copper == "0" -> "<hidden>" + displayConfig.displayNumbersFirst -> "§c$copper Copper" + else -> "Copper: §c$copper" + } to HorizontalAlignment.LEFT + ) +} + +private fun getCopperShowWhen() = inAnyIsland(IslandType.GARDEN) + +private fun getGemsDisplayPair(): List<ScoreboardElementType> { + val gems = getGroupFromPattern(TabListData.getTabList(), ScoreboardPattern.gemsPattern, "gems") + + return listOf( + when { + informationFilteringConfig.hideEmptyLines && gems == "0" -> "<hidden>" + displayConfig.displayNumbersFirst -> "§a$gems Gems" + else -> "Gems: §a$gems" + } to HorizontalAlignment.LEFT + ) +} + +private fun getGemsShowWhen() = !inAnyIsland(IslandType.THE_RIFT, IslandType.CATACOMBS, IslandType.KUUDRA_ARENA) + +private fun getHeatDisplayPair(): List<ScoreboardElementType> { + val heat = getGroupFromPattern(ScoreboardData.sidebarLinesFormatted, ScoreboardPattern.heatPattern, "heat") + + return listOf( + when { + informationFilteringConfig.hideEmptyLines && heat == "§c♨ 0" -> "<hidden>" + displayConfig.displayNumbersFirst -> if (heat == "0") "§c♨ 0 Heat" else "$heat Heat" + else -> if (heat == "0") "Heat: §c♨ 0" else "Heat: $heat" + } to HorizontalAlignment.LEFT + ) +} + +private fun getHeatShowWhen() = inAnyIsland(IslandType.CRYSTAL_HOLLOWS) + && ScoreboardData.sidebarLinesFormatted.any { ScoreboardPattern.heatPattern.matches(it) } + +private fun getNorthStarsDisplayPair(): List<ScoreboardElementType> { + val northStars = + getGroupFromPattern(ScoreboardData.sidebarLinesFormatted, ScoreboardPattern.northstarsPattern, "northstars") + .formatNum() + + return listOf( + when { + informationFilteringConfig.hideEmptyLines && northStars == "0" -> "<hidden>" + displayConfig.displayNumbersFirst -> "§d$northStars North Stars" + else -> "North Stars: §d$northStars" + } to HorizontalAlignment.LEFT + ) +} + +private fun getNorthStarsShowWhen() = inAnyIsland(IslandType.WINTER) + +private fun getEmptyLineDisplayPair() = listOf("<empty>" to HorizontalAlignment.LEFT) + +private fun getIslandDisplayPair() = + listOf("§7㋖ §a" + HypixelData.skyBlockIsland.displayName to HorizontalAlignment.LEFT) + +private fun getLocationDisplayPair() = buildList { + add( + (tryToReplaceScoreboardLine( + getGroupFromPattern( + ScoreboardData.sidebarLinesFormatted, + ScoreboardPattern.locationPattern, + "location" + ) + )?.trim() + ?: "<hidden>") to HorizontalAlignment.LEFT + ) + + val plotLine = ScoreboardData.sidebarLinesFormatted.firstOrNull { ScoreboardPattern.plotPattern.matches(it) } + if (plotLine != null) add(plotLine to HorizontalAlignment.LEFT) +} + +private fun getVisitDisplayPair() = + listOf( + ScoreboardData.sidebarLinesFormatted.first { ScoreboardPattern.visitingPattern.matches(it) } to HorizontalAlignment.LEFT + ) + +private fun getVisitShowWhen() = + ScoreboardData.sidebarLinesFormatted.any { ScoreboardPattern.visitingPattern.matches(it) } + +private fun getDateDisplayPair() = + listOf( + SkyBlockTime.now().formatted(yearElement = false, hoursAndMinutesElement = false) to HorizontalAlignment.LEFT + ) + + +private fun getTimeDisplayPair(): List<ScoreboardElementType> { + var symbol = getGroupFromPattern(ScoreboardData.sidebarLinesFormatted, ScoreboardPattern.timePattern, "symbol") + if (symbol == "0") symbol = "" + return listOf( + "§7" + SkyBlockTime.now() + .formatted(dayAndMonthElement = false, yearElement = false) + " $symbol" to HorizontalAlignment.LEFT + ) +} + +private fun getLobbyDisplayPair(): List<ScoreboardElementType> { + val lobbyCode = getGroupFromPattern( + ScoreboardData.sidebarLinesFormatted, + ScoreboardPattern.lobbyCodePattern, + "code" + ) + + val displayValue = if (lobbyCode == "0") "<hidden>" else "§8$lobbyCode" + return listOf(displayValue to HorizontalAlignment.LEFT) +} + +private fun getPowerDisplayPair() = listOf( + when (MaxwellAPI.currentPower) { + null -> "§cOpen \"Your Bags\"!" + else -> + if (displayConfig.displayNumbersFirst) { + "${MaxwellAPI.currentPower?.replace("Power", "")} Power " + + "§7(§6${MaxwellAPI.magicalPower}§7)" + } else { + "Power: ${MaxwellAPI.currentPower?.replace("Power", "")} " + + "§7(§6${MaxwellAPI.magicalPower?.addSeparators()}§7)" + } + } to HorizontalAlignment.LEFT +) + +private fun getPowerShowWhen() = !inAnyIsland(IslandType.THE_RIFT) + +private fun getCookieDisplayPair(): List<ScoreboardElementType> { + val timeLine = CustomScoreboardUtils.getTablistFooter().split("\n") + .nextAfter("§d§lCookie Buff") ?: "<hidden>" + + return listOf( + "§d§lCookie Buff" to HorizontalAlignment.LEFT, + if (timeLine.contains("Not active")) + " §7- §cNot active" to HorizontalAlignment.LEFT + else + " §7- §e${timeLine.substringAfter("§d§lCookie Buff").trim()}" to HorizontalAlignment.LEFT + ) +} + +private fun getCookieShowWhen(): Boolean { + if (HypixelData.bingo) return false + + return if (informationFilteringConfig.hideEmptyLines) { + CustomScoreboardUtils.getTablistFooter().split("\n").any { + CustomScoreboardUtils.getTablistFooter().split("\n").nextAfter("§d§lCookie Buff")?.contains(it) + ?: false + } + } else { + true + } +} + +private fun getObjectiveDisplayPair() = buildList { + val objective = ScoreboardData.sidebarLinesFormatted.first { ScoreboardPattern.objectivePattern.matches(it) } + + add(objective to HorizontalAlignment.LEFT) + add((ScoreboardData.sidebarLinesFormatted.nextAfter(objective) ?: "<hidden>") to HorizontalAlignment.LEFT) + + if (ScoreboardData.sidebarLinesFormatted.any { ScoreboardPattern.thirdObjectiveLinePattern.matches(it) }) { + add( + (ScoreboardData.sidebarLinesFormatted.nextAfter(objective, 2) + ?: "Second objective here") to HorizontalAlignment.LEFT + ) + } +} + +private fun getObjectiveShowWhen(): Boolean = + !inAnyIsland(IslandType.KUUDRA_ARENA) + && ScoreboardData.sidebarLinesFormatted.none { ScoreboardPattern.objectivePattern.matches(it) } + + +private fun getSlayerDisplayPair(): List<ScoreboardElementType> = listOf( + (if (SlayerAPI.hasActiveSlayerQuest()) "Slayer Quest" else "<hidden>") to HorizontalAlignment.LEFT, + (" §7- §e${SlayerAPI.latestSlayerCategory.trim()}" to HorizontalAlignment.LEFT), + (" §7- §e${SlayerAPI.latestSlayerProgress.trim()}" to HorizontalAlignment.LEFT) +) + +// TODO: Redo the Slayer showWhen +private fun getSlayerShowWhen() = true + +private fun getQuiverDisplayPair(): List<ScoreboardElementType> { + if (QuiverAPI.currentArrow == null) + return listOf("§cChange your Arrow once" to HorizontalAlignment.LEFT) + if (QuiverAPI.currentArrow == NONE_ARROW_TYPE) + return listOf("No Arrows selected" to HorizontalAlignment.LEFT) + + val amountString = (if (displayConfig.colorArrowAmount) { + percentageColor(QuiverAPI.currentAmount.toLong(), QuiverAPI.MAX_ARROW_AMOUNT.toLong()).getChatColor() + } else { + "" + }) + when (displayConfig.arrowAmountDisplay) { + ArrowAmountDisplay.NUMBER -> QuiverAPI.currentAmount.addSeparators() + ArrowAmountDisplay.PERCENTAGE -> "${QuiverAPI.currentAmount.asArrowPercentage()}%" + else -> QuiverAPI.currentAmount.addSeparators() + } + + return listOf( + if (displayConfig.displayNumbersFirst) { + "$amountString ${QuiverAPI.currentArrow?.arrow}s" + } else { + "${QuiverAPI.currentArrow?.arrow?.replace(" Arrow", "")}: $amountString Arrows" + } to HorizontalAlignment.LEFT + ) +} + +private fun getQuiverShowWhen(): Boolean { + if (informationFilteringConfig.hideIrrelevantLines && !QuiverAPI.hasBowInInventory()) return false + return !inAnyIsland(IslandType.THE_RIFT) +} + +private fun getPowderDisplayPair() = buildList { + val mithrilPowder = + getGroupFromPattern(TabListData.getTabList(), ScoreboardPattern.mithrilPowderPattern, "mithrilpowder") + .formatNum() + val gemstonePowder = + getGroupFromPattern(TabListData.getTabList(), ScoreboardPattern.gemstonePowderPattern, "gemstonepowder") + .formatNum() + + add("§9§lPowder" to HorizontalAlignment.LEFT) + + if (informationFilteringConfig.hideEmptyLines && mithrilPowder == "0" && gemstonePowder == "0") { + add(0, "<hidden>" to HorizontalAlignment.LEFT) + } else { + if (displayConfig.displayNumbersFirst) { + add(" §7- §2$mithrilPowder Mithril" to HorizontalAlignment.LEFT) + add(" §7- §d$gemstonePowder Gemstone" to HorizontalAlignment.LEFT) + } else { + add(" §7- §fMithril: §2$mithrilPowder" to HorizontalAlignment.LEFT) + add(" §7- §fGemstone: §d$gemstonePowder" to HorizontalAlignment.LEFT) + } + } +} + +private fun getPowderShowWhen() = inAdvancedMiningIsland() + +private fun getEventsDisplayPair(): List<ScoreboardElementType> { + return ScoreboardEvents.getEvent() + .flatMap { it.getLines().map { i -> i to HorizontalAlignment.LEFT } } + .takeIf { it.isNotEmpty() } ?: listOf("<hidden>" to HorizontalAlignment.LEFT) +} + +private fun getEventsShowWhen() = ScoreboardEvents.getEvent().isNotEmpty() + +private fun getMayorDisplayPair() = buildList { + add( + ((MayorAPI.currentMayor?.mayorName?.let { MayorAPI.mayorNameWithColorCode(it) } + ?: "<hidden>") + + (if (config.mayorConfig.showTimeTillNextMayor) { + "§7 (§e${MayorAPI.timeTillNextMayor.format()}§7)" + } else { + "" + })) to HorizontalAlignment.LEFT + ) + if (config.mayorConfig.showMayorPerks) { + MayorAPI.currentMayor?.activePerks?.forEach { + add(" §7- §e${it.perkName}" to HorizontalAlignment.LEFT) + } + } +} + +private fun getMayorShowWhen() = + !inAnyIsland(IslandType.THE_RIFT) && MayorAPI.currentMayor != null + +private fun getPartyDisplayPair() = + if (PartyAPI.partyMembers.isEmpty() && informationFilteringConfig.hideEmptyLines) { + listOf("<hidden>" to HorizontalAlignment.LEFT) + } else { + val title = + if (PartyAPI.partyMembers.isEmpty()) "§9§lParty" else "§9§lParty (${PartyAPI.partyMembers.size})" + val partyList = PartyAPI.partyMembers + .take(config.partyConfig.maxPartyList.get()) + .map { + " §7- §7$it" + } + .toTypedArray() + listOf(title, *partyList).map { it to HorizontalAlignment.LEFT } + } + +private fun getPartyShowWhen() = if (inDungeons) { + false // Hidden bc the scoreboard lines already exist +} else { + if (config.partyConfig.showPartyEverywhere) { + true + } else { + inAnyIsland( + IslandType.DUNGEON_HUB, + IslandType.KUUDRA_ARENA, + IslandType.CRIMSON_ISLE + ) + } +} + +private fun getFooterDisplayPair() = listOf( + displayConfig.titleAndFooter.customFooter.get().toString() + .replace("&", "§") to displayConfig.titleAndFooter.alignTitleAndFooter +) + +private fun getExtraDisplayPair(): List<ScoreboardElementType> { + if (unknownLines.isEmpty()) return listOf("<hidden>" to HorizontalAlignment.LEFT) + + if (amountOfUnknownLines != unknownLines.size && config.unknownLinesWarning) { + ErrorManager.logErrorWithData( + CustomScoreboardUtils.UndetectedScoreboardLines("CustomScoreboard detected ${unknownLines.size} unknown line${if (unknownLines.size > 1) "s" else ""}"), + "CustomScoreboard detected ${unknownLines.size} unknown line${if (unknownLines.size > 1) "s" else ""}", + "Unknown Lines" to unknownLines, + "Island" to HypixelData.skyBlockIsland, + "Area" to HypixelData.skyBlockArea, + noStackTrace = true + ) + amountOfUnknownLines = unknownLines.size + } + + return listOf("§cUndetected Lines:" to HorizontalAlignment.LEFT) + unknownLines.map { it to HorizontalAlignment.LEFT } +} + +private fun getExtraShowWhen(): Boolean { + if (unknownLines.isEmpty()) { + amountOfUnknownLines = 0 + } + return unknownLines.isNotEmpty() +} diff --git a/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/ScoreboardEvents.kt b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/ScoreboardEvents.kt new file mode 100644 index 000000000..0ca968a98 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/ScoreboardEvents.kt @@ -0,0 +1,498 @@ +package at.hannibal2.skyhanni.features.gui.customscoreboard + +import at.hannibal2.skyhanni.data.HypixelData +import at.hannibal2.skyhanni.data.IslandType +import at.hannibal2.skyhanni.data.ScoreboardData +import at.hannibal2.skyhanni.features.garden.contest.FarmingContestAPI.sidebarCropPattern +import at.hannibal2.skyhanni.features.gui.customscoreboard.CustomScoreboard.Companion.config +import at.hannibal2.skyhanni.features.gui.customscoreboard.ScoreboardEvents.VOTING +import at.hannibal2.skyhanni.features.gui.customscoreboard.ScoreboardPattern +import at.hannibal2.skyhanni.features.misc.ServerRestartTitle +import at.hannibal2.skyhanni.features.rift.area.stillgorechateau.RiftBloodEffigies +import at.hannibal2.skyhanni.utils.CollectionUtils.addIfNotNull +import at.hannibal2.skyhanni.utils.CollectionUtils.nextAfter +import at.hannibal2.skyhanni.utils.LorenzUtils.inAdvancedMiningIsland +import at.hannibal2.skyhanni.utils.LorenzUtils.inDungeons +import at.hannibal2.skyhanni.utils.LorenzUtils.isInIsland +import at.hannibal2.skyhanni.utils.StringUtils.anyMatches +import at.hannibal2.skyhanni.utils.StringUtils.matchMatcher +import at.hannibal2.skyhanni.utils.StringUtils.matches +import at.hannibal2.skyhanni.utils.TabListData +import java.util.function.Supplier +import at.hannibal2.skyhanni.features.gui.customscoreboard.ScoreboardPattern as SbPattern + +/** + * This enum contains all the lines that either are events or other lines that are so rare/not often seen that they + * don't fit in the normal [ScoreboardElement] enum. + * + * We for example have the [VOTING] Event, while this is clearly not an event, I don't consider them as normal lines + * because they are visible for a maximum of like 1 minute every 5 days and ~12 hours. + */ + +private fun getSbLines(): List<String> { + return ScoreboardData.sidebarLinesFormatted +} + +enum class ScoreboardEvents(private val displayLine: Supplier<List<String>>, private val showWhen: () -> Boolean) { + VOTING( + ::getVotingLines, + ::getVotingShowWhen + ), + SERVER_CLOSE( + ::getServerCloseLines, + ::getServerCloseShowWhen + ), + DUNGEONS( + ::getDungeonsLines, + ::getDungeonsShowWhen + ), + KUUDRA( + ::getKuudraLines, + ::getKuudraShowWhen + ), + DOJO( + ::getDojoLines, + ::getDojoShowWhen + ), + DARK_AUCTION( + ::getDarkAuctionLines, + ::getDarkAuctionShowWhen + ), + JACOB_CONTEST( + ::getJacobContestLines, + ::getJacobContestShowWhen + ), + JACOB_MEDALS( + ::getJacobMedalsLines, + ::getJacobMedalsShowWhen + ), + TRAPPER( + ::getTrapperLines, + ::getTrapperShowWhen + ), + GARDEN_CLEAN_UP( + ::getGardenCleanUpLines, + ::getGardenCleanUpShowWhen + ), + GARDEN_PASTING( + ::getGardenPastingLines, + ::getGardenPastingShowWhen + ), + FLIGHT_DURATION( + ::getFlightDurationLines, + ::getFlightDurationShowWhen + ), + WINTER( + ::getWinterLines, + ::getWinterShowWhen + ), + SPOOKY( + ::getSpookyLines, + ::getSpookyShowWhen + ), + ACTIVE_TABLIST_EVENTS( + ::getActiveEventLine, + ::getActiveEventShowWhen + ), + BROODMOTHER( + ::getBroodmotherLines, + ::getBroodmotherShowWhen + ), + NEW_YEAR( + ::getNewYearLines, + ::getNewYearShowWhen + ), + ORINGO( + ::getOringoLines, + ::getOringoShowWhen + ), + MINING_EVENTS( + ::getMiningEventsLines, + ::getMiningEventsShowWhen + ), + DAMAGE( + ::getDamageLines, + ::getDamageShowWhen + ), + MAGMA_BOSS( + ::getMagmaBossLines, + ::getMagmaBossShowWhen + ), + ESSENCE( + ::getEssenceLines, + ::getEssenceShowWhen + ), + EFFIGIES( + ::getEffigiesLines, + ::getEffigiesShowWhen + ), + REDSTONE( + ::getRedstoneLines, + ::getRedstoneShowWhen + ), + + // Maybe as a default state, use tablist "Events: ..." + NONE( + ::getNoneLines, + { false } + ); + + fun getLines(): List<String> { + return displayLine.get() + } + + companion object { + fun getEvent(): List<ScoreboardEvents> { + if (config.displayConfig.showAllActiveEvents) { + return entries.filter { it.showWhen() } + } + return listOf(entries.firstOrNull { it.showWhen() } ?: NONE) + } + } +} + +private fun getVotingLines() = buildList { + val sbLines = getSbLines() + + val yearLine = sbLines.firstOrNull { SbPattern.yearVotesPattern.matches(it) } ?: return emptyList<String>() + addIfNotNull(yearLine) + + if (sbLines.nextAfter(yearLine) == "§7Waiting for") { + add("§7Waiting for") + add("§7your vote...") + } else { + if (SbPattern.votesPattern.anyMatches(sbLines)) { + addAll(sbLines.filter { SbPattern.votesPattern.matches(it) }) + } + } +} + + +private fun getVotingShowWhen(): Boolean { + return SbPattern.yearVotesPattern.anyMatches(getSbLines()) +} + +private fun getServerCloseLines() = buildList { + val matchingLine = getSbLines().first { ServerRestartTitle.restartingGreedyPattern.matches(it) } + add(matchingLine.split("§8")[0]) +} + +private fun getServerCloseShowWhen(): Boolean { + return ServerRestartTitle.restartingGreedyPattern.anyMatches(getSbLines()) +} + +private fun getDungeonsLines() = listOf( + SbPattern.autoClosingPattern, + SbPattern.startingInPattern, + SbPattern.keysPattern, + SbPattern.timeElapsedPattern, + SbPattern.clearedPattern, + SbPattern.soloPattern, + SbPattern.teammatesPattern, + SbPattern.floor3GuardiansPattern +).let { patterns -> + // BetterMap adds a random §r at the start, making it go black + getSbLines().filter { line -> patterns.any { it.matches(line.replace("§r", "")) } } +} + +private fun getDungeonsShowWhen(): Boolean { + return IslandType.CATACOMBS.isInIsland() || inDungeons +} + +private fun getKuudraLines() = listOf( + SbPattern.autoClosingPattern, + SbPattern.startingInPattern, + SbPattern.timeElapsedPattern, + SbPattern.instanceShutdownPattern, + SbPattern.wavePattern, + SbPattern.tokensPattern, + SbPattern.submergesPattern +) + .mapNotNull { pattern -> + getSbLines().firstOrNull { pattern.matches(it) } + } + +private fun getKuudraShowWhen(): Boolean { + return IslandType.KUUDRA_ARENA.isInIsland() +} + +private fun getDojoLines() = listOf( + SbPattern.dojoChallengePattern, + SbPattern.dojoDifficultyPattern, + SbPattern.dojoPointsPattern, + SbPattern.dojoTimePattern +) + .mapNotNull { pattern -> + getSbLines().firstOrNull { pattern.matches(it) } + } + +private fun getDojoShowWhen(): Boolean { + return SbPattern.dojoChallengePattern.anyMatches(getSbLines()) +} + +private fun getDarkAuctionLines() = buildList { + getSbLines().firstOrNull { SbPattern.startingInPattern.matches(it) }?.let { add(it) } + getSbLines().firstOrNull { SbPattern.timeLeftPattern.matches(it) }?.let { add(it) } + + val darkAuctionCurrentItemLine = + getSbLines().firstOrNull { SbPattern.darkAuctionCurrentItemPattern.matches(it) } + + if (darkAuctionCurrentItemLine != null) { + addIfNotNull(darkAuctionCurrentItemLine) + addIfNotNull(getSbLines().nextAfter(darkAuctionCurrentItemLine)) + } +} + +private fun getDarkAuctionShowWhen(): Boolean { + return IslandType.DARK_AUCTION.isInIsland() +} + +private fun getJacobContestLines() = buildList { + val jacobsContestLine = getSbLines().firstOrNull { SbPattern.jacobsContestPattern.matches(it) } + + jacobsContestLine?.let { + addIfNotNull(it) + addIfNotNull(getSbLines().nextAfter(it)) + addIfNotNull(getSbLines().nextAfter(it, 2)) + addIfNotNull(getSbLines().nextAfter(it, 3)) + } +} + +private fun getJacobContestShowWhen(): Boolean { + return sidebarCropPattern.anyMatches(getSbLines()) +} + +private fun getJacobMedalsLines(): List<String> { + return getSbLines().filter { SbPattern.medalsPattern.matches(it) } +} + +private fun getJacobMedalsShowWhen(): Boolean { + return SbPattern.medalsPattern.anyMatches(getSbLines()) +} + +private fun getTrapperLines() = buildList { + addIfNotNull(getSbLines().firstOrNull { SbPattern.peltsPattern.matches(it) }) + + val trapperMobLocationLine = getSbLines().firstOrNull { SbPattern.mobLocationPattern.matches(it) } + if (trapperMobLocationLine != null) { + add("Tracker Mob Location:") + addIfNotNull(getSbLines().nextAfter(trapperMobLocationLine)) + } +} + +private fun getTrapperShowWhen(): Boolean { + return getSbLines().any { + ScoreboardPattern.peltsPattern.matches(it) || ScoreboardPattern.mobLocationPattern.matches(it) + } +} + +private fun getGardenCleanUpLines(): List<String> { + return listOf(getSbLines().first { SbPattern.cleanUpPattern.matches(it) }.trim()) +} + +private fun getGardenCleanUpShowWhen(): Boolean { + return SbPattern.cleanUpPattern.anyMatches(getSbLines()) +} + +private fun getGardenPastingLines(): List<String> { + return listOf(getSbLines().first { SbPattern.pastingPattern.matches(it) }.trim()) +} + +private fun getGardenPastingShowWhen(): Boolean { + return SbPattern.pastingPattern.anyMatches(getSbLines()) +} + +private fun getFlightDurationLines(): List<String> { + return listOf(getSbLines().first { SbPattern.flightDurationPattern.matches(it) }.trim()) +} + +private fun getFlightDurationShowWhen(): Boolean { + return SbPattern.flightDurationPattern.anyMatches(getSbLines()) +} + +private fun getWinterLines() = buildList { + addIfNotNull(getSbLines().firstOrNull { SbPattern.winterEventStartPattern.matches(it) }) + addIfNotNull(getSbLines().firstOrNull { SbPattern.winterNextWavePattern.matches(it) && !it.endsWith("Soon!") }) + addIfNotNull(getSbLines().firstOrNull { SbPattern.winterWavePattern.matches(it) }) + addIfNotNull(getSbLines().firstOrNull { SbPattern.winterMagmaLeftPattern.matches(it) }) + addIfNotNull(getSbLines().firstOrNull { SbPattern.winterTotalDmgPattern.matches(it) }) + addIfNotNull(getSbLines().firstOrNull { SbPattern.winterCubeDmgPattern.matches(it) }) +} + +private fun getWinterShowWhen(): Boolean { + return getSbLines().any { + ScoreboardPattern.winterEventStartPattern.matches(it) + || (ScoreboardPattern.winterNextWavePattern.matches(it) && !it.endsWith("Soon!")) + || ScoreboardPattern.winterWavePattern.matches(it) + } +} + +private fun getSpookyLines() = buildList { + addIfNotNull(getSbLines().firstOrNull { SbPattern.spookyPattern.matches(it) }) // Time + addIfNotNull("§7Your Candy: ") + addIfNotNull( + CustomScoreboardUtils.getTablistFooter() + .split("\n") + .firstOrNull { it.startsWith("§7Your Candy:") } + ?.removePrefix("§7Your Candy:") ?: "§cCandy not found" + ) // Candy +} + +private fun getSpookyShowWhen(): Boolean { + return getSbLines().any { ScoreboardPattern.spookyPattern.matches(it) } +} + +private fun getActiveEventLine(): List<String> { + val currentActiveEvent = TabListData.getTabList().firstOrNull { SbPattern.eventNamePattern.matches(it) } + ?.let { + SbPattern.eventNamePattern.matchMatcher(it) { + group("name") + } + } + val currentActiveEventEndsIn = TabListData.getTabList().firstOrNull { SbPattern.eventTimeEndsPattern.matches(it) } + ?.let { + SbPattern.eventTimeEndsPattern.matchMatcher(it) { + group("time") + } + } + + return listOf("$currentActiveEvent $currentActiveEventEndsIn") +} + +private fun getActiveEventShowWhen(): Boolean { + return TabListData.getTabList().any { SbPattern.eventNamePattern.matches(it) } && + TabListData.getTabList().any { SbPattern.eventTimeEndsPattern.matches(it) } +} + +private fun getBroodmotherLines(): List<String> { + return listOf(getSbLines().first { SbPattern.broodmotherPattern.matches(it) }) +} + +private fun getBroodmotherShowWhen(): Boolean { + return getSbLines().any { SbPattern.broodmotherPattern.matches(it) } +} + +private fun getNewYearLines(): List<String> { + return listOf(getSbLines().first { SbPattern.newYearPattern.matches(it) }) +} + +private fun getNewYearShowWhen(): Boolean { + return getSbLines().any { SbPattern.newYearPattern.matches(it) } +} + +private fun getOringoLines(): List<String> { + return listOf(getSbLines().first { SbPattern.travelingZooPattern.matches(it) }) +} + +private fun getOringoShowWhen(): Boolean { + return getSbLines().any { SbPattern.travelingZooPattern.matches(it) } +} + +private fun getMiningEventsLines() = buildList { + // Wind + if (getSbLines().any { SbPattern.windCompassPattern.matches(it) } + && getSbLines().any { SbPattern.windCompassArrowPattern.matches(it) }) { + add(getSbLines().first { SbPattern.windCompassPattern.matches(it) }) + add("| ${getSbLines().first { SbPattern.windCompassArrowPattern.matches(it) }} §f|") + } + + // Better Together + if (getSbLines().any { SbPattern.nearbyPlayersPattern.matches(it) }) { + add("§dBetter Together") + add(" ${getSbLines().first { SbPattern.nearbyPlayersPattern.matches(it) }}") + } + + // Zone Events + if (getSbLines().any { SbPattern.miningEventPattern.matches(it) } + && getSbLines().any { SbPattern.miningEventZonePattern.matches(it) }) { + add(getSbLines().first { SbPattern.miningEventPattern.matches(it) }.removePrefix("Event: ")) + add("in ${getSbLines().first { SbPattern.miningEventZonePattern.matches(it) }.removePrefix("Zone: ")}") + } + + // Zone Events but no Zone Line + if (getSbLines().any { SbPattern.miningEventPattern.matches(it) } + && getSbLines().none { SbPattern.miningEventZonePattern.matches(it) }) { + add(getSbLines().first { SbPattern.miningEventPattern.matches(it) } + .removePrefix("Event: ")) + } + + // Mithril Gourmand + if (getSbLines().any { SbPattern.mithrilRemainingPattern.matches(it) } + && getSbLines().any { SbPattern.mithrilYourMithrilPattern.matches(it) }) { + add(getSbLines().first { SbPattern.mithrilRemainingPattern.matches(it) }) + add(getSbLines().first { SbPattern.mithrilYourMithrilPattern.matches(it) }) + } + + // Raffle + if (getSbLines().any { SbPattern.raffleTicketsPattern.matches(it) } + && getSbLines().any { SbPattern.rafflePoolPattern.matches(it) }) { + add(getSbLines().first { SbPattern.raffleTicketsPattern.matches(it) }) + add(getSbLines().first { SbPattern.rafflePoolPattern.matches(it) }) + } + + // Raid + if (getSbLines().any { SbPattern.yourGoblinKillsPattern.matches(it) } + && getSbLines().any { SbPattern.remainingGoblinPattern.matches(it) }) { + add(getSbLines().first { SbPattern.yourGoblinKillsPattern.matches(it) }) + add(getSbLines().first { SbPattern.remainingGoblinPattern.matches(it) }) + } +} + +private fun getMiningEventsShowWhen(): Boolean { + return inAdvancedMiningIsland() +} + +private fun getDamageLines(): List<String> { + return listOf(getSbLines().first { SbPattern.bossHPPattern.matches(it) }) + + (getSbLines().first { SbPattern.bossDamagePattern.matches(it) }) +} + +private fun getDamageShowWhen(): Boolean { + return getSbLines().any { SbPattern.bossHPPattern.matches(it) } + && getSbLines().any { SbPattern.bossDamagePattern.matches(it) } +} + +private fun getMagmaBossLines() = getSbLines().filter { line -> + SbPattern.magmaBossPattern.matches(line) + || SbPattern.damageSoakedPattern.matches(line) + || SbPattern.killMagmasPattern.matches(line) + || SbPattern.killMagmasDamagedSoakedBarPattern.matches(line) + || SbPattern.reformingPattern.matches(line) + || SbPattern.bossHealthPattern.matches(line) + || SbPattern.bossHealthBarPattern.matches(line) +} + +private fun getMagmaBossShowWhen(): Boolean { + return SbPattern.magmaChamberPattern.matches(HypixelData.skyBlockArea) +} + +private fun getEssenceLines(): List<String> { + return listOf(getSbLines().first { SbPattern.essencePattern.matches(it) }) +} + +private fun getEssenceShowWhen(): Boolean { + return SbPattern.essencePattern.anyMatches(getSbLines()) +} + +private fun getEffigiesLines(): List<String> { + return listOf(getSbLines().first { RiftBloodEffigies.heartsPattern.matches(it) }) +} + +private fun getEffigiesShowWhen(): Boolean { + return RiftBloodEffigies.heartsPattern.anyMatches(getSbLines()) +} + +private fun getRedstoneLines(): List<String> { + return listOf(getSbLines().first { SbPattern.redstonePattern.matches(it) }) +} + +private fun getRedstoneShowWhen(): Boolean { + return SbPattern.redstonePattern.anyMatches(getSbLines()) +} + +private fun getNoneLines(): List<String> { + return when { + config.informationFilteringConfig.hideEmptyLines -> listOf("<hidden>") + else -> listOf("§cNo Event") + } +} diff --git a/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/ScoreboardPattern.kt b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/ScoreboardPattern.kt new file mode 100644 index 000000000..45c0aa01d --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/ScoreboardPattern.kt @@ -0,0 +1,404 @@ +package at.hannibal2.skyhanni.features.gui.customscoreboard + +import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern + +object ScoreboardPattern { + val group = RepoPattern.group("features.gui.customscoreboard") + + // Stats from the scoreboard + private val scoreboardGroup = group.group("scoreboard") + + // main scoreboard + private val mainSb = scoreboardGroup.group("main") + val motesPattern by mainSb.pattern( + "motes", + "^(§.)*Motes: (§.)*(?<motes>[\\d,]+).*$" + ) + val heatPattern by mainSb.pattern( + "heat", + "^Heat: (?<heat>.*)$" + ) // this line is weird (either text or number), ill leave it as is; it even has different colors? + val copperPattern by mainSb.pattern( + "copper", + "^(§.)*Copper: (§.)*(?<copper>[\\d,]+).*$" + ) + val locationPattern by mainSb.pattern( + "location", + "^\\s*(?<location>(§7⏣|§5ф) .*)$" + ) + val lobbyCodePattern by mainSb.pattern( + "lobbycode", + "^\\s*§.((\\d{2}/\\d{2}/\\d{2})|Server closing: [\\d:]+) §8(?<code>.*)\$" + ) + val datePattern by mainSb.pattern( + "date", + "^\\s*(Late |Early )?(Spring|Summer|Autumn|Winter) \\d{1,2}(st|nd|rd|th)?.*" + ) + val timePattern by mainSb.pattern( + "time", + "^\\s*§7\\d{1,2}:\\d{2}(?:am|pm) (?<symbol>(§b☽|§e☀|§.⚡|§.☔)).*$" + ) + val footerPattern by mainSb.pattern( + "footer", + "§e(www|alpha).hypixel.net\$" + ) + val yearVotesPattern by mainSb.pattern( + "yearvotes", + "(?<yearvotes>^§6Year \\d+ Votes\$)" + ) + val votesPattern by mainSb.pattern( + "votes", + "(?<votes>§[caebd]\\|+§f\\|+ §(.+)\$)" + ) + val waitingForVotePattern by mainSb.pattern( + "waitingforvote", + "(§7Waiting for|§7your vote\\.\\.\\.)$" + ) + val northstarsPattern by mainSb.pattern( + "northstars", + "North Stars: §d(?<northstars>[\\w,]+).*$" + ) + val profileTypePattern by mainSb.pattern( + "profiletype", + "^\\s*(§7♲ §7Ironman|§a☀ §aStranded|§.Ⓑ §.Bingo).*$" + ) + + // multi use + private val multiUseSb = scoreboardGroup.group("multiuse") + val autoClosingPattern by multiUseSb.pattern( + "autoclosing", + "(§.)*Auto-closing in: §c(\\d{1,2}:)?\\d{1,2}$" + ) + val startingInPattern by multiUseSb.pattern( + "startingin", + "(§.)*Starting in: §.(\\d{1,2}:)?\\d{1,2}$" + ) + val timeElapsedPattern by multiUseSb.pattern( + "timeelapsed", + "(§.)*Time Elapsed: (§.)*(?<time>(\\w+[ydhms] ?)+)$" + ) + val instanceShutdownPattern by multiUseSb.pattern( + "instanceshutdown", + "(§.)*Instance Shutdown: (§.)*(?<time>(\\w+[ydhms] ?)+)$" + ) + val timeLeftPattern by multiUseSb.pattern( + "timeleft", + "(§.)*Time Left: (§.)*[\\w:,.]*$" + ) + + // dungeon scoreboard + private val dungeonSb = scoreboardGroup.group("dungeon") + val keysPattern by dungeonSb.pattern( + "keys", + "Keys: §.■ §.[✗✓] §.■ §a.x$" + ) + val clearedPattern by dungeonSb.pattern( + "cleared", + "(§.)*Cleared: (§.)*(?<percent>[\\w,.]+)% (§.)*\\((§.)*(?<score>[\\w,.]+)(§.)*\\)$" + ) + val soloPattern by dungeonSb.pattern( + "solo", + "§3§lSolo$" + ) + val teammatesPattern by dungeonSb.pattern( + "teammates", + "(§.)*(?<classAbbv>\\[\\w]) (§.)*(?<username>[a-zA-Z0-9_]{2,16}) ((§.)*(?<classLevel>\\[Lvl?(?<level>[\\w,.]+)?]?)|(§.)*(?<health>[\\w,.]+)(§.)*.?)$" + ) + val floor3GuardiansPattern by dungeonSb.pattern( + "floor3guardians", + "^§. - §.(Healthy|Reinforced|Laser|Chaos)§a ([\\w,.]?)+§c❤$" + ) + + // kuudra + private val kuudraSb = scoreboardGroup.group("kuudra") + val wavePattern by kuudraSb.pattern( + "wave", + "^(§.)*Wave: (§.)*\\d+(§.)*( §.- §.\\d+:\\d+)?$" + ) + val tokensPattern by kuudraSb.pattern( + "tokens", + "^(§.)*Tokens: §.[\\w,]+$" + ) + val submergesPattern by kuudraSb.pattern( + "submerges", + "^(§.)*Submerges In: (§.)*[\\w,?:]+$" + ) + + // farming + private val farmingSb = scoreboardGroup.group("farming") + val medalsPattern by farmingSb.pattern( + "medals", + "§[6fc]§l(GOLD|SILVER|BRONZE) §fmedals: §[6fc]\\d+$" + ) + val lockedPattern by farmingSb.pattern( + "locked", + "^\\s*§cLocked$" + ) + val cleanUpPattern by farmingSb.pattern( + "cleanup", + "^\\s*(§.)*Cleanup(§.)*: (§.)*[\\d,.]+%$" + ) + val pastingPattern by farmingSb.pattern( + "pasting", + "^\\s*§f(Barn )?Pasting§7: (§.)*[\\d,]+%$" + ) + val peltsPattern by farmingSb.pattern( + "pelts", + "^(§.)*Pelts: (§.)*(?<pelts>[\\d,]+)( (§.)*\\([+-](?<diff>[\\w,.]+)\\))?\$" + ) + val mobLocationPattern by farmingSb.pattern( + "moblocation", + "^(§.)*Tracker Mob Location:" + ) + val jacobsContestPattern by farmingSb.pattern( + "jacobscontest", + "^§eJacob's Contest$" + ) + val plotPattern by farmingSb.pattern( + "plot", + "\\s*§aPlot §7-.*" + ) + + // mining + private val miningSb = scoreboardGroup.group("mining") + val powderPattern by miningSb.pattern( + "powder", + "(§.)*᠅ §f(Gemstone|Mithril)( Powder)?(§.)*:?.*$" + ) + val windCompassPattern by miningSb.pattern( + "windcompass", + "§9Wind Compass$" + ) + val windCompassArrowPattern by miningSb.pattern( + "windcompassarrow", + "( )*((§[a-zA-Z0-9]|[⋖⋗≈])+)( )*((§[a-zA-Z0-9]|[⋖⋗≈])+)?( )*" + ) + val miningEventPattern by miningSb.pattern( + "miningevent", + "^Event: §.§L.*$" + ) + val miningEventZonePattern by miningSb.pattern( + "miningeventzone", + "^Zone: §.*$" + ) + val raffleUselessPattern by miningSb.pattern( + "raffleuseless", + "^(Find tickets on the|ground and bring them|to the raffle box)$" + ) + val raffleTicketsPattern by miningSb.pattern( + "raffletickets", + "^Tickets: §a\\d+ §7\\(\\d{1,3}\\.\\d%\\)$" + ) + val rafflePoolPattern by miningSb.pattern( + "rafflepool", + "^Pool: §6\\d+§8/500$" + ) + val mithrilUselessPattern by miningSb.pattern( + "mithriluseless", + "^§7Give Tasty Mithril to Don!$" + ) + val mithrilRemainingPattern by miningSb.pattern( + "mithrilremaining", + "^Remaining: §a(\\d+ Tasty Mithril|FULL)$" + ) + val mithrilYourMithrilPattern by miningSb.pattern( + "mithrilyourmithril", + "^Your Tasty Mithril: §c\\d+.*$" + ) + val nearbyPlayersPattern by miningSb.pattern( + "nearbyplayers", + "^Nearby Players: §.(\\d+|N/A)$" + ) + val uselessGoblinPattern by miningSb.pattern( + "uselessgoblin", + "^§7Kill goblins!$" + ) + val remainingGoblinPattern by miningSb.pattern( + "remaininggoblin", "^Remaining: §a\\d+ goblins$" + ) + val yourGoblinKillsPattern by miningSb.pattern( + "yourgoblin", "^Your kills: §c\\d+ ☠( §a\\(\\+\\d+\\))?$" + ) + + // combat + private val combatSb = scoreboardGroup.group("combat") + val magmaChamberPattern by combatSb.pattern( + "magmachamber", + "^Magma Chamber$" + ) + val magmaBossPattern by combatSb.pattern( + "magmaboss", + "^§7Boss: §[c6e]\\d{1,3}%$" + ) + val damageSoakedPattern by combatSb.pattern( + "damagesoaked", + "^§7Damage Soaked:" + ) + val killMagmasPattern by combatSb.pattern( + "killmagmas", + "^§6Kill the Magmas:$" + ) + val killMagmasDamagedSoakedBarPattern by combatSb.pattern( + "killmagmasbar", + "^((§.)*▎+)+.*$" + ) + val reformingPattern by combatSb.pattern( + "magmareforming", + "^§cThe boss is reforming!$" + ) + val bossHealthPattern by combatSb.pattern( + "magmabosshealth", + "^§7Boss Health:$" + ) + val bossHealthBarPattern by combatSb.pattern( + "magmabosshealthbar", + "^§.(\\d{1,2}(\\.\\d)?M|\\d{1,3}k)§f/§a10M§c❤$" + ) + val broodmotherPattern by combatSb.pattern( + "broodmother", + "^§4Broodmother§7: §[e64](Slain|Dormant|Soon|Awakening|Imminent|Alive!)$" + ) + val bossHPPattern by combatSb.pattern( + "bosshp", + "^(Protector|Dragon) HP: §a(,?\\d{1,3})* §c❤$" + ) + val bossDamagePattern by combatSb.pattern( + "bossdamage", + "^Your Damage: §c(,?\\d{1,3}(\\.\\d)?)*$" + ) + val slayerQuestPattern by combatSb.pattern( + "slayerquest", + "^Slayer Quest$" + ) + + // misc + private val miscSb = scoreboardGroup.group("misc") + val essencePattern by miscSb.pattern( + "essence", + "^\\s*(.*)?Essence: §.(?<essence>-?\\d+(:?,\\d{3})*(?:\\.\\d+)?)$" + ) + val brokenRedstonePattern by miscSb.pattern( + "brokenredstone", + "\\s*e: §e§b\\d{1,3}%$" + ) + val redstonePattern by miscSb.pattern( + "redstone", + "\\s*(§.)*⚡ §cRedstone: (§.)*\\d{1,3}%$" + ) + val visitingPattern by miscSb.pattern( + "visiting", + "^\\s*§a✌ §7\\(§.\\d+(§.)?/\\d+(§.)?\\)$" + ) + val flightDurationPattern by miscSb.pattern( + "flightduration", + "^\\s*Flight Duration: §a(:?\\d{1,3})*$" + ) + val dojoChallengePattern by miscSb.pattern( + "dojochallenge", + "^(§.)*Challenge: (§.)*(?<challenge>[\\w ]+)$" + ) + val dojoDifficultyPattern by miscSb.pattern( + "dojodifficulty", + "^(§.)*Difficulty: (§.)*(?<difficulty>[\\w ]+)$" + ) + val dojoPointsPattern by miscSb.pattern( + "dojopoints", + "^(§.)*Points: (§.)*(?<points>[\\w,.]+) ?( (§.)*\\((§.)*[+-](§.)*(?<difference>[\\w,.]+)(§.)*\\))?\$" + ) + val dojoTimePattern by miscSb.pattern( + "dojotime", + "^(§.)*Time: (§.)*(?<time>(?<seconds>\\w+s))( (§.)*\\((§.)*[+-](§.)*(?<difference>[\\w,.]+)(§.)*\\))?$" + ) + val objectivePattern by miscSb.pattern( + "objective", + "^(§.)*(Objective|Quest).*" + ) + // this thirdObjectiveLinePattern includes all those weird objective lines that go into a third scoreboard line + val thirdObjectiveLinePattern by miscSb.pattern( + "thirdobjectiveline", + "(\\s*§.\\(§.\\w+§./§.\\w+§.\\)|§f Mages.*|§f Barbarians.*|§edefeat Kuudra|§eand stun him)" + ) + // collection of lines that just randomly exist and I have no clue how on earth to effectively remove them + val wtfAreThoseLinesPattern by miscSb.pattern( + "wtfarethoselines", + "^§eMine 10 Rubies$" + ) + val darkAuctionCurrentItemPattern by miscSb.pattern( + "darkauction.currentitem", + "^Current Item:$" + ) + + // events + private val eventsSb = scoreboardGroup.group("events") + val travelingZooPattern by eventsSb.pattern( + "travelingzoo", + "§aTraveling Zoo§f \\d{0,2}:\\d{2}$" + ) + val newYearPattern by eventsSb.pattern( + "newyear", + "§dNew Year Event!§f \\d{0,2}?:?\\d{2}$" + ) + val spookyPattern by eventsSb.pattern( + "spooky", + "§6Spooky Festival§f \\d{0,2}?:?\\d{2}$" + ) + val winterEventStartPattern by eventsSb.pattern( + "wintereventstart", + "(§.)*Event Start: §.\\d+:\\d+$" + ) + val winterNextWavePattern by eventsSb.pattern( + "wintereventnextwave", + "(§.)*Next Wave: (§.)*(\\d+:\\d+|Soon!)$" + ) + val winterWavePattern by eventsSb.pattern( + "wintereventwave", + "(§.)*Wave \\d+$" + ) + val winterMagmaLeftPattern by eventsSb.pattern( + "wintereventmagmaleft", + "(§.)*Magma Cubes Left: §.\\d+$" + ) + val winterTotalDmgPattern by eventsSb.pattern( + "wintereventtotaldmg", + "(§.)*Your Total Damage: §.\\d+( §e\\(#\\d+\\)?)?$" + ) + val winterCubeDmgPattern by eventsSb.pattern( + "wintereventcubedmg", + "(§.)*Your Cube Damage: §.\\d+$" + ) + + // rift + private val riftSb = scoreboardGroup.group("rift") + val riftDimensionPattern by riftSb.pattern( + "dimension", + "^\\s*§fRift Dimension$" + ) + + + // Stats from the tablist + private val tablistGroup = group.group("tablist") + val gemsPattern by tablistGroup.pattern( + "gems", + "^\\s*Gems: §a(?<gems>\\d*,?(\\.\\d+)?[a-zA-Z]?)$" + ) + val bankPattern by tablistGroup.pattern( + "bank", + "^\\s*Bank: §6(?<bank>[\\w.,]+(?:§7 \\/ §6(?<coop>[\\w.,]+))?)$" + ) + val mithrilPowderPattern by tablistGroup.pattern( + "mithrilpowder", + "^\\s*Gemstone Powder: (?:§.)+(?<mithrilpowder>[\\d,\\.]+)$" + ) + val gemstonePowderPattern by tablistGroup.pattern( + "gemstonepowder", + "^\\s*Gemstone Powder: (?:§.)+(?<gemstonepowder>[\\d,\\.]+)$" + ) + val eventNamePattern by tablistGroup.pattern( + "event", + "^\\s*§e§lEvent: §r(?<name>§.*)$" + ) + val eventTimeEndsPattern by tablistGroup.pattern( + "eventtime", + "^\\s+Ends In: §r§e(?<time>.*)$" + ) +} diff --git a/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/UnknownLinesHandler.kt b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/UnknownLinesHandler.kt new file mode 100644 index 000000000..5fe788983 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/gui/customscoreboard/UnknownLinesHandler.kt @@ -0,0 +1,156 @@ +package at.hannibal2.skyhanni.features.gui.customscoreboard + +import at.hannibal2.skyhanni.data.BitsAPI +import at.hannibal2.skyhanni.data.PurseAPI +import at.hannibal2.skyhanni.data.ScoreboardData +import at.hannibal2.skyhanni.features.misc.ServerRestartTitle +import at.hannibal2.skyhanni.features.rift.area.stillgorechateau.RiftBloodEffigies +import at.hannibal2.skyhanni.utils.CollectionUtils.nextAfter +import at.hannibal2.skyhanni.utils.StringUtils.matches +import at.hannibal2.skyhanni.utils.StringUtils.removeResets +import at.hannibal2.skyhanni.features.gui.customscoreboard.ScoreboardPattern as SbPattern + +object UnknownLinesHandler { + fun handleUnknownLines() { + val sidebarLines = ScoreboardData.sidebarLinesFormatted + + unknownLines = sidebarLines.toMutableList().filter { it.isNotBlank() }.map { it.removeResets() } + + /* + * remove with pattern + */ + val patternsToExclude = listOf( + PurseAPI.coinsPattern, + SbPattern.motesPattern, + BitsAPI.bitsScoreboardPattern, + SbPattern.heatPattern, + SbPattern.copperPattern, + SbPattern.locationPattern, + SbPattern.lobbyCodePattern, + SbPattern.datePattern, + SbPattern.timePattern, + SbPattern.footerPattern, + SbPattern.yearVotesPattern, + SbPattern.votesPattern, + SbPattern.waitingForVotePattern, + SbPattern.northstarsPattern, + SbPattern.profileTypePattern, + SbPattern.autoClosingPattern, + SbPattern.startingInPattern, + SbPattern.timeElapsedPattern, + SbPattern.keysPattern, + SbPattern.clearedPattern, + SbPattern.soloPattern, + SbPattern.teammatesPattern, + SbPattern.floor3GuardiansPattern, + SbPattern.wavePattern, + SbPattern.tokensPattern, + SbPattern.submergesPattern, + SbPattern.medalsPattern, + SbPattern.lockedPattern, + SbPattern.cleanUpPattern, + SbPattern.pastingPattern, + SbPattern.peltsPattern, + SbPattern.mobLocationPattern, + SbPattern.jacobsContestPattern, + SbPattern.plotPattern, + SbPattern.powderPattern, + SbPattern.windCompassPattern, + SbPattern.windCompassArrowPattern, + SbPattern.miningEventPattern, + SbPattern.miningEventZonePattern, + SbPattern.raffleUselessPattern, + SbPattern.raffleTicketsPattern, + SbPattern.rafflePoolPattern, + SbPattern.mithrilUselessPattern, + SbPattern.mithrilRemainingPattern, + SbPattern.mithrilYourMithrilPattern, + SbPattern.nearbyPlayersPattern, + SbPattern.uselessGoblinPattern, + SbPattern.remainingGoblinPattern, + SbPattern.yourGoblinKillsPattern, + SbPattern.magmaBossPattern, + SbPattern.damageSoakedPattern, + SbPattern.killMagmasPattern, + SbPattern.killMagmasDamagedSoakedBarPattern, + SbPattern.reformingPattern, + SbPattern.bossHealthPattern, + SbPattern.bossHealthBarPattern, + SbPattern.broodmotherPattern, + SbPattern.bossHPPattern, + SbPattern.bossDamagePattern, + SbPattern.slayerQuestPattern, + SbPattern.essencePattern, + SbPattern.brokenRedstonePattern, + SbPattern.redstonePattern, + SbPattern.visitingPattern, + SbPattern.flightDurationPattern, + SbPattern.dojoChallengePattern, + SbPattern.dojoDifficultyPattern, + SbPattern.dojoPointsPattern, + SbPattern.dojoTimePattern, + SbPattern.objectivePattern, + ServerRestartTitle.restartingGreedyPattern, + SbPattern.travelingZooPattern, + SbPattern.newYearPattern, + SbPattern.spookyPattern, + SbPattern.winterEventStartPattern, + SbPattern.winterNextWavePattern, + SbPattern.winterWavePattern, + SbPattern.winterMagmaLeftPattern, + SbPattern.winterTotalDmgPattern, + SbPattern.winterCubeDmgPattern, + SbPattern.riftDimensionPattern, + RiftBloodEffigies.heartsPattern, + SbPattern.wtfAreThoseLinesPattern, + SbPattern.timeLeftPattern, + SbPattern.darkAuctionCurrentItemPattern, + ) + + unknownLines = unknownLines.filterNot { line -> + patternsToExclude.any { pattern -> pattern.matches(line) } + } + + + /* + * remove known text + */ + // remove objectives + val objectiveLine = + sidebarLines.firstOrNull { SbPattern.objectivePattern.matches(it) } + ?: "Objective" + unknownLines = unknownLines.filter { sidebarLines.nextAfter(objectiveLine) != it } + unknownLines = unknownLines.filter { + sidebarLines.nextAfter(objectiveLine, 2) != it + && !SbPattern.thirdObjectiveLinePattern.matches(it) + } + + // Remove jacobs contest + for (i in 1..3) + unknownLines = unknownLines.filter { + sidebarLines.nextAfter(sidebarLines.firstOrNull { line -> + SbPattern.jacobsContestPattern.matches(line) + } ?: "§eJacob's Contest", i) != it + } + + // Remove slayer + for (i in 1..2) + unknownLines = unknownLines.filter { + sidebarLines.nextAfter(sidebarLines.firstOrNull { line -> + SbPattern.slayerQuestPattern.matches(line) + } ?: "Slayer Quest", i) != it + } + + // remove trapper mob location + unknownLines = unknownLines.filter { + sidebarLines.nextAfter(sidebarLines.firstOrNull { line -> + SbPattern.mobLocationPattern.matches(line) + } ?: "Tracker Mob Location:") != it + } + + // da + unknownLines = unknownLines.filter { sidebarLines.nextAfter(sidebarLines.firstOrNull { line -> + SbPattern.darkAuctionCurrentItemPattern.matches(line) + } ?: "Current Item:") != it } + } +} diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/MaxPurseItems.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/MaxPurseItems.kt index d835fc5a8..53b74c7f7 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/MaxPurseItems.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/MaxPurseItems.kt @@ -45,7 +45,7 @@ class MaxPurseItems { for (info in item.getLore()) { orderPattern.matchMatcher(info) { // +0.1 because I expect people to use the gold nugget option - buyOrderPrice = group("coins").formatDouble()?.let { it + 0.1 } ?: 0.0 + buyOrderPrice = group("coins").formatDouble() + 0.1 // If we get to this point, we have the instant price because instant is earlier in the list of items // So we can return return @@ -55,7 +55,7 @@ class MaxPurseItems { createInstantPattern.matchMatcher(name) { for (info in item.getLore()) { instantPattern.matchMatcher(info) { - instantBuyPrice = group("coins").formatDouble() ?: 0.0 + instantBuyPrice = group("coins").formatDouble() } } } diff --git a/src/main/java/at/hannibal2/skyhanni/features/minion/MinionXp.kt b/src/main/java/at/hannibal2/skyhanni/features/minion/MinionXp.kt index ff27bd43f..2f1c14f53 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/minion/MinionXp.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/minion/MinionXp.kt @@ -1,7 +1,7 @@ package at.hannibal2.skyhanni.features.minion import at.hannibal2.skyhanni.SkyHanniMod -import at.hannibal2.skyhanni.data.MayorElection +import at.hannibal2.skyhanni.data.Perk import at.hannibal2.skyhanni.data.jsonobjects.repo.MinionXPJson import at.hannibal2.skyhanni.events.IslandChangeEvent import at.hannibal2.skyhanni.events.LorenzToolTipEvent @@ -103,7 +103,7 @@ class MinionXp { // TODO add wisdom and temporary skill exp (Events) to calculation val baseXp = xp.amount * item.amount - val xpAmount = if (MayorElection.isPerkActive("Derpy", "MOAR SKILLZ!!!")) { + val xpAmount = if (Perk.MOAR_SKILLZ.isActive) { baseXp * 1.5 } else baseXp diff --git a/src/main/java/at/hannibal2/skyhanni/features/misc/ServerRestartTitle.kt b/src/main/java/at/hannibal2/skyhanni/features/misc/ServerRestartTitle.kt index 34196acbe..a236daf4e 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/misc/ServerRestartTitle.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/misc/ServerRestartTitle.kt @@ -16,10 +16,17 @@ class ServerRestartTitle { private val config get() = SkyHanniMod.feature.misc - private val restartPattern by RepoPattern.pattern( - "misc.serverrestart.restart", - "§cServer closing: (?<minutes>\\d+):(?<seconds>\\d+) §8.*" - ) + companion object { + private val restartingGroup = RepoPattern.group("features.misc.serverrestart") + private val restartingPattern by restartingGroup.pattern( + "time", + "§cServer closing: (?<minutes>\\d+):(?<seconds>\\d+) ?§8.*" + ) + val restartingGreedyPattern by restartingGroup.pattern( + "greedy", + "§cServer closing:.*" + ) + } @SubscribeEvent fun onTick(event: LorenzTickEvent) { @@ -29,7 +36,7 @@ class ServerRestartTitle { if (!event.repeatSeconds(1)) return for (line in ScoreboardData.sidebarLinesFormatted) { - restartPattern.matchMatcher(line) { + restartingPattern.matchMatcher(line) { try { val minutes = group("minutes").toInt().minutes val seconds = group("seconds").toInt().seconds @@ -39,9 +46,9 @@ class ServerRestartTitle { LorenzUtils.sendTitle("§cServer Restart in §b$time", 2.seconds) } catch (e: Throwable) { ErrorManager.logErrorWithData( - e, "Error reading server restart time from socreboard", + e, "Error reading server restart time from scoreboard", "line" to line, - "restartPattern" to restartPattern.pattern(), + "restartPattern" to restartingPattern.pattern(), ) } } diff --git a/src/main/java/at/hannibal2/skyhanni/features/misc/compacttablist/TabListReader.kt b/src/main/java/at/hannibal2/skyhanni/features/misc/compacttablist/TabListReader.kt index 07473f9d9..bba2ff6aa 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/misc/compacttablist/TabListReader.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/misc/compacttablist/TabListReader.kt @@ -2,14 +2,12 @@ package at.hannibal2.skyhanni.features.misc.compacttablist import at.hannibal2.skyhanni.SkyHanniMod import at.hannibal2.skyhanni.events.LorenzTickEvent -import at.hannibal2.skyhanni.mixins.transformers.AccessorGuiPlayerTabOverlay import at.hannibal2.skyhanni.utils.LorenzUtils import at.hannibal2.skyhanni.utils.StringUtils.removeResets import at.hannibal2.skyhanni.utils.StringUtils.removeSFormattingCode import at.hannibal2.skyhanni.utils.StringUtils.trimWhiteSpaceAndResets import at.hannibal2.skyhanni.utils.TabListData import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern -import net.minecraft.client.Minecraft import net.minecraftforge.fml.common.eventhandler.SubscribeEvent // heavily inspired by SBA code @@ -99,7 +97,7 @@ object TabListReader { } private fun parseFooterAsColumn(): TabColumn? { - val tabList = Minecraft.getMinecraft().ingameGUI.tabList as AccessorGuiPlayerTabOverlay + val tabList = TabListData.getPlayerTabOverlay() if (tabList.footer_skyhanni == null) { return null diff --git a/src/main/java/at/hannibal2/skyhanni/features/misc/compacttablist/TabListRenderer.kt b/src/main/java/at/hannibal2/skyhanni/features/misc/compacttablist/TabListRenderer.kt index c6aa9a510..6f2d5d636 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/misc/compacttablist/TabListRenderer.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/misc/compacttablist/TabListRenderer.kt @@ -3,11 +3,11 @@ package at.hannibal2.skyhanni.features.misc.compacttablist import at.hannibal2.skyhanni.SkyHanniMod import at.hannibal2.skyhanni.events.GuiRenderEvent import at.hannibal2.skyhanni.events.SkipTabListLineEvent -import at.hannibal2.skyhanni.mixins.transformers.AccessorGuiPlayerTabOverlay import at.hannibal2.skyhanni.utils.CollectionUtils.filterToMutable import at.hannibal2.skyhanni.utils.KeyboardManager.isActive import at.hannibal2.skyhanni.utils.LorenzUtils import at.hannibal2.skyhanni.utils.StringUtils.matches +import at.hannibal2.skyhanni.utils.TabListData.Companion.getPlayerTabOverlay import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern import net.minecraft.client.Minecraft import net.minecraft.client.gui.Gui @@ -78,7 +78,7 @@ object TabListRenderer { } var totalHeight = maxLines * lineHeight - val tabList = Minecraft.getMinecraft().ingameGUI.tabList as AccessorGuiPlayerTabOverlay + val tabList = getPlayerTabOverlay() var header = listOf<String>() if (tabList.header_skyhanni != null) { diff --git a/src/main/java/at/hannibal2/skyhanni/features/rift/area/stillgorechateau/RiftBloodEffigies.kt b/src/main/java/at/hannibal2/skyhanni/features/rift/area/stillgorechateau/RiftBloodEffigies.kt index cd18de35a..be05e11fb 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/rift/area/stillgorechateau/RiftBloodEffigies.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/rift/area/stillgorechateau/RiftBloodEffigies.kt @@ -28,15 +28,6 @@ class RiftBloodEffigies { private val config get() = RiftAPI.config.area.stillgoreChateau.bloodEffigies - private val patternGroup = RepoPattern.group("rift.area.stillgore.effegies") - private val effigiesTimerPattern by patternGroup.pattern( - "respawn", - "§eRespawn §c(?<time>.*) §7\\(or click!\\)" - ) - private val effegieHeartPattern by patternGroup.pattern( - "heart", - "Effigies: (?<hearts>.*)" - ) private var locations: List<LorenzVec> = emptyList() private var effigiesTimes = mapOf( @@ -48,6 +39,18 @@ class RiftBloodEffigies { 5 to -1L, ) + companion object { + private val group = RepoPattern.group("rift.area.stillgore.effegies") + val effigiesTimerPattern by group.pattern( + "respawn", + "§eRespawn §c(?<time>.*) §7\\(or click!\\)" + ) + val heartsPattern by group.pattern( + "heart", + "Effigies: (?<hearts>((§[7c])?⧯)*)" + ) + } + @SubscribeEvent fun onWorldChange(event: LorenzWorldChangeEvent) { effigiesTimes = mapOf( @@ -74,7 +77,7 @@ class RiftBloodEffigies { if (!isEnabled()) return val line = event.newList.firstOrNull { it.startsWith("Effigies:") } ?: return - val hearts = effegieHeartPattern.matchMatcher(line) { + val hearts = heartsPattern.matchMatcher(line) { group("hearts") } ?: return diff --git a/src/main/java/at/hannibal2/skyhanni/mixins/hooks/GuiIngameHook.kt b/src/main/java/at/hannibal2/skyhanni/mixins/hooks/GuiIngameHook.kt index 9d1e7ab87..0bf44d0a0 100644 --- a/src/main/java/at/hannibal2/skyhanni/mixins/hooks/GuiIngameHook.kt +++ b/src/main/java/at/hannibal2/skyhanni/mixins/hooks/GuiIngameHook.kt @@ -15,11 +15,16 @@ fun drawString( x: Int, y: Int, color: Int, -) = replaceString(text)?.let { +) = tryToReplaceScoreboardLine(text)?.let { instance.drawString(it, x, y, color) } ?: 0 -private fun replaceString(text: String): String? { +/** + * Tries to replace a scoreboard line with a modified one + * @param text The line to check and possibly replace + * @return The replaced line, or null if it should be hidden + */ +fun tryToReplaceScoreboardLine(text: String): String? { if (SkyHanniMod.feature.misc.hideScoreboardNumbers && text.startsWith("§c") && text.length <= 4) { return null } diff --git a/src/main/java/at/hannibal2/skyhanni/test/DebugCommand.kt b/src/main/java/at/hannibal2/skyhanni/test/DebugCommand.kt index 3ffe8f8e6..4a379fed6 100644 --- a/src/main/java/at/hannibal2/skyhanni/test/DebugCommand.kt +++ b/src/main/java/at/hannibal2/skyhanni/test/DebugCommand.kt @@ -58,7 +58,7 @@ object DebugCommand { private fun profileType(event: DebugDataCollectEvent) { event.title("Profile Type") if (!LorenzUtils.inSkyBlock) { - event.addIrrelevant("Not on SkyBlcok") + event.addIrrelevant("Not on SkyBlock") return } @@ -81,7 +81,7 @@ object DebugCommand { private fun profileName(event: DebugDataCollectEvent) { event.title("Profile Name") if (!LorenzUtils.inSkyBlock) { - event.addIrrelevant("Not on SkyBlcok") + event.addIrrelevant("Not on SkyBlock") return } diff --git a/src/main/java/at/hannibal2/skyhanni/test/SkyHanniDebugsAndTests.kt b/src/main/java/at/hannibal2/skyhanni/test/SkyHanniDebugsAndTests.kt index b2b6bccb3..cd5d9bf0b 100644 --- a/src/main/java/at/hannibal2/skyhanni/test/SkyHanniDebugsAndTests.kt +++ b/src/main/java/at/hannibal2/skyhanni/test/SkyHanniDebugsAndTests.kt @@ -129,7 +129,7 @@ class SkyHanniDebugsAndTests { // b = args[1].toDouble() // c = args[2].toDouble() -// for (line in (Minecraft.getMinecraft().ingameGUI.tabList as AccessorGuiPlayerTabOverlay).footer.unformattedText +// for (line in getPlayerTabOverlay().footer.unformattedText // .split("\n")) { // println("footer: '$line'") // } diff --git a/src/main/java/at/hannibal2/skyhanni/test/command/ErrorManager.kt b/src/main/java/at/hannibal2/skyhanni/test/command/ErrorManager.kt index 4c0a3cf27..16757d255 100644 --- a/src/main/java/at/hannibal2/skyhanni/test/command/ErrorManager.kt +++ b/src/main/java/at/hannibal2/skyhanni/test/command/ErrorManager.kt @@ -101,8 +101,9 @@ object ErrorManager { message: String, vararg extraData: Pair<String, Any?>, ignoreErrorCache: Boolean = false, + noStackTrace: Boolean = false, ) { - logError(throwable, message, ignoreErrorCache, noStackTrace = false, *extraData) + logError(throwable, message, ignoreErrorCache, noStackTrace, *extraData) } private fun logError( diff --git a/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt b/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt index b93f17fa4..21f731fc2 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt @@ -51,6 +51,9 @@ object CollectionUtils { fun <K> MutableMap<K, Double>.addOrPut(key: K, number: Double): Double = this.merge(key, number, Double::plus)!! // Never returns null since "plus" can't return null + fun <K> MutableMap<K, Float>.addOrPut(key: K, number: Float): Float = + this.merge(key, number, Float::plus)!! // Never returns null since "plus" can't return null + fun <K, N : Number> Map<K, N>.sumAllValues(): Double { if (values.isEmpty()) return 0.0 @@ -81,6 +84,30 @@ object CollectionUtils { return null } + fun List<String>.removeNextAfter(after: String, skip: Int = 1) = removeNextAfter({ it == after }, skip) + + fun List<String>.removeNextAfter(after: (String) -> Boolean, skip: Int = 1): List<String> { + val newList = mutableListOf<String>() + var missing = -1 + for (line in this) { + if (after(line)) { + missing = skip - 1 + continue + } + if (missing == 0) { + missing-- + continue + } + if (missing != -1) { + missing-- + } + newList.add(line) + } + return newList + } + + fun List<String>.addIfNotNull(element: String?) = element?.let { plus(it) } ?: this + fun <K, V> Map<K, V>.editCopy(function: MutableMap<K, V>.() -> Unit) = toMutableMap().also { function(it) }.toMap() diff --git a/src/main/java/at/hannibal2/skyhanni/utils/LorenzUtils.kt b/src/main/java/at/hannibal2/skyhanni/utils/LorenzUtils.kt index a2788a6fa..ed0af59eb 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/LorenzUtils.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/LorenzUtils.kt @@ -3,7 +3,7 @@ package at.hannibal2.skyhanni.utils import at.hannibal2.skyhanni.SkyHanniMod import at.hannibal2.skyhanni.data.HypixelData import at.hannibal2.skyhanni.data.IslandType -import at.hannibal2.skyhanni.data.MayorElection +import at.hannibal2.skyhanni.data.Perk import at.hannibal2.skyhanni.data.TitleManager import at.hannibal2.skyhanni.events.GuiContainerEvent import at.hannibal2.skyhanni.features.dungeon.DungeonAPI @@ -270,6 +270,8 @@ object LorenzUtils { fun IslandType.isInIsland() = inSkyBlock && skyBlockIsland == this + fun inAnyIsland(vararg islandTypes: IslandType) = inSkyBlock && islandTypes.any { it.isInIsland() } + fun GuiContainerEvent.SlotClickEvent.makeShiftClick() { if (this.clickedButton == 1 && slot?.stack?.getItemCategoryOrNull() == ItemCategory.SACK) return slot?.slotNumber?.let { slotNumber -> @@ -281,7 +283,7 @@ object LorenzUtils { } private val recalculateDerpy = - RecalculatingValue(1.seconds) { MayorElection.isPerkActive("Derpy", "DOUBLE MOBS HP!!!") } + RecalculatingValue(1.seconds) { Perk.DOUBLE_MOBS_HP.isActive } val isDerpy get() = recalculateDerpy.getValue() diff --git a/src/main/java/at/hannibal2/skyhanni/utils/NumberUtil.kt b/src/main/java/at/hannibal2/skyhanni/utils/NumberUtil.kt index 92cbe4d57..784b7e9ac 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/NumberUtil.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/NumberUtil.kt @@ -236,20 +236,22 @@ object NumberUtil { 1_000.0 } else if (text.endsWith("m")) { text = text.substring(0, text.length - 1) - 1.milion + 1.million } else if (text.endsWith("b")) { text = text.substring(0, text.length - 1) - 1.bilion + 1.billion } else 1.0 return text.toDoubleOrNull()?.let { it * multiplier } } - val Int.milion get() = this * 1_000_000.0 - private val Int.bilion get() = this * 1_000_000_000.0 - val Double.milion get() = (this * 1_000_000.0).toLong() + // Sometimes we just take an L, never find it and forget to write it down + val Int.million get() = this * 1_000_000.0 + private val Int.billion get() = this * 1_000_000_000.0 + val Double.million get() = (this * 1_000_000.0).toLong() + /** @return clamped to [0.0, 1.0]**/ fun Number.fractionOf(maxValue: Number) = maxValue.toDouble().takeIf { it != 0.0 }?.let { max -> this.toDouble() / max diff --git a/src/main/java/at/hannibal2/skyhanni/utils/RenderUtils.kt b/src/main/java/at/hannibal2/skyhanni/utils/RenderUtils.kt index 32ea32329..d40f98667 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/RenderUtils.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/RenderUtils.kt @@ -4,6 +4,7 @@ import at.hannibal2.skyhanni.config.core.config.Position import at.hannibal2.skyhanni.data.GuiEditManager import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getAbsX import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getAbsY +import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getDummySize import at.hannibal2.skyhanni.events.GuiRenderItemEvent import at.hannibal2.skyhanni.events.LorenzRenderWorldEvent import at.hannibal2.skyhanni.features.misc.RoundedRectangleShader @@ -37,7 +38,16 @@ import kotlin.time.DurationUnit object RenderUtils { - enum class HorizontalAlignment { LEFT, CENTER, RIGHT } + enum class HorizontalAlignment(private val value: String) { + LEFT("Left"), + CENTER("Center"), + RIGHT("Right"), + ; + + override fun toString(): String { + return value + } + } enum class VerticalAlignment { TOP, CENTER, BOTTOM } private val beaconBeam = ResourceLocation("textures/entity/beacon_beam.png") @@ -401,6 +411,36 @@ object RenderUtils { return renderer.getStringWidth(display) } + // Aligns using the width of element to render + private fun Position.renderString0( + string: String?, + offsetX: Int = 0, + offsetY: Int = 0, + alignmentEnum: HorizontalAlignment + ): Int { + val display = "§f$string" + GlStateManager.pushMatrix() + transform() + val minecraft = Minecraft.getMinecraft() + val renderer = minecraft.renderManager.fontRenderer + val width = this.getDummySize().x / this.scale + + GlStateManager.translate(offsetX + 1.0, offsetY + 1.0, 0.0) + + val strLen: Int = renderer.getStringWidth(string) + val x2 = when (alignmentEnum) { + HorizontalAlignment.LEFT -> offsetX.toFloat() + HorizontalAlignment.CENTER -> offsetX + width / 2f - strLen / 2f + HorizontalAlignment.RIGHT -> offsetX + width - strLen.toFloat() + } + GL11.glTranslatef(x2, 0f, 0f) + renderer.drawStringWithShadow(display, 0f, 0f, 0) + + GlStateManager.popMatrix() + + return renderer.getStringWidth(display) + } + fun Position.renderStrings(list: List<String>, extraSpace: Int = 0, posLabel: String) { if (list.isEmpty()) return @@ -416,6 +456,25 @@ object RenderUtils { GuiEditManager.add(this, posLabel, longestX, offsetY) } + fun Position.renderStringsAlignedWidth( + list: List<Pair<String, HorizontalAlignment>>, + extraSpace: Int = 0, + posLabel: String + ) { + if (list.isEmpty()) return + + var offsetY = 0 + var longestX = 0 + for (pair in list) { + val x = renderString0(pair.first, offsetY = offsetY, alignmentEnum = pair.second) + if (x > longestX) { + longestX = x + } + offsetY += 10 + extraSpace + } + GuiEditManager.add(this, posLabel, longestX, offsetY) + } + fun Position.renderRenderables( renderables: List<Renderable>, extraSpace: Int = 0, diff --git a/src/main/java/at/hannibal2/skyhanni/utils/SimpleTimeMark.kt b/src/main/java/at/hannibal2/skyhanni/utils/SimpleTimeMark.kt index 784eb85ec..d6df48a67 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/SimpleTimeMark.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/SimpleTimeMark.kt @@ -35,6 +35,8 @@ value class SimpleTimeMark(private val millis: Long) : Comparable<SimpleTimeMark fun toSkyBlockTime() = SkyBlockTime.fromInstant(Instant.ofEpochMilli(millis)) + fun elapsedMinutes() = passedSince().inWholeMinutes + companion object { fun now() = SimpleTimeMark(System.currentTimeMillis()) diff --git a/src/main/java/at/hannibal2/skyhanni/utils/TabListData.kt b/src/main/java/at/hannibal2/skyhanni/utils/TabListData.kt index 4fd442c09..a96a31789 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/TabListData.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/TabListData.kt @@ -24,6 +24,7 @@ class TabListData { private var cache = emptyList<String>() private var debugCache: List<String>? = null + var fullyLoaded = false // TODO replace with TabListUpdateEvent fun getTabList() = debugCache ?: cache @@ -53,7 +54,7 @@ class TabListData { val tabListLine = line.transformIf({ noColor }) { removeColor() } if (tabListLine != "") resultList.add("'$tabListLine'") } - val tabList = Minecraft.getMinecraft().ingameGUI.tabList as AccessorGuiPlayerTabOverlay + val tabList = getPlayerTabOverlay() val tabHeader = tabList.header_skyhanni.conditionalTransform(noColor, { unformattedText }, { formattedText }) val tabFooter = @@ -62,6 +63,10 @@ class TabListData { OSUtils.copyToClipboard(string) ChatUtils.chat("Tab list copied into the clipboard!") } + + fun getPlayerTabOverlay(): AccessorGuiPlayerTabOverlay { + return Minecraft.getMinecraft().ingameGUI.tabList as AccessorGuiPlayerTabOverlay + } } private val playerOrdering = Ordering.from(PlayerComparator()) diff --git a/src/main/java/at/hannibal2/skyhanni/utils/TimeUtils.kt b/src/main/java/at/hannibal2/skyhanni/utils/TimeUtils.kt index d2b269e9a..58bdb2d77 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/TimeUtils.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/TimeUtils.kt @@ -1,5 +1,6 @@ package at.hannibal2.skyhanni.utils +import at.hannibal2.skyhanni.mixins.hooks.tryToReplaceScoreboardLine import at.hannibal2.skyhanni.utils.NumberUtil.addSeparators import at.hannibal2.skyhanni.utils.StringUtils.matchMatcher import io.github.moulberry.notenoughupdates.util.SkyBlockTime @@ -129,19 +130,36 @@ object TimeUtils { }.toLong().toDuration(DurationUnit.MILLISECONDS) } - fun SkyBlockTime.formatted(): String { + fun SkyBlockTime.formatted( + dayAndMonthElement: Boolean = true, + yearElement: Boolean = true, + hoursAndMinutesElement: Boolean = true + ): String { val hour = if (this.hour > 12) this.hour - 12 else this.hour - val timeOfDay = if (this.hour > 11) "pm" else "am" // hooray for 12-hour clocks - var minute = this.minute.toString() - if (minute.length != 2) { - minute = minute.padStart(2, '0') - } - + val timeOfDay = if (this.hour > 11) "pm" else "am" + val minute = this.minute.toString().padStart(2, '0') val month = SkyBlockTime.monthName(this.month) val day = this.day val daySuffix = SkyBlockTime.daySuffix(day) val year = this.year - return "$month $day$daySuffix, Year $year $hour:${minute}$timeOfDay" // Early Winter 1st Year 300, 12:03pm + + val datePart = when { + yearElement -> "$month $day$daySuffix, Year $year" + dayAndMonthElement -> "$month $day$daySuffix" + else -> "" + } + val timePart = if (hoursAndMinutesElement) "$hour:$minute$timeOfDay" else "" + + /** + * We replace the line here, because the user might want color month names + */ + return tryToReplaceScoreboardLine( + if (datePart.isNotEmpty() && timePart.isNotEmpty()) { + "$datePart, $timePart" + } else { + "$datePart$timePart".trim() + } + ) ?: "" } fun getCurrentLocalDate(): LocalDate = LocalDate.now(ZoneId.of("UTC")) diff --git a/src/main/java/at/hannibal2/skyhanni/utils/shader/ShaderManager.kt b/src/main/java/at/hannibal2/skyhanni/utils/shader/ShaderManager.kt index 9398d0e53..3c6bc5ce0 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/shader/ShaderManager.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/shader/ShaderManager.kt @@ -19,13 +19,13 @@ object ShaderManager { /** * For any future shaders add the object instance in this enum and - * in the when expression + * in the when-expression */ enum class Shaders(val shader: Shader) { - STANDARD_CHROMA(StandardChromaShader.INSTANCE), TEXTURED_CHROMA(TexturedChromaShader.INSTANCE), - ROUNDED_RECTANGLE(RoundedRectangleShader.INSTANCE); + ROUNDED_RECTANGLE(RoundedRectangleShader.INSTANCE), + ; companion object { diff --git a/src/main/resources/assets/skyhanni/scoreboard.png b/src/main/resources/assets/skyhanni/scoreboard.png Binary files differnew file mode 100644 index 000000000..acd9d8586 --- /dev/null +++ b/src/main/resources/assets/skyhanni/scoreboard.png |
