From 18deeccb78f084b41d7dbf695e97496d4ad24c6d Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Thu, 18 Jul 2024 17:05:35 -0400 Subject: [PATCH 01/15] Start of feature --- .../features/inventory/InventoryConfig.java | 6 + .../storage/ProfileSpecificStorage.java | 5 +- .../inventory/caketracker/CakeTracker.kt | 158 ++++++++++++++++++ .../caketracker/CakeTrackerConfig.java | 43 +++++ .../skyhanni/utils/HypixelCommands.kt | 4 + 5 files changed, 215 insertions(+), 1 deletion(-) create mode 100644 src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt create mode 100644 src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/inventory/InventoryConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/inventory/InventoryConfig.java index 45c0a9e98239..56538a75fcfb 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/features/inventory/InventoryConfig.java +++ b/src/main/java/at/hannibal2/skyhanni/config/features/inventory/InventoryConfig.java @@ -8,6 +8,7 @@ import at.hannibal2.skyhanni.config.features.itemability.ItemAbilityConfig; import at.hannibal2.skyhanni.config.features.misc.EstimatedItemValueConfig; import at.hannibal2.skyhanni.config.features.misc.PocketSackInASackConfig; +import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTrackerConfig; import com.google.gson.annotations.Expose; import io.github.notenoughupdates.moulconfig.annotations.Accordion; import io.github.notenoughupdates.moulconfig.annotations.Category; @@ -113,6 +114,11 @@ public class InventoryConfig { @Accordion public PageScrollingConfig pageScrolling = new PageScrollingConfig(); + @Expose + @ConfigOption(name = "Cake Tracker", desc = "") + @Accordion + public CakeTrackerConfig cakeTracker = new CakeTrackerConfig(); + @Expose @ConfigOption(name = "Item Number", desc = "Showing the item number as a stack size for these items.") @ConfigEditorDraggableList diff --git a/src/main/java/at/hannibal2/skyhanni/config/storage/ProfileSpecificStorage.java b/src/main/java/at/hannibal2/skyhanni/config/storage/ProfileSpecificStorage.java index b49a9c612fca..b445bd83fae5 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/storage/ProfileSpecificStorage.java +++ b/src/main/java/at/hannibal2/skyhanni/config/storage/ProfileSpecificStorage.java @@ -28,7 +28,7 @@ import at.hannibal2.skyhanni.features.garden.pests.PestProfitTracker; import at.hannibal2.skyhanni.features.garden.pests.VinylType; import at.hannibal2.skyhanni.features.garden.visitor.VisitorReward; -import at.hannibal2.skyhanni.features.inventory.chocolatefactory.ChocolateFactoryUpgrade; +import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTracker; import at.hannibal2.skyhanni.features.inventory.wardrobe.WardrobeAPI; import at.hannibal2.skyhanni.features.mining.MineshaftPityDisplay; import at.hannibal2.skyhanni.features.mining.fossilexcavator.ExcavatorProfitTracker; @@ -458,6 +458,9 @@ public static class GhostCounter { } + @Expose + public CakeTracker.Data cakeTracker = new CakeTracker.Data(); + @Expose public PowderTracker.Data powderTracker = new PowderTracker.Data(); diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt new file mode 100644 index 000000000000..512bf5748f4e --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -0,0 +1,158 @@ +package at.hannibal2.skyhanni.features.inventory.caketracker + +import at.hannibal2.skyhanni.SkyHanniMod +import at.hannibal2.skyhanni.data.ProfileStorageData +import at.hannibal2.skyhanni.events.DrawScreenAfterEvent +import at.hannibal2.skyhanni.events.InventoryFullyOpenedEvent +import at.hannibal2.skyhanni.events.InventoryOpenEvent +import at.hannibal2.skyhanni.events.SecondPassedEvent +import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTrackerConfig.CakeTrackerDisplayType +import at.hannibal2.skyhanni.features.inventory.patternGroup +import at.hannibal2.skyhanni.skyhannimodule.SkyHanniModule +import at.hannibal2.skyhanni.utils.ChatUtils +import at.hannibal2.skyhanni.utils.CollectionUtils.addAsSingletonList +import at.hannibal2.skyhanni.utils.HypixelCommands +import at.hannibal2.skyhanni.utils.InventoryUtils +import at.hannibal2.skyhanni.utils.InventoryUtils.getInventoryName +import at.hannibal2.skyhanni.utils.ItemUtils.itemName +import at.hannibal2.skyhanni.utils.LorenzUtils +import at.hannibal2.skyhanni.utils.RegexUtils.matches +import at.hannibal2.skyhanni.utils.SkyBlockTime +import at.hannibal2.skyhanni.utils.renderables.Renderable +import at.hannibal2.skyhanni.utils.tracker.SkyHanniTracker +import at.hannibal2.skyhanni.utils.tracker.TrackerData +import com.google.gson.annotations.Expose +import net.minecraft.client.Minecraft +import net.minecraft.client.gui.inventory.GuiChest +import net.minecraft.client.gui.inventory.GuiContainer +import net.minecraft.inventory.ContainerChest +import net.minecraftforge.client.event.GuiOpenEvent +import net.minecraftforge.fml.common.eventhandler.EventPriority +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent + +@SkyHanniModule +object CakeTracker { + + fun getStorage() = ProfileStorageData.profileSpecific?.cakeTracker + private val config get() = SkyHanniMod.feature.inventory.cakeTracker + private var currentYear = SkyBlockTime.now().year + + /** + * REGEX-TEST: §cNew Year Cake (Year 360) + * REGEX-TEST: §cNew Year Cake (Year 1,000) + */ + private val cakeNamePattern by patternGroup.pattern( + "cake.name", + "§cNew Year Cake \\(Year (?[\\d,]*)\\)" + ) + + /** + * REGEX-TEST: Ender Chest (2/9) + * REGEX-TEST: Jumbo Backpack (Slot #6) + * REGEX-TEST: New Year Cake Bag + */ + private val cakeContainerPattern by patternGroup.pattern( + "cake.container", + "^(Ender Chest \\(\\d{1,2}/\\d{1,2}\\)|.*Backpack(?:§r)? \\(Slot #\\d{1,2}\\)|New Year Cake Bag)$" + ) + + /** + * REGEX-TEST: New Year Cake Bag + */ + private val cakeBagPattern by patternGroup.pattern( + "cake.bag", + "^New Year Cake Bag$" + ) + + private val tracker = SkyHanniTracker("New Year Cake Tracker", { Data() }, { it.cakeTracker }) + { drawDisplay(it) } + + class Data : TrackerData() { + override fun reset(){ + cakesOwned.clear() + } + + @Expose + var cakesOwned: MutableList = mutableListOf() + + @Expose + var cakesMissing: MutableList = mutableListOf() + } + + @SubscribeEvent + fun onInventoryOpen(event: InventoryFullyOpenedEvent) { + if (!LorenzUtils.inSkyBlock) return + if (!config.enabled) return + val inventoryName = event.inventoryName + if(!cakeContainerPattern.matches(inventoryName)) return; + val items = event.inventoryItems.values.filter { cakeNamePattern.matches(it.displayName) } + ChatUtils.chat("Cakes found: ${items.count()}") + } + + @SubscribeEvent + fun onSecondPassed(event: SecondPassedEvent) { + if(!LorenzUtils.inSkyBlock) return + if(!config.enabled) return + checkYear() + } + + private fun checkYear() { + if(SkyBlockTime.now().year == currentYear) return + val profileStorage = getStorage() ?: return + currentYear = SkyBlockTime.now().year + recalculateMissingCakes(profileStorage) + } + + private fun recalculateMissingCakes(data: Data) { + data.cakesMissing = (1..currentYear).filterNot { data.cakesOwned.contains(it) }.toMutableList() + } + + private fun cakeYearsToRenderable(start: Int, end: Int = 0): Renderable { + return Renderable.clickAndHover( + if (end != 0) "§cYears $start-$end" else "§cYear $start", + listOf("Click to search /ah"), + onClick = { + HypixelCommands.ahs("New Year Cake (Year $start)") + }, + ) + } + + private fun drawDisplay(data: Data): List> = buildList { + addAsSingletonList( + Renderable.hoverTips( + "§f§lYear §c§lCake §f§lTracker", + tips = listOf("§aHave§7: §a${data.cakesOwned.count()}§7, §cMissing§7: §c${data.cakesMissing.count()}") + ), + ) + + if (data.cakesMissing.isEmpty()) { + addAsSingletonList("§aAll cakes owned!") + } else { + val sortedMissingCakes = when (config.displayType) { + CakeTrackerDisplayType.OLDEST_FIRST -> data.cakesMissing.sorted() + CakeTrackerDisplayType.NEWEST_FIRST -> data.cakesMissing.sortedDescending() + null -> data.cakesMissing + } + + // Combine consecutive missing years into ranges + val combinedMissingYears = mutableListOf() + var start = sortedMissingCakes.first() + var end = start + + for (i in 1 until sortedMissingCakes.size) { + if (sortedMissingCakes[i] == end + 1) end = sortedMissingCakes[i] + else { + if (start != end) combinedMissingYears.add(cakeYearsToRenderable(start, end)) + else combinedMissingYears.add(cakeYearsToRenderable(start)) + start = sortedMissingCakes[i] + end = start + } + } + + if (start != end) combinedMissingYears.add(cakeYearsToRenderable(start, end)) + else combinedMissingYears.add(cakeYearsToRenderable(start)) + + add(combinedMissingYears) + } + } +} diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java new file mode 100644 index 000000000000..d721acf610de --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java @@ -0,0 +1,43 @@ +package at.hannibal2.skyhanni.features.inventory.caketracker; + +import at.hannibal2.skyhanni.config.FeatureToggle; +import at.hannibal2.skyhanni.config.core.config.Position; +import com.google.gson.annotations.Expose; +import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorBoolean; +import io.github.notenoughupdates.moulconfig.annotations.ConfigLink; +import io.github.notenoughupdates.moulconfig.annotations.ConfigOption; + +public class CakeTrackerConfig { + + @Expose + @ConfigOption(name = "New Year Cake Tracker", desc = "Track which New Year Cakes you have/need.") + @ConfigEditorBoolean + @FeatureToggle + public boolean enabled = false; + + @Expose + @ConfigLink(owner = CakeTrackerConfig.class, field = "enabled") + public Position cakeTrackerPosition = new Position(300, 300, false, true); + + @Expose + @ConfigOption(name = "Display Mode", desc = "How the tracker should display") + public CakeTrackerDisplayType displayType = CakeTrackerDisplayType.OLDEST_FIRST; + + public enum CakeTrackerDisplayType { + + OLDEST_FIRST("§cOldest Missing First"), + NEWEST_FIRST("§dNewest Missing First") + ; + + private final String name; + + CakeTrackerDisplayType(String name) { + this.name = name; + } + + @Override + public String toString() { + return name; + } + } +} diff --git a/src/main/java/at/hannibal2/skyhanni/utils/HypixelCommands.kt b/src/main/java/at/hannibal2/skyhanni/utils/HypixelCommands.kt index 4df630dbe040..d0a349b3820a 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/HypixelCommands.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/HypixelCommands.kt @@ -137,6 +137,10 @@ object HypixelCommands { send("chatprompt $prompt") } + fun ahs(query: String) { + send("ahs $query") + } + private fun send(command: String) { @Suppress("DEPRECATION") // TODO rename function From 210f7098c0d9ef76484f42e629e2f01de9f40002 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Fri, 19 Jul 2024 01:59:47 -0400 Subject: [PATCH 02/15] Progress, still lots to do --- .../skyhanni/config/commands/Commands.kt | 5 + .../inventory/caketracker/CakeTracker.kt | 244 ++++++++++++++---- .../caketracker/CakeTrackerConfig.java | 34 ++- 3 files changed, 229 insertions(+), 54 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt b/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt index c08595b5bf80..fe96772f6a48 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt +++ b/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt @@ -51,6 +51,7 @@ import at.hannibal2.skyhanni.features.garden.fortuneguide.FFGuideGUI import at.hannibal2.skyhanni.features.garden.pests.PestFinder import at.hannibal2.skyhanni.features.garden.pests.PestProfitTracker import at.hannibal2.skyhanni.features.garden.visitor.GardenVisitorDropStatistics +import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTracker import at.hannibal2.skyhanni.features.mining.KingTalismanHelper import at.hannibal2.skyhanni.features.mining.MineshaftPityDisplay import at.hannibal2.skyhanni.features.mining.powdertracker.PowderTracker @@ -272,6 +273,10 @@ object Commands { "shresetseacreaturetracker", "Resets the Sea Creature Tracker", ) { SeaCreatureTracker.resetCommand() } + registerCommand( + "shresetcaketracker", + "Resets the New Year Cake Tracker", + ) { CakeTracker.resetCommand() } registerCommand( "shfandomwiki", "Searches the fandom wiki with SkyHanni's own method.", diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index 512bf5748f4e..5e7047d7b6db 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -2,48 +2,58 @@ package at.hannibal2.skyhanni.features.inventory.caketracker import at.hannibal2.skyhanni.SkyHanniMod import at.hannibal2.skyhanni.data.ProfileStorageData -import at.hannibal2.skyhanni.events.DrawScreenAfterEvent +import at.hannibal2.skyhanni.events.GuiContainerEvent +import at.hannibal2.skyhanni.events.GuiRenderEvent +import at.hannibal2.skyhanni.events.InventoryCloseEvent import at.hannibal2.skyhanni.events.InventoryFullyOpenedEvent -import at.hannibal2.skyhanni.events.InventoryOpenEvent import at.hannibal2.skyhanni.events.SecondPassedEvent import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTrackerConfig.CakeTrackerDisplayType +import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTrackerConfig.CakeTrackerDisplayOrderType import at.hannibal2.skyhanni.features.inventory.patternGroup import at.hannibal2.skyhanni.skyhannimodule.SkyHanniModule -import at.hannibal2.skyhanni.utils.ChatUtils import at.hannibal2.skyhanni.utils.CollectionUtils.addAsSingletonList import at.hannibal2.skyhanni.utils.HypixelCommands import at.hannibal2.skyhanni.utils.InventoryUtils -import at.hannibal2.skyhanni.utils.InventoryUtils.getInventoryName -import at.hannibal2.skyhanni.utils.ItemUtils.itemName +import at.hannibal2.skyhanni.utils.LorenzColor import at.hannibal2.skyhanni.utils.LorenzUtils +import at.hannibal2.skyhanni.utils.RegexUtils.matchMatcher import at.hannibal2.skyhanni.utils.RegexUtils.matches +import at.hannibal2.skyhanni.utils.RenderUtils.highlight import at.hannibal2.skyhanni.utils.SkyBlockTime import at.hannibal2.skyhanni.utils.renderables.Renderable import at.hannibal2.skyhanni.utils.tracker.SkyHanniTracker import at.hannibal2.skyhanni.utils.tracker.TrackerData import com.google.gson.annotations.Expose -import net.minecraft.client.Minecraft -import net.minecraft.client.gui.inventory.GuiChest -import net.minecraft.client.gui.inventory.GuiContainer -import net.minecraft.inventory.ContainerChest -import net.minecraftforge.client.event.GuiOpenEvent -import net.minecraftforge.fml.common.eventhandler.EventPriority import net.minecraftforge.fml.common.eventhandler.SubscribeEvent @SkyHanniModule object CakeTracker { - fun getStorage() = ProfileStorageData.profileSpecific?.cakeTracker + /** + * TODO: + * - Check for Cake leaving inventory, if not `inCakeInventory`, remove from tracker + * - When items are placed into inventories, if `inCakeInventory`, do another inventory check + * - Fix drawDisplay() so that year grouping works for both Display Order Types + */ + + private fun getCakeTrackerData() = ProfileStorageData.profileSpecific?.cakeTracker private val config get() = SkyHanniMod.feature.inventory.cakeTracker private var currentYear = SkyBlockTime.now().year + private var inCakeBag = false + private var inCakeInventory = false + private var inAuctionHouse = false + private var unobtainedCakesDisplayed = false + private var searchingForCakes = false + /** * REGEX-TEST: §cNew Year Cake (Year 360) * REGEX-TEST: §cNew Year Cake (Year 1,000) + * REGEX-TEST: §f§f§cNew Year Cake (Year 330) */ private val cakeNamePattern by patternGroup.pattern( "cake.name", - "§cNew Year Cake \\(Year (?[\\d,]*)\\)" + "(?:§f§f)?§cNew Year Cake \\(Year (?[\\d,]*)\\)" ) /** @@ -64,6 +74,23 @@ object CakeTracker { "^New Year Cake Bag$" ) + /** + * REGEX-TEST: Auctions Browser + * REGEX-TEST: Auctions: "Test" + */ + private val auctionBrowserPattern by patternGroup.pattern( + "auction.search", + "^(Auctions Browser|Auctions: \".*)$", + ) + + /** + * REGEX-TEST: Auctions: "New Year C + */ + private val auctionCakeSearchPattern by patternGroup.pattern( + "auction.cakesearch", + "^Auctions: \"New Year C.*$" + ) + private val tracker = SkyHanniTracker("New Year Cake Tracker", { Data() }, { it.cakeTracker }) { drawDisplay(it) } @@ -79,42 +106,148 @@ object CakeTracker { var cakesMissing: MutableList = mutableListOf() } + private fun addCake(cakeYear: Int) { + val cakeTrackerData = getCakeTrackerData() ?: return + if (!cakeTrackerData.cakesOwned.contains(cakeYear)) { + tracker.modify { + it.cakesOwned.add(cakeYear) + } + } + recalculateMissingCakes() + } + + private fun removeCake(cakeYear: Int) { + val cakeTrackerData = getCakeTrackerData() ?: return + if (cakeTrackerData.cakesOwned.contains(cakeYear)) { + tracker.modify { + it.cakesOwned.remove(cakeYear) + } + } + recalculateMissingCakes() + } + + private fun isEnabled(): Boolean { + if (!LorenzUtils.inSkyBlock) return false + if (!config.enabled) return false + return true; + } + + @SubscribeEvent + fun onBackgroundDraw(event: GuiRenderEvent.ChestGuiOverlayRenderEvent) { + if (!isEnabled()) return + if (inCakeBag || (inAuctionHouse && (unobtainedCakesDisplayed || searchingForCakes))) { + tracker.renderDisplay(config.cakeTrackerPosition) + } + } + + @SubscribeEvent + fun onBackgroundDraw(event: GuiContainerEvent.BackgroundDrawnEvent) { + if (inAuctionHouse) { + unobtainedCakesDisplayed = getCakeTrackerData()?.let { data -> + InventoryUtils.getItemsInOpenChest().filter { + cakeNamePattern.matches(it.stack.displayName) + }.onEach { cakeItem -> + cakeNamePattern.matchMatcher(cakeItem.stack.displayName) { + group("year").toInt().takeIf { it !in data.cakesOwned }?.let { + cakeItem highlight LorenzColor.RED + } + } + }.isNotEmpty() + } ?: false + } + } + @SubscribeEvent fun onInventoryOpen(event: InventoryFullyOpenedEvent) { - if (!LorenzUtils.inSkyBlock) return - if (!config.enabled) return + if(!isEnabled()) return val inventoryName = event.inventoryName - if(!cakeContainerPattern.matches(inventoryName)) return; - val items = event.inventoryItems.values.filter { cakeNamePattern.matches(it.displayName) } - ChatUtils.chat("Cakes found: ${items.count()}") + if(cakeContainerPattern.matches(inventoryName)) { + if(cakeBagPattern.matches(inventoryName)) inCakeBag = true + val items = event.inventoryItems.values.filter { cakeNamePattern.matches(it.displayName) } + for(item in items) { + cakeNamePattern.matchMatcher(item.displayName){ + val cakeYearInt = group("year").toInt() + addCake(cakeYearInt) + } + } + tracker.firstUpdate() + } + if(auctionBrowserPattern.matches(inventoryName)) { + inAuctionHouse = true + searchingForCakes = auctionCakeSearchPattern.matches(inventoryName) + } else inAuctionHouse = false + } + + @SubscribeEvent + fun onInventoryClose(event: InventoryCloseEvent) { + inCakeBag = false + inCakeInventory = false + inAuctionHouse = false + unobtainedCakesDisplayed = false + searchingForCakes = false } @SubscribeEvent fun onSecondPassed(event: SecondPassedEvent) { - if(!LorenzUtils.inSkyBlock) return - if(!config.enabled) return + if(!isEnabled()) return checkYear() } private fun checkYear() { - if(SkyBlockTime.now().year == currentYear) return - val profileStorage = getStorage() ?: return + if(currentYear == SkyBlockTime.now().year) return currentYear = SkyBlockTime.now().year - recalculateMissingCakes(profileStorage) + recalculateMissingCakes() + } + + private fun recalculateMissingCakes() { + val cakeTrackerData = getCakeTrackerData() ?: return + tracker.modify { + it.cakesMissing = (1..currentYear).filterNot { year -> cakeTrackerData.cakesOwned.contains(year) }.toMutableList() + } + } + + private class CakeRange(var start: Int, var end: Int = 0) { + fun getRenderable(displayType: CakeTrackerDisplayType): Renderable { + val colorCode = if (displayType== CakeTrackerDisplayType.OWNED_CAKES) "§a" else "§c" + val stringRenderable = Renderable.string(if (end != 0) "§fYears $colorCode$start§f-$colorCode$end" else "§fYear $colorCode$start") + return if (displayType == CakeTrackerDisplayType.MISSING_CAKES) Renderable.link( + stringRenderable, + { HypixelCommands.ahs("New Year Cake (Year $start)") } + ) else stringRenderable + } } - private fun recalculateMissingCakes(data: Data) { - data.cakesMissing = (1..currentYear).filterNot { data.cakesOwned.contains(it) }.toMutableList() + private fun setDisplayType(type: CakeTrackerDisplayType) { + val cakeTrackerData = getCakeTrackerData() ?: return + config.displayType = type + drawDisplay(cakeTrackerData) + tracker.update() } - private fun cakeYearsToRenderable(start: Int, end: Int = 0): Renderable { - return Renderable.clickAndHover( - if (end != 0) "§cYears $start-$end" else "§cYear $start", - listOf("Click to search /ah"), - onClick = { - HypixelCommands.ahs("New Year Cake (Year $start)") - }, + private fun getDisplayTypeToggle(): List { + val displayToggleRenderables = mutableListOf() + val ownedString = + if(config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "§7§l[§r §a§nOwned§r §7§l]" + else "§aOwned" + val missingString = + if(config.displayType == CakeTrackerDisplayType.MISSING_CAKES) "§7§l[§r §c§nMissing§r §7§l]" + else "§cMissing" + + displayToggleRenderables.add( + Renderable.optionalLink( + ownedString, + { setDisplayType(CakeTrackerDisplayType.OWNED_CAKES) } + ) { config.displayType != CakeTrackerDisplayType.OWNED_CAKES } ) + displayToggleRenderables.add(Renderable.string(" §7§l- §r")) + displayToggleRenderables.add( + Renderable.optionalLink( + missingString, + { setDisplayType(CakeTrackerDisplayType.MISSING_CAKES) } + ) { config.displayType != CakeTrackerDisplayType.MISSING_CAKES } + ) + + return displayToggleRenderables } private fun drawDisplay(data: Data): List> = buildList { @@ -124,35 +257,48 @@ object CakeTracker { tips = listOf("§aHave§7: §a${data.cakesOwned.count()}§7, §cMissing§7: §c${data.cakesMissing.count()}") ), ) + add(getDisplayTypeToggle()) + + val cakeList = when (config.displayType) { + CakeTrackerDisplayType.OWNED_CAKES -> data.cakesOwned + CakeTrackerDisplayType.MISSING_CAKES -> data.cakesMissing + null -> data.cakesMissing + } - if (data.cakesMissing.isEmpty()) { - addAsSingletonList("§aAll cakes owned!") + if (cakeList.isEmpty()) { + val colorCode = if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "§c" else "§a" + val verbiage = if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "missing" else "owned" + addAsSingletonList("$colorCode§lAll cakes $verbiage!") } else { - val sortedMissingCakes = when (config.displayType) { - CakeTrackerDisplayType.OLDEST_FIRST -> data.cakesMissing.sorted() - CakeTrackerDisplayType.NEWEST_FIRST -> data.cakesMissing.sortedDescending() - null -> data.cakesMissing + val sortedCakes = when (config.displayOrderType) { + CakeTrackerDisplayOrderType.OLDEST_FIRST -> cakeList.sorted() + CakeTrackerDisplayOrderType.NEWEST_FIRST -> cakeList.sortedDescending() + null -> cakeList } - // Combine consecutive missing years into ranges - val combinedMissingYears = mutableListOf() - var start = sortedMissingCakes.first() + // Combine consecutive years into ranges + val cakeRanges = mutableListOf() + var start = sortedCakes.first() var end = start - for (i in 1 until sortedMissingCakes.size) { - if (sortedMissingCakes[i] == end + 1) end = sortedMissingCakes[i] + for (i in 1 until sortedCakes.size) { + if (sortedCakes[i] == end + 1) end = sortedCakes[i] else { - if (start != end) combinedMissingYears.add(cakeYearsToRenderable(start, end)) - else combinedMissingYears.add(cakeYearsToRenderable(start)) - start = sortedMissingCakes[i] + if (start != end) cakeRanges.add(CakeRange(start, end)) + else cakeRanges.add(CakeRange(start)) + start = sortedCakes[i] end = start } } - if (start != end) combinedMissingYears.add(cakeYearsToRenderable(start, end)) - else combinedMissingYears.add(cakeYearsToRenderable(start)) + if (start != end) cakeRanges.add(CakeRange(start, end)) + else cakeRanges.add(CakeRange(start)) - add(combinedMissingYears) + cakeRanges.forEach { addAsSingletonList(it.getRenderable(config.displayType)) } } } + + fun resetCommand() { + tracker.resetCommand() + } } diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java index d721acf610de..ae18ffd89ccc 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java @@ -4,6 +4,7 @@ import at.hannibal2.skyhanni.config.core.config.Position; import com.google.gson.annotations.Expose; import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorBoolean; +import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorDropdown; import io.github.notenoughupdates.moulconfig.annotations.ConfigLink; import io.github.notenoughupdates.moulconfig.annotations.ConfigOption; @@ -20,13 +21,13 @@ public class CakeTrackerConfig { public Position cakeTrackerPosition = new Position(300, 300, false, true); @Expose - @ConfigOption(name = "Display Mode", desc = "How the tracker should display") - public CakeTrackerDisplayType displayType = CakeTrackerDisplayType.OLDEST_FIRST; + @ConfigOption(name = "Display Mode", desc = "Which cakes the tracker should display.") + @ConfigEditorDropdown + public CakeTrackerDisplayType displayType = CakeTrackerDisplayType.MISSING_CAKES; public enum CakeTrackerDisplayType { - - OLDEST_FIRST("§cOldest Missing First"), - NEWEST_FIRST("§dNewest Missing First") + MISSING_CAKES("§cMissing Cakes"), + OWNED_CAKES("§aOwned Cakes") ; private final String name; @@ -40,4 +41,27 @@ public String toString() { return name; } } + + @Expose + @ConfigOption(name = "Display Order", desc = "What order the tracker should display cakes in.") + @ConfigEditorDropdown + public CakeTrackerDisplayOrderType displayOrderType = CakeTrackerDisplayOrderType.OLDEST_FIRST; + + public enum CakeTrackerDisplayOrderType { + + OLDEST_FIRST("§cOldest Cakes First"), + NEWEST_FIRST("§dNewest Cakes First") + ; + + private final String name; + + CakeTrackerDisplayOrderType(String name) { + this.name = name; + } + + @Override + public String toString() { + return name; + } + } } From a19327cd2c053061b7b4e72147963406efcd108b Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Fri, 19 Jul 2024 14:30:11 -0400 Subject: [PATCH 03/15] Full functionality --- .../inventory/caketracker/CakeTracker.kt | 85 ++++++++++++++++--- 1 file changed, 75 insertions(+), 10 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index 5e7047d7b6db..d156dbefc9fe 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -42,9 +42,11 @@ object CakeTracker { private var inCakeBag = false private var inCakeInventory = false + private var timeOpenedCakeInventory: Long = 0 private var inAuctionHouse = false private var unobtainedCakesDisplayed = false private var searchingForCakes = false + private var knownCakesInCurrentInventory = mutableListOf() /** * REGEX-TEST: §cNew Year Cake (Year 360) @@ -129,7 +131,7 @@ object CakeTracker { private fun isEnabled(): Boolean { if (!LorenzUtils.inSkyBlock) return false if (!config.enabled) return false - return true; + return true } @SubscribeEvent @@ -138,10 +140,12 @@ object CakeTracker { if (inCakeBag || (inAuctionHouse && (unobtainedCakesDisplayed || searchingForCakes))) { tracker.renderDisplay(config.cakeTrackerPosition) } + if (inCakeInventory) checkInventoryCakes() } @SubscribeEvent fun onBackgroundDraw(event: GuiContainerEvent.BackgroundDrawnEvent) { + if (!isEnabled()) return if (inAuctionHouse) { unobtainedCakesDisplayed = getCakeTrackerData()?.let { data -> InventoryUtils.getItemsInOpenChest().filter { @@ -155,6 +159,7 @@ object CakeTracker { }.isNotEmpty() } ?: false } + if (inCakeInventory) checkInventoryCakes() } @SubscribeEvent @@ -163,13 +168,20 @@ object CakeTracker { val inventoryName = event.inventoryName if(cakeContainerPattern.matches(inventoryName)) { if(cakeBagPattern.matches(inventoryName)) inCakeBag = true - val items = event.inventoryItems.values.filter { cakeNamePattern.matches(it.displayName) } + val items = event.inventoryItems.filter { cakeNamePattern.matches(it.value.displayName) } + knownCakesInCurrentInventory = items.values.mapNotNull { item -> + cakeNamePattern.matchMatcher(item.displayName) { + group("year")?.toInt() + } + }.toMutableList() for(item in items) { - cakeNamePattern.matchMatcher(item.displayName){ + cakeNamePattern.matchMatcher(item.value.displayName){ val cakeYearInt = group("year").toInt() addCake(cakeYearInt) } } + inCakeInventory = true + timeOpenedCakeInventory = System.currentTimeMillis() tracker.firstUpdate() } if(auctionBrowserPattern.matches(inventoryName)) { @@ -182,6 +194,7 @@ object CakeTracker { fun onInventoryClose(event: InventoryCloseEvent) { inCakeBag = false inCakeInventory = false + knownCakesInCurrentInventory.clear() inAuctionHouse = false unobtainedCakesDisplayed = false searchingForCakes = false @@ -190,15 +203,31 @@ object CakeTracker { @SubscribeEvent fun onSecondPassed(event: SecondPassedEvent) { if(!isEnabled()) return - checkYear() - } - - private fun checkYear() { if(currentYear == SkyBlockTime.now().year) return currentYear = SkyBlockTime.now().year recalculateMissingCakes() } + private fun checkInventoryCakes() { + if (System.currentTimeMillis() - timeOpenedCakeInventory >= 500) { + val currentYears = InventoryUtils.getItemsInOpenChest().mapNotNull { item -> + cakeNamePattern.matchMatcher(item.stack.displayName) { + group("year")?.toInt() + } + } + + val addedYears = currentYears.filter { it !in knownCakesInCurrentInventory } + val removedYears = knownCakesInCurrentInventory.filter { it !in currentYears } + + addedYears.forEach(::addCake) + removedYears.forEach(::removeCake) + + if (addedYears.isNotEmpty() || removedYears.isNotEmpty()) { + knownCakesInCurrentInventory = currentYears.toMutableList() + } + } + } + private fun recalculateMissingCakes() { val cakeTrackerData = getCakeTrackerData() ?: return tracker.modify { @@ -250,14 +279,48 @@ object CakeTracker { return displayToggleRenderables } + private fun setDisplayOrderType(type: CakeTrackerDisplayOrderType) { + val cakeTrackerData = getCakeTrackerData() ?: return + config.displayOrderType = type + drawDisplay(cakeTrackerData) + tracker.update() + } + + private fun getDisplayOrderTypeToggle(): List { + val displayOrderToggleRenderables = mutableListOf() + val newestString = + if(config.displayOrderType == CakeTrackerDisplayOrderType.NEWEST_FIRST) "§7§l[§r §a§nNewest First§r §7§l]" + else "§aNewest First" + val oldestString = + if(config.displayOrderType == CakeTrackerDisplayOrderType.OLDEST_FIRST) "§7§l[§r §c§nOldest First§r §7§l]" + else "§cOldest First" + + displayOrderToggleRenderables.add( + Renderable.optionalLink( + newestString, + { setDisplayOrderType(CakeTrackerDisplayOrderType.NEWEST_FIRST) } + ) { config.displayOrderType != CakeTrackerDisplayOrderType.NEWEST_FIRST } + ) + displayOrderToggleRenderables.add(Renderable.string(" §7§l- §r")) + displayOrderToggleRenderables.add( + Renderable.optionalLink( + oldestString, + { setDisplayOrderType(CakeTrackerDisplayOrderType.OLDEST_FIRST) } + ) { config.displayOrderType != CakeTrackerDisplayOrderType.OLDEST_FIRST } + ) + + return displayOrderToggleRenderables + } + private fun drawDisplay(data: Data): List> = buildList { addAsSingletonList( Renderable.hoverTips( - "§f§lYear §c§lCake §f§lTracker", + "§c§lNew §f§lYear §c§lCake §f§lTracker", tips = listOf("§aHave§7: §a${data.cakesOwned.count()}§7, §cMissing§7: §c${data.cakesMissing.count()}") ), ) add(getDisplayTypeToggle()) + add(getDisplayOrderTypeToggle()) val cakeList = when (config.displayType) { CakeTrackerDisplayType.OWNED_CAKES -> data.cakesOwned @@ -282,8 +345,10 @@ object CakeTracker { var end = start for (i in 1 until sortedCakes.size) { - if (sortedCakes[i] == end + 1) end = sortedCakes[i] - else { + if ((config.displayOrderType == CakeTrackerDisplayOrderType.OLDEST_FIRST && sortedCakes[i] == end + 1) || + (config.displayOrderType == CakeTrackerDisplayOrderType.NEWEST_FIRST && sortedCakes[i] == end - 1)) { + end = sortedCakes[i] + } else { if (start != end) cakeRanges.add(CakeRange(start, end)) else cakeRanges.add(CakeRange(start)) start = sortedCakes[i] From b4b446b12cfc13ee237aee3dc9108b0b1cfa74c3 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Fri, 19 Jul 2024 17:02:43 -0400 Subject: [PATCH 04/15] Add logic to only update currentYear during or after Late Winter 29th --- .../features/inventory/caketracker/CakeTracker.kt | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index d156dbefc9fe..926a328e21d8 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -38,7 +38,7 @@ object CakeTracker { private fun getCakeTrackerData() = ProfileStorageData.profileSpecific?.cakeTracker private val config get() = SkyHanniMod.feature.inventory.cakeTracker - private var currentYear = SkyBlockTime.now().year + private var currentYear = 0 private var inCakeBag = false private var inCakeInventory = false @@ -204,8 +204,10 @@ object CakeTracker { fun onSecondPassed(event: SecondPassedEvent) { if(!isEnabled()) return if(currentYear == SkyBlockTime.now().year) return - currentYear = SkyBlockTime.now().year - recalculateMissingCakes() + if(SkyBlockTime.now().monthName == "Late Winter" && SkyBlockTime.now().day >= 29) { + currentYear = SkyBlockTime.now().year + recalculateMissingCakes() + } else currentYear = SkyBlockTime.now().year - 1 } private fun checkInventoryCakes() { From 37993ae38ca63eea0d23dd55b156ff8ad5d8af22 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Fri, 19 Jul 2024 20:50:39 -0400 Subject: [PATCH 05/15] Add note about NEU, convert static color to config option --- .../features/inventory/caketracker/CakeTracker.kt | 13 +++---------- .../inventory/caketracker/CakeTrackerConfig.java | 9 ++++++++- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index 926a328e21d8..b0975467e2d9 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -12,9 +12,9 @@ import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTrackerConfig.Ca import at.hannibal2.skyhanni.features.inventory.patternGroup import at.hannibal2.skyhanni.skyhannimodule.SkyHanniModule import at.hannibal2.skyhanni.utils.CollectionUtils.addAsSingletonList +import at.hannibal2.skyhanni.utils.ColorUtils.toChromaColor import at.hannibal2.skyhanni.utils.HypixelCommands import at.hannibal2.skyhanni.utils.InventoryUtils -import at.hannibal2.skyhanni.utils.LorenzColor import at.hannibal2.skyhanni.utils.LorenzUtils import at.hannibal2.skyhanni.utils.RegexUtils.matchMatcher import at.hannibal2.skyhanni.utils.RegexUtils.matches @@ -29,13 +29,6 @@ import net.minecraftforge.fml.common.eventhandler.SubscribeEvent @SkyHanniModule object CakeTracker { - /** - * TODO: - * - Check for Cake leaving inventory, if not `inCakeInventory`, remove from tracker - * - When items are placed into inventories, if `inCakeInventory`, do another inventory check - * - Fix drawDisplay() so that year grouping works for both Display Order Types - */ - private fun getCakeTrackerData() = ProfileStorageData.profileSpecific?.cakeTracker private val config get() = SkyHanniMod.feature.inventory.cakeTracker private var currentYear = 0 @@ -140,7 +133,6 @@ object CakeTracker { if (inCakeBag || (inAuctionHouse && (unobtainedCakesDisplayed || searchingForCakes))) { tracker.renderDisplay(config.cakeTrackerPosition) } - if (inCakeInventory) checkInventoryCakes() } @SubscribeEvent @@ -153,7 +145,7 @@ object CakeTracker { }.onEach { cakeItem -> cakeNamePattern.matchMatcher(cakeItem.stack.displayName) { group("year").toInt().takeIf { it !in data.cakesOwned }?.let { - cakeItem highlight LorenzColor.RED + cakeItem highlight config.auctionHighlightColor.toChromaColor() } } }.isNotEmpty() @@ -165,6 +157,7 @@ object CakeTracker { @SubscribeEvent fun onInventoryOpen(event: InventoryFullyOpenedEvent) { if(!isEnabled()) return + knownCakesInCurrentInventory.clear() val inventoryName = event.inventoryName if(cakeContainerPattern.matches(inventoryName)) { if(cakeBagPattern.matches(inventoryName)) inCakeBag = true diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java index ae18ffd89ccc..767ef464c35b 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java @@ -2,8 +2,10 @@ import at.hannibal2.skyhanni.config.FeatureToggle; import at.hannibal2.skyhanni.config.core.config.Position; +import at.hannibal2.skyhanni.utils.LorenzColor; import com.google.gson.annotations.Expose; import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorBoolean; +import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorColour; import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorDropdown; import io.github.notenoughupdates.moulconfig.annotations.ConfigLink; import io.github.notenoughupdates.moulconfig.annotations.ConfigOption; @@ -11,7 +13,7 @@ public class CakeTrackerConfig { @Expose - @ConfigOption(name = "New Year Cake Tracker", desc = "Track which New Year Cakes you have/need.") + @ConfigOption(name = "New Year Cake Tracker", desc = "Track which Cakes you have/need. §cWill not fully work with NEU Storage Overlay.") @ConfigEditorBoolean @FeatureToggle public boolean enabled = false; @@ -64,4 +66,9 @@ public String toString() { return name; } } + + @Expose + @ConfigOption(name = "Auction Highlight Color", desc = "The color that should be used to highlight unobtained cakes in the auction house.") + @ConfigEditorColour + public String auctionHighlightColor = LorenzColor.RED.toConfigColour(); } From 4a862dea8214c36323c59ae0acd87aba81a96740 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Tue, 30 Jul 2024 11:47:33 -0400 Subject: [PATCH 06/15] Post merge cleanup --- src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt | 1 + .../features/inventory/caketracker/CakeTrackerConfig.java | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt b/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt index 2ec8659ec3fc..2d4947d51ae6 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt +++ b/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt @@ -278,6 +278,7 @@ object Commands { "shresetcaketracker", "Resets the New Year Cake Tracker", ) { CakeTracker.resetCommand() } + registerCommand( "shresetstrayrabbittracker", "Resets the Stray Rabbit Tracker", ) { ChocolateFactoryStrayTracker.resetCommand() } diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java index 767ef464c35b..dc255853736b 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTrackerConfig.java @@ -70,5 +70,5 @@ public String toString() { @Expose @ConfigOption(name = "Auction Highlight Color", desc = "The color that should be used to highlight unobtained cakes in the auction house.") @ConfigEditorColour - public String auctionHighlightColor = LorenzColor.RED.toConfigColour(); + public String auctionHighlightColor = LorenzColor.RED.toConfigColor(); } From 3e6da8812b522ad2d2d6db19b02c3be290e209b1 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Wed, 21 Aug 2024 13:32:14 -0400 Subject: [PATCH 07/15] This seems better --- .../skyhanni/features/inventory/caketracker/CakeTracker.kt | 2 +- .../at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index b0975467e2d9..f0cdeb918fd6 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -131,7 +131,7 @@ object CakeTracker { fun onBackgroundDraw(event: GuiRenderEvent.ChestGuiOverlayRenderEvent) { if (!isEnabled()) return if (inCakeBag || (inAuctionHouse && (unobtainedCakesDisplayed || searchingForCakes))) { - tracker.renderDisplay(config.cakeTrackerPosition) + tracker.renderDisplay(config.cakeTrackerPosition, sessionTracking = false) } } diff --git a/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt b/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt index 345767b051b5..e17cb785fa1f 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt @@ -70,7 +70,7 @@ open class SkyHanniTracker( update() } - fun renderDisplay(position: Position) { + fun renderDisplay(position: Position, sessionTracking: Boolean = true) { if (config.hideInEstimatedItemValue && EstimatedItemValue.isCurrentlyShowing()) return val currentlyOpen = Minecraft.getMinecraft().currentScreen?.let { it is GuiInventory || it is GuiChest } ?: false @@ -84,7 +84,7 @@ open class SkyHanniTracker( if (dirty || TrackerManager.dirty) { display = getSharedTracker()?.let { - buildFinalDisplay(drawDisplay(it.get(getDisplayMode()))) + buildFinalDisplay(drawDisplay(it.get(getDisplayMode())), sessionTracking) } ?: emptyList() dirty = false } @@ -96,7 +96,7 @@ open class SkyHanniTracker( dirty = true } - private fun buildFinalDisplay(rawList: List>) = rawList.toMutableList().also { + private fun buildFinalDisplay(rawList: List>, sessionTracking: Boolean) = rawList.toMutableList().also { if (it.isEmpty()) return@also if (inventoryOpen) { it.add(1, buildDisplayModeView()) From 5b4b4dffdfd747fc1d1faba6242e910a41d20af6 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Wed, 21 Aug 2024 13:34:46 -0400 Subject: [PATCH 08/15] Actually take action on param, rename --- .../features/inventory/caketracker/CakeTracker.kt | 2 +- .../skyhanni/utils/tracker/SkyHanniTracker.kt | 14 +++++++------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index f0cdeb918fd6..d0cdfbefc229 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -131,7 +131,7 @@ object CakeTracker { fun onBackgroundDraw(event: GuiRenderEvent.ChestGuiOverlayRenderEvent) { if (!isEnabled()) return if (inCakeBag || (inAuctionHouse && (unobtainedCakesDisplayed || searchingForCakes))) { - tracker.renderDisplay(config.cakeTrackerPosition, sessionTracking = false) + tracker.renderDisplay(config.cakeTrackerPosition, displayModeToggleable = false) } } diff --git a/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt b/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt index e17cb785fa1f..0b5e3b0c518a 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt @@ -70,7 +70,7 @@ open class SkyHanniTracker( update() } - fun renderDisplay(position: Position, sessionTracking: Boolean = true) { + fun renderDisplay(position: Position, displayModeToggleable: Boolean = true) { if (config.hideInEstimatedItemValue && EstimatedItemValue.isCurrentlyShowing()) return val currentlyOpen = Minecraft.getMinecraft().currentScreen?.let { it is GuiInventory || it is GuiChest } ?: false @@ -84,7 +84,7 @@ open class SkyHanniTracker( if (dirty || TrackerManager.dirty) { display = getSharedTracker()?.let { - buildFinalDisplay(drawDisplay(it.get(getDisplayMode())), sessionTracking) + buildFinalDisplay(drawDisplay(it.get(getDisplayMode())), displayModeToggleable) } ?: emptyList() dirty = false } @@ -96,13 +96,13 @@ open class SkyHanniTracker( dirty = true } - private fun buildFinalDisplay(rawList: List>, sessionTracking: Boolean) = rawList.toMutableList().also { + private fun buildFinalDisplay(rawList: List>, displayModeToggleable: Boolean) = rawList.toMutableList().also { if (it.isEmpty()) return@also - if (inventoryOpen) { + if (inventoryOpen && displayModeToggleable) { it.add(1, buildDisplayModeView()) - } - if (inventoryOpen && getDisplayMode() == DisplayMode.SESSION) { - it.addAsSingletonList(buildSessionResetButton()) + if (getDisplayMode() == DisplayMode.SESSION) { + it.addAsSingletonList(buildSessionResetButton()) + } } } From 7b508f1401f197c3367ab56eeb85dbfcf4b0d55c Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Sun, 8 Sep 2024 12:21:52 -0400 Subject: [PATCH 09/15] Post merge cleanup --- .../inventory/caketracker/CakeTracker.kt | 79 ++++++++++--------- .../skyhanni/utils/tracker/SkyHanniTracker.kt | 7 +- 2 files changed, 44 insertions(+), 42 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index d0cdfbefc229..c889f8b720c9 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -7,11 +7,10 @@ import at.hannibal2.skyhanni.events.GuiRenderEvent import at.hannibal2.skyhanni.events.InventoryCloseEvent import at.hannibal2.skyhanni.events.InventoryFullyOpenedEvent import at.hannibal2.skyhanni.events.SecondPassedEvent -import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTrackerConfig.CakeTrackerDisplayType import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTrackerConfig.CakeTrackerDisplayOrderType +import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTrackerConfig.CakeTrackerDisplayType import at.hannibal2.skyhanni.features.inventory.patternGroup import at.hannibal2.skyhanni.skyhannimodule.SkyHanniModule -import at.hannibal2.skyhanni.utils.CollectionUtils.addAsSingletonList import at.hannibal2.skyhanni.utils.ColorUtils.toChromaColor import at.hannibal2.skyhanni.utils.HypixelCommands import at.hannibal2.skyhanni.utils.InventoryUtils @@ -48,7 +47,7 @@ object CakeTracker { */ private val cakeNamePattern by patternGroup.pattern( "cake.name", - "(?:§f§f)?§cNew Year Cake \\(Year (?[\\d,]*)\\)" + "(?:§f§f)?§cNew Year Cake \\(Year (?[\\d,]*)\\)", ) /** @@ -58,7 +57,7 @@ object CakeTracker { */ private val cakeContainerPattern by patternGroup.pattern( "cake.container", - "^(Ender Chest \\(\\d{1,2}/\\d{1,2}\\)|.*Backpack(?:§r)? \\(Slot #\\d{1,2}\\)|New Year Cake Bag)$" + "^(Ender Chest \\(\\d{1,2}/\\d{1,2}\\)|.*Backpack(?:§r)? \\(Slot #\\d{1,2}\\)|New Year Cake Bag)$", ) /** @@ -66,7 +65,7 @@ object CakeTracker { */ private val cakeBagPattern by patternGroup.pattern( "cake.bag", - "^New Year Cake Bag$" + "^New Year Cake Bag$", ) /** @@ -83,14 +82,14 @@ object CakeTracker { */ private val auctionCakeSearchPattern by patternGroup.pattern( "auction.cakesearch", - "^Auctions: \"New Year C.*$" + "^Auctions: \"New Year C.*$", ) private val tracker = SkyHanniTracker("New Year Cake Tracker", { Data() }, { it.cakeTracker }) { drawDisplay(it) } class Data : TrackerData() { - override fun reset(){ + override fun reset() { cakesOwned.clear() } @@ -156,19 +155,19 @@ object CakeTracker { @SubscribeEvent fun onInventoryOpen(event: InventoryFullyOpenedEvent) { - if(!isEnabled()) return + if (!isEnabled()) return knownCakesInCurrentInventory.clear() val inventoryName = event.inventoryName - if(cakeContainerPattern.matches(inventoryName)) { - if(cakeBagPattern.matches(inventoryName)) inCakeBag = true + if (cakeContainerPattern.matches(inventoryName)) { + if (cakeBagPattern.matches(inventoryName)) inCakeBag = true val items = event.inventoryItems.filter { cakeNamePattern.matches(it.value.displayName) } knownCakesInCurrentInventory = items.values.mapNotNull { item -> cakeNamePattern.matchMatcher(item.displayName) { group("year")?.toInt() } }.toMutableList() - for(item in items) { - cakeNamePattern.matchMatcher(item.value.displayName){ + for (item in items) { + cakeNamePattern.matchMatcher(item.value.displayName) { val cakeYearInt = group("year").toInt() addCake(cakeYearInt) } @@ -177,7 +176,7 @@ object CakeTracker { timeOpenedCakeInventory = System.currentTimeMillis() tracker.firstUpdate() } - if(auctionBrowserPattern.matches(inventoryName)) { + if (auctionBrowserPattern.matches(inventoryName)) { inAuctionHouse = true searchingForCakes = auctionCakeSearchPattern.matches(inventoryName) } else inAuctionHouse = false @@ -195,9 +194,9 @@ object CakeTracker { @SubscribeEvent fun onSecondPassed(event: SecondPassedEvent) { - if(!isEnabled()) return - if(currentYear == SkyBlockTime.now().year) return - if(SkyBlockTime.now().monthName == "Late Winter" && SkyBlockTime.now().day >= 29) { + if (!isEnabled()) return + if (currentYear == SkyBlockTime.now().year) return + if (SkyBlockTime.now().monthName == "Late Winter" && SkyBlockTime.now().day >= 29) { currentYear = SkyBlockTime.now().year recalculateMissingCakes() } else currentYear = SkyBlockTime.now().year - 1 @@ -232,11 +231,12 @@ object CakeTracker { private class CakeRange(var start: Int, var end: Int = 0) { fun getRenderable(displayType: CakeTrackerDisplayType): Renderable { - val colorCode = if (displayType== CakeTrackerDisplayType.OWNED_CAKES) "§a" else "§c" - val stringRenderable = Renderable.string(if (end != 0) "§fYears $colorCode$start§f-$colorCode$end" else "§fYear $colorCode$start") + val colorCode = if (displayType == CakeTrackerDisplayType.OWNED_CAKES) "§a" else "§c" + val stringRenderable = + Renderable.string(if (end != 0) "§fYears $colorCode$start§f-$colorCode$end" else "§fYear $colorCode$start") return if (displayType == CakeTrackerDisplayType.MISSING_CAKES) Renderable.link( stringRenderable, - { HypixelCommands.ahs("New Year Cake (Year $start)") } + { HypixelCommands.ahs("New Year Cake (Year $start)") }, ) else stringRenderable } } @@ -251,24 +251,24 @@ object CakeTracker { private fun getDisplayTypeToggle(): List { val displayToggleRenderables = mutableListOf() val ownedString = - if(config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "§7§l[§r §a§nOwned§r §7§l]" + if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "§7§l[§r §a§nOwned§r §7§l]" else "§aOwned" val missingString = - if(config.displayType == CakeTrackerDisplayType.MISSING_CAKES) "§7§l[§r §c§nMissing§r §7§l]" + if (config.displayType == CakeTrackerDisplayType.MISSING_CAKES) "§7§l[§r §c§nMissing§r §7§l]" else "§cMissing" displayToggleRenderables.add( Renderable.optionalLink( ownedString, - { setDisplayType(CakeTrackerDisplayType.OWNED_CAKES) } - ) { config.displayType != CakeTrackerDisplayType.OWNED_CAKES } + { setDisplayType(CakeTrackerDisplayType.OWNED_CAKES) }, + ) { config.displayType != CakeTrackerDisplayType.OWNED_CAKES }, ) displayToggleRenderables.add(Renderable.string(" §7§l- §r")) displayToggleRenderables.add( Renderable.optionalLink( missingString, - { setDisplayType(CakeTrackerDisplayType.MISSING_CAKES) } - ) { config.displayType != CakeTrackerDisplayType.MISSING_CAKES } + { setDisplayType(CakeTrackerDisplayType.MISSING_CAKES) }, + ) { config.displayType != CakeTrackerDisplayType.MISSING_CAKES }, ) return displayToggleRenderables @@ -284,38 +284,38 @@ object CakeTracker { private fun getDisplayOrderTypeToggle(): List { val displayOrderToggleRenderables = mutableListOf() val newestString = - if(config.displayOrderType == CakeTrackerDisplayOrderType.NEWEST_FIRST) "§7§l[§r §a§nNewest First§r §7§l]" + if (config.displayOrderType == CakeTrackerDisplayOrderType.NEWEST_FIRST) "§7§l[§r §a§nNewest First§r §7§l]" else "§aNewest First" val oldestString = - if(config.displayOrderType == CakeTrackerDisplayOrderType.OLDEST_FIRST) "§7§l[§r §c§nOldest First§r §7§l]" + if (config.displayOrderType == CakeTrackerDisplayOrderType.OLDEST_FIRST) "§7§l[§r §c§nOldest First§r §7§l]" else "§cOldest First" displayOrderToggleRenderables.add( Renderable.optionalLink( newestString, - { setDisplayOrderType(CakeTrackerDisplayOrderType.NEWEST_FIRST) } - ) { config.displayOrderType != CakeTrackerDisplayOrderType.NEWEST_FIRST } + { setDisplayOrderType(CakeTrackerDisplayOrderType.NEWEST_FIRST) }, + ) { config.displayOrderType != CakeTrackerDisplayOrderType.NEWEST_FIRST }, ) displayOrderToggleRenderables.add(Renderable.string(" §7§l- §r")) displayOrderToggleRenderables.add( Renderable.optionalLink( oldestString, - { setDisplayOrderType(CakeTrackerDisplayOrderType.OLDEST_FIRST) } - ) { config.displayOrderType != CakeTrackerDisplayOrderType.OLDEST_FIRST } + { setDisplayOrderType(CakeTrackerDisplayOrderType.OLDEST_FIRST) }, + ) { config.displayOrderType != CakeTrackerDisplayOrderType.OLDEST_FIRST }, ) return displayOrderToggleRenderables } - private fun drawDisplay(data: Data): List> = buildList { - addAsSingletonList( + private fun drawDisplay(data: Data): List = buildList { + add( Renderable.hoverTips( "§c§lNew §f§lYear §c§lCake §f§lTracker", - tips = listOf("§aHave§7: §a${data.cakesOwned.count()}§7, §cMissing§7: §c${data.cakesMissing.count()}") + tips = listOf("§aHave§7: §a${data.cakesOwned.count()}§7, §cMissing§7: §c${data.cakesMissing.count()}"), ), ) - add(getDisplayTypeToggle()) - add(getDisplayOrderTypeToggle()) + addAll(getDisplayTypeToggle()) + addAll(getDisplayOrderTypeToggle()) val cakeList = when (config.displayType) { CakeTrackerDisplayType.OWNED_CAKES -> data.cakesOwned @@ -326,7 +326,7 @@ object CakeTracker { if (cakeList.isEmpty()) { val colorCode = if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "§c" else "§a" val verbiage = if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "missing" else "owned" - addAsSingletonList("$colorCode§lAll cakes $verbiage!") + add(Renderable.string("$colorCode§lAll cakes $verbiage!")) } else { val sortedCakes = when (config.displayOrderType) { CakeTrackerDisplayOrderType.OLDEST_FIRST -> cakeList.sorted() @@ -341,7 +341,8 @@ object CakeTracker { for (i in 1 until sortedCakes.size) { if ((config.displayOrderType == CakeTrackerDisplayOrderType.OLDEST_FIRST && sortedCakes[i] == end + 1) || - (config.displayOrderType == CakeTrackerDisplayOrderType.NEWEST_FIRST && sortedCakes[i] == end - 1)) { + (config.displayOrderType == CakeTrackerDisplayOrderType.NEWEST_FIRST && sortedCakes[i] == end - 1) + ) { end = sortedCakes[i] } else { if (start != end) cakeRanges.add(CakeRange(start, end)) @@ -354,7 +355,7 @@ object CakeTracker { if (start != end) cakeRanges.add(CakeRange(start, end)) else cakeRanges.add(CakeRange(start)) - cakeRanges.forEach { addAsSingletonList(it.getRenderable(config.displayType)) } + cakeRanges.forEach { add(it.getRenderable(config.displayType)) } } } diff --git a/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt b/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt index 926971f12fa3..f9bf70be0ae7 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt @@ -8,6 +8,7 @@ import at.hannibal2.skyhanni.data.TrackerManager import at.hannibal2.skyhanni.features.misc.items.EstimatedItemValue import at.hannibal2.skyhanni.utils.ChatUtils import at.hannibal2.skyhanni.utils.CollectionUtils +import at.hannibal2.skyhanni.utils.CollectionUtils.addAsSingletonList import at.hannibal2.skyhanni.utils.NEUInternalName import at.hannibal2.skyhanni.utils.NEUItems.getPrice import at.hannibal2.skyhanni.utils.RenderUtils.renderRenderables @@ -85,7 +86,7 @@ open class SkyHanniTracker( display = getSharedTracker()?.let { val get = it.get(getDisplayMode()) val rawList = drawDisplay(get) - buildFinalDisplay(rawList, , displayModeToggleable) + buildFinalDisplay(rawList, displayModeToggleable) } ?: emptyList() dirty = false } @@ -97,12 +98,12 @@ open class SkyHanniTracker( dirty = true } - private fun buildFinalDisplay(rawList: List>, displayModeToggleable: Boolean) = rawList.toMutableList().also { + private fun buildFinalDisplay(rawList: List, displayModeToggleable: Boolean) = rawList.toMutableList().also { if (it.isEmpty()) return@also if (inventoryOpen && displayModeToggleable) { it.add(1, buildDisplayModeView()) if (getDisplayMode() == DisplayMode.SESSION) { - it.addAsSingletonList(buildSessionResetButton()) + it.add(buildSessionResetButton()) } } } From 896287ad791ad1fe5606137817bb477dcc2fb1d2 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Sun, 8 Sep 2024 12:24:49 -0400 Subject: [PATCH 10/15] Update command registration to be readable --- .../skyhanni/features/inventory/caketracker/CakeTracker.kt | 2 +- src/main/java/at/hannibal2/skyhanni/utils/HypixelCommands.kt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index c889f8b720c9..5df1166b0f91 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -236,7 +236,7 @@ object CakeTracker { Renderable.string(if (end != 0) "§fYears $colorCode$start§f-$colorCode$end" else "§fYear $colorCode$start") return if (displayType == CakeTrackerDisplayType.MISSING_CAKES) Renderable.link( stringRenderable, - { HypixelCommands.ahs("New Year Cake (Year $start)") }, + { HypixelCommands.auctionHouseSearch("New Year Cake (Year $start)") }, ) else stringRenderable } } diff --git a/src/main/java/at/hannibal2/skyhanni/utils/HypixelCommands.kt b/src/main/java/at/hannibal2/skyhanni/utils/HypixelCommands.kt index f459f3459c08..ff196162ee21 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/HypixelCommands.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/HypixelCommands.kt @@ -150,7 +150,7 @@ object HypixelCommands { send("chatprompt $prompt") } - fun ahs(query: String) { + fun auctionHouseSearch(query: String) { send("ahs $query") } From 836be1415fbdb0dfb849c813710e5bb7f89be864 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Mon, 9 Sep 2024 13:18:05 -0400 Subject: [PATCH 11/15] Post-merge cleanup --- .../at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt b/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt index 49aea4227645..d1bf3c57e654 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniTracker.kt @@ -8,7 +8,6 @@ import at.hannibal2.skyhanni.data.TrackerManager import at.hannibal2.skyhanni.features.misc.items.EstimatedItemValue import at.hannibal2.skyhanni.utils.ChatUtils import at.hannibal2.skyhanni.utils.CollectionUtils -import at.hannibal2.skyhanni.utils.CollectionUtils.addAsSingletonList import at.hannibal2.skyhanni.utils.NEUInternalName import at.hannibal2.skyhanni.utils.NEUItems.getPrice import at.hannibal2.skyhanni.utils.RenderUtils.renderRenderables @@ -105,7 +104,7 @@ open class SkyHanniTracker( if (inventoryOpen && displayModeToggleable) { add(buildDisplayModeView()) if (getDisplayMode() == DisplayMode.SESSION) { - it.add(buildSessionResetButton()) + add(buildSessionResetButton()) } } } From 657edbc7976011c36e7bae9a7dbd748ef979516d Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Mon, 9 Sep 2024 13:28:19 -0400 Subject: [PATCH 12/15] Update to Searchables --- .../inventory/caketracker/CakeTracker.kt | 35 +++++++++++-------- 1 file changed, 21 insertions(+), 14 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index 5df1166b0f91..56dd0c4e7888 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -11,6 +11,7 @@ import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTrackerConfig.Ca import at.hannibal2.skyhanni.features.inventory.caketracker.CakeTrackerConfig.CakeTrackerDisplayType import at.hannibal2.skyhanni.features.inventory.patternGroup import at.hannibal2.skyhanni.skyhannimodule.SkyHanniModule +import at.hannibal2.skyhanni.utils.CollectionUtils.addSearchString import at.hannibal2.skyhanni.utils.ColorUtils.toChromaColor import at.hannibal2.skyhanni.utils.HypixelCommands import at.hannibal2.skyhanni.utils.InventoryUtils @@ -20,6 +21,8 @@ import at.hannibal2.skyhanni.utils.RegexUtils.matches import at.hannibal2.skyhanni.utils.RenderUtils.highlight import at.hannibal2.skyhanni.utils.SkyBlockTime import at.hannibal2.skyhanni.utils.renderables.Renderable +import at.hannibal2.skyhanni.utils.renderables.Searchable +import at.hannibal2.skyhanni.utils.renderables.toSearchable import at.hannibal2.skyhanni.utils.tracker.SkyHanniTracker import at.hannibal2.skyhanni.utils.tracker.TrackerData import com.google.gson.annotations.Expose @@ -248,8 +251,8 @@ object CakeTracker { tracker.update() } - private fun getDisplayTypeToggle(): List { - val displayToggleRenderables = mutableListOf() + private fun getDisplayTypeToggle(): List { + val displayToggleRenderables = mutableListOf() val ownedString = if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "§7§l[§r §a§nOwned§r §7§l]" else "§aOwned" @@ -261,14 +264,16 @@ object CakeTracker { Renderable.optionalLink( ownedString, { setDisplayType(CakeTrackerDisplayType.OWNED_CAKES) }, - ) { config.displayType != CakeTrackerDisplayType.OWNED_CAKES }, + condition = { config.displayType != CakeTrackerDisplayType.OWNED_CAKES }, + ).toSearchable() ) - displayToggleRenderables.add(Renderable.string(" §7§l- §r")) + displayToggleRenderables.addSearchString(" §7§l- §r") displayToggleRenderables.add( Renderable.optionalLink( missingString, { setDisplayType(CakeTrackerDisplayType.MISSING_CAKES) }, - ) { config.displayType != CakeTrackerDisplayType.MISSING_CAKES }, + condition = { config.displayType != CakeTrackerDisplayType.MISSING_CAKES }, + ).toSearchable() ) return displayToggleRenderables @@ -281,8 +286,8 @@ object CakeTracker { tracker.update() } - private fun getDisplayOrderTypeToggle(): List { - val displayOrderToggleRenderables = mutableListOf() + private fun getDisplayOrderTypeToggle(): List { + val displayOrderToggleRenderables = mutableListOf() val newestString = if (config.displayOrderType == CakeTrackerDisplayOrderType.NEWEST_FIRST) "§7§l[§r §a§nNewest First§r §7§l]" else "§aNewest First" @@ -294,25 +299,27 @@ object CakeTracker { Renderable.optionalLink( newestString, { setDisplayOrderType(CakeTrackerDisplayOrderType.NEWEST_FIRST) }, - ) { config.displayOrderType != CakeTrackerDisplayOrderType.NEWEST_FIRST }, + condition = { config.displayOrderType != CakeTrackerDisplayOrderType.NEWEST_FIRST }, + ).toSearchable() ) - displayOrderToggleRenderables.add(Renderable.string(" §7§l- §r")) + displayOrderToggleRenderables.addSearchString(" §7§l- §r") displayOrderToggleRenderables.add( Renderable.optionalLink( oldestString, { setDisplayOrderType(CakeTrackerDisplayOrderType.OLDEST_FIRST) }, - ) { config.displayOrderType != CakeTrackerDisplayOrderType.OLDEST_FIRST }, + condition = { config.displayOrderType != CakeTrackerDisplayOrderType.OLDEST_FIRST }, + ).toSearchable() ) return displayOrderToggleRenderables } - private fun drawDisplay(data: Data): List = buildList { + private fun drawDisplay(data: Data): List = buildList { add( Renderable.hoverTips( "§c§lNew §f§lYear §c§lCake §f§lTracker", tips = listOf("§aHave§7: §a${data.cakesOwned.count()}§7, §cMissing§7: §c${data.cakesMissing.count()}"), - ), + ).toSearchable(), ) addAll(getDisplayTypeToggle()) addAll(getDisplayOrderTypeToggle()) @@ -326,7 +333,7 @@ object CakeTracker { if (cakeList.isEmpty()) { val colorCode = if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "§c" else "§a" val verbiage = if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "missing" else "owned" - add(Renderable.string("$colorCode§lAll cakes $verbiage!")) + addSearchString("$colorCode§lAll cakes $verbiage!") } else { val sortedCakes = when (config.displayOrderType) { CakeTrackerDisplayOrderType.OLDEST_FIRST -> cakeList.sorted() @@ -355,7 +362,7 @@ object CakeTracker { if (start != end) cakeRanges.add(CakeRange(start, end)) else cakeRanges.add(CakeRange(start)) - cakeRanges.forEach { add(it.getRenderable(config.displayType)) } + cakeRanges.forEach { add(it.getRenderable(config.displayType).toSearchable()) } } } From d671876937496f4b8f41c8a7ccebe5a5a995b288 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Thu, 10 Oct 2024 09:49:41 -0400 Subject: [PATCH 13/15] Update formatting post-Searchable conversion --- .../inventory/caketracker/CakeTracker.kt | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index 56dd0c4e7888..7594c5098c7a 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -251,8 +251,8 @@ object CakeTracker { tracker.update() } - private fun getDisplayTypeToggle(): List { - val displayToggleRenderables = mutableListOf() + private fun buildDisplayTypeToggle(): Renderable { + val displayToggleRenderables = mutableListOf() val ownedString = if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "§7§l[§r §a§nOwned§r §7§l]" else "§aOwned" @@ -265,18 +265,18 @@ object CakeTracker { ownedString, { setDisplayType(CakeTrackerDisplayType.OWNED_CAKES) }, condition = { config.displayType != CakeTrackerDisplayType.OWNED_CAKES }, - ).toSearchable() + ) ) - displayToggleRenderables.addSearchString(" §7§l- §r") + displayToggleRenderables.add(Renderable.string(" §7§l- §r")) displayToggleRenderables.add( Renderable.optionalLink( missingString, { setDisplayType(CakeTrackerDisplayType.MISSING_CAKES) }, condition = { config.displayType != CakeTrackerDisplayType.MISSING_CAKES }, - ).toSearchable() + ) ) - return displayToggleRenderables + return Renderable.horizontalContainer(displayToggleRenderables) } private fun setDisplayOrderType(type: CakeTrackerDisplayOrderType) { @@ -286,8 +286,8 @@ object CakeTracker { tracker.update() } - private fun getDisplayOrderTypeToggle(): List { - val displayOrderToggleRenderables = mutableListOf() + private fun buildOrderTypeToggle(): Renderable { + val displayOrderToggleRenderables = mutableListOf() val newestString = if (config.displayOrderType == CakeTrackerDisplayOrderType.NEWEST_FIRST) "§7§l[§r §a§nNewest First§r §7§l]" else "§aNewest First" @@ -300,18 +300,18 @@ object CakeTracker { newestString, { setDisplayOrderType(CakeTrackerDisplayOrderType.NEWEST_FIRST) }, condition = { config.displayOrderType != CakeTrackerDisplayOrderType.NEWEST_FIRST }, - ).toSearchable() + ) ) - displayOrderToggleRenderables.addSearchString(" §7§l- §r") + displayOrderToggleRenderables.add(Renderable.string(" §7§l- §r")) displayOrderToggleRenderables.add( Renderable.optionalLink( oldestString, { setDisplayOrderType(CakeTrackerDisplayOrderType.OLDEST_FIRST) }, condition = { config.displayOrderType != CakeTrackerDisplayOrderType.OLDEST_FIRST }, - ).toSearchable() + ) ) - return displayOrderToggleRenderables + return Renderable.horizontalContainer(displayOrderToggleRenderables) } private fun drawDisplay(data: Data): List = buildList { @@ -321,8 +321,8 @@ object CakeTracker { tips = listOf("§aHave§7: §a${data.cakesOwned.count()}§7, §cMissing§7: §c${data.cakesMissing.count()}"), ).toSearchable(), ) - addAll(getDisplayTypeToggle()) - addAll(getDisplayOrderTypeToggle()) + add(buildDisplayTypeToggle().toSearchable("Display Type")) + add(buildOrderTypeToggle().toSearchable("Order Type")) val cakeList = when (config.displayType) { CakeTrackerDisplayType.OWNED_CAKES -> data.cakesOwned @@ -362,7 +362,7 @@ object CakeTracker { if (start != end) cakeRanges.add(CakeRange(start, end)) else cakeRanges.add(CakeRange(start)) - cakeRanges.forEach { add(it.getRenderable(config.displayType).toSearchable()) } + cakeRanges.forEach { add(it.getRenderable(config.displayType).toSearchable("${it.start}")) } } } From 6781f7683efc0e51abdf1325fbdc280b31ed2463 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Wed, 16 Oct 2024 09:12:33 -0400 Subject: [PATCH 14/15] Fixes & improvements --- .../inventory/caketracker/CakeTracker.kt | 132 ++++++++---------- 1 file changed, 61 insertions(+), 71 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index 7594c5098c7a..65b2df526816 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -19,6 +19,7 @@ import at.hannibal2.skyhanni.utils.LorenzUtils import at.hannibal2.skyhanni.utils.RegexUtils.matchMatcher import at.hannibal2.skyhanni.utils.RegexUtils.matches import at.hannibal2.skyhanni.utils.RenderUtils.highlight +import at.hannibal2.skyhanni.utils.SimpleTimeMark import at.hannibal2.skyhanni.utils.SkyBlockTime import at.hannibal2.skyhanni.utils.renderables.Renderable import at.hannibal2.skyhanni.utils.renderables.Searchable @@ -27,6 +28,7 @@ import at.hannibal2.skyhanni.utils.tracker.SkyHanniTracker import at.hannibal2.skyhanni.utils.tracker.TrackerData import com.google.gson.annotations.Expose import net.minecraftforge.fml.common.eventhandler.SubscribeEvent +import kotlin.time.Duration.Companion.milliseconds @SkyHanniModule object CakeTracker { @@ -37,7 +39,7 @@ object CakeTracker { private var inCakeBag = false private var inCakeInventory = false - private var timeOpenedCakeInventory: Long = 0 + private var timeOpenedCakeInventory = SimpleTimeMark.farPast() private var inAuctionHouse = false private var unobtainedCakesDisplayed = false private var searchingForCakes = false @@ -123,11 +125,7 @@ object CakeTracker { recalculateMissingCakes() } - private fun isEnabled(): Boolean { - if (!LorenzUtils.inSkyBlock) return false - if (!config.enabled) return false - return true - } + private fun isEnabled() = LorenzUtils.inSkyBlock && config.enabled @SubscribeEvent fun onBackgroundDraw(event: GuiRenderEvent.ChestGuiOverlayRenderEvent) { @@ -163,20 +161,13 @@ object CakeTracker { val inventoryName = event.inventoryName if (cakeContainerPattern.matches(inventoryName)) { if (cakeBagPattern.matches(inventoryName)) inCakeBag = true - val items = event.inventoryItems.filter { cakeNamePattern.matches(it.value.displayName) } - knownCakesInCurrentInventory = items.values.mapNotNull { item -> + knownCakesInCurrentInventory = event.inventoryItems.values.mapNotNull { item -> cakeNamePattern.matchMatcher(item.displayName) { group("year")?.toInt() } - }.toMutableList() - for (item in items) { - cakeNamePattern.matchMatcher(item.value.displayName) { - val cakeYearInt = group("year").toInt() - addCake(cakeYearInt) - } - } + }.toMutableList().onEach { year -> addCake(year) } inCakeInventory = true - timeOpenedCakeInventory = System.currentTimeMillis() + timeOpenedCakeInventory = SimpleTimeMark.now() tracker.firstUpdate() } if (auctionBrowserPattern.matches(inventoryName)) { @@ -198,15 +189,16 @@ object CakeTracker { @SubscribeEvent fun onSecondPassed(event: SecondPassedEvent) { if (!isEnabled()) return - if (currentYear == SkyBlockTime.now().year) return - if (SkyBlockTime.now().monthName == "Late Winter" && SkyBlockTime.now().day >= 29) { - currentYear = SkyBlockTime.now().year + val sbTimeNow = SkyBlockTime.now() + if (currentYear == sbTimeNow.year) return + if (sbTimeNow.month == 12 && sbTimeNow.day >= 29) { + currentYear = sbTimeNow.year recalculateMissingCakes() - } else currentYear = SkyBlockTime.now().year - 1 + } else currentYear = sbTimeNow.year - 1 } private fun checkInventoryCakes() { - if (System.currentTimeMillis() - timeOpenedCakeInventory >= 500) { + if (timeOpenedCakeInventory.passedSince() >= 500.milliseconds) { val currentYears = InventoryUtils.getItemsInOpenChest().mapNotNull { item -> cakeNamePattern.matchMatcher(item.stack.displayName) { group("year")?.toInt() @@ -251,33 +243,32 @@ object CakeTracker { tracker.update() } - private fun buildDisplayTypeToggle(): Renderable { - val displayToggleRenderables = mutableListOf() - val ownedString = - if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "§7§l[§r §a§nOwned§r §7§l]" - else "§aOwned" - val missingString = - if (config.displayType == CakeTrackerDisplayType.MISSING_CAKES) "§7§l[§r §c§nMissing§r §7§l]" - else "§cMissing" - - displayToggleRenderables.add( - Renderable.optionalLink( - ownedString, - { setDisplayType(CakeTrackerDisplayType.OWNED_CAKES) }, - condition = { config.displayType != CakeTrackerDisplayType.OWNED_CAKES }, + private fun buildDisplayTypeToggle(): Renderable = Renderable.horizontalContainer( + buildList { + val ownedString = + if (config.displayType == CakeTrackerDisplayType.OWNED_CAKES) "§7§l[§r §a§nOwned§r §7§l]" + else "§aOwned" + val missingString = + if (config.displayType == CakeTrackerDisplayType.MISSING_CAKES) "§7§l[§r §c§nMissing§r §7§l]" + else "§cMissing" + + add( + Renderable.optionalLink( + ownedString, + { setDisplayType(CakeTrackerDisplayType.OWNED_CAKES) }, + condition = { config.displayType != CakeTrackerDisplayType.OWNED_CAKES }, + ) ) - ) - displayToggleRenderables.add(Renderable.string(" §7§l- §r")) - displayToggleRenderables.add( - Renderable.optionalLink( - missingString, - { setDisplayType(CakeTrackerDisplayType.MISSING_CAKES) }, - condition = { config.displayType != CakeTrackerDisplayType.MISSING_CAKES }, + add(Renderable.string(" §7§l- §r")) + add( + Renderable.optionalLink( + missingString, + { setDisplayType(CakeTrackerDisplayType.MISSING_CAKES) }, + condition = { config.displayType != CakeTrackerDisplayType.MISSING_CAKES }, + ) ) - ) - - return Renderable.horizontalContainer(displayToggleRenderables) - } + } + ) private fun setDisplayOrderType(type: CakeTrackerDisplayOrderType) { val cakeTrackerData = getCakeTrackerData() ?: return @@ -286,33 +277,32 @@ object CakeTracker { tracker.update() } - private fun buildOrderTypeToggle(): Renderable { - val displayOrderToggleRenderables = mutableListOf() - val newestString = - if (config.displayOrderType == CakeTrackerDisplayOrderType.NEWEST_FIRST) "§7§l[§r §a§nNewest First§r §7§l]" - else "§aNewest First" - val oldestString = - if (config.displayOrderType == CakeTrackerDisplayOrderType.OLDEST_FIRST) "§7§l[§r §c§nOldest First§r §7§l]" - else "§cOldest First" - - displayOrderToggleRenderables.add( - Renderable.optionalLink( - newestString, - { setDisplayOrderType(CakeTrackerDisplayOrderType.NEWEST_FIRST) }, - condition = { config.displayOrderType != CakeTrackerDisplayOrderType.NEWEST_FIRST }, + private fun buildOrderTypeToggle(): Renderable = Renderable.horizontalContainer( + buildList { + val newestString = + if (config.displayOrderType == CakeTrackerDisplayOrderType.NEWEST_FIRST) "§7§l[§r §a§nNewest First§r §7§l]" + else "§aNewest First" + val oldestString = + if (config.displayOrderType == CakeTrackerDisplayOrderType.OLDEST_FIRST) "§7§l[§r §c§nOldest First§r §7§l]" + else "§cOldest First" + + add( + Renderable.optionalLink( + newestString, + { setDisplayOrderType(CakeTrackerDisplayOrderType.NEWEST_FIRST) }, + condition = { config.displayOrderType != CakeTrackerDisplayOrderType.NEWEST_FIRST }, + ) ) - ) - displayOrderToggleRenderables.add(Renderable.string(" §7§l- §r")) - displayOrderToggleRenderables.add( - Renderable.optionalLink( - oldestString, - { setDisplayOrderType(CakeTrackerDisplayOrderType.OLDEST_FIRST) }, - condition = { config.displayOrderType != CakeTrackerDisplayOrderType.OLDEST_FIRST }, + add(Renderable.string(" §7§l- §r")) + add( + Renderable.optionalLink( + oldestString, + { setDisplayOrderType(CakeTrackerDisplayOrderType.OLDEST_FIRST) }, + condition = { config.displayOrderType != CakeTrackerDisplayOrderType.OLDEST_FIRST }, + ) ) - ) - - return Renderable.horizontalContainer(displayOrderToggleRenderables) - } + } + ) private fun drawDisplay(data: Data): List = buildList { add( From f1cf754313781263bbe5c9008fe1738e6c713618 Mon Sep 17 00:00:00 2001 From: David Cole <40234707+DavidArthurCole@users.noreply.github.com> Date: Wed, 16 Oct 2024 09:43:34 -0400 Subject: [PATCH 15/15] More fixes --- .../inventory/caketracker/CakeTracker.kt | 53 +++++++++++-------- 1 file changed, 32 insertions(+), 21 deletions(-) diff --git a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt index 65b2df526816..861e089b6f70 100644 --- a/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt +++ b/src/main/java/at/hannibal2/skyhanni/features/inventory/caketracker/CakeTracker.kt @@ -16,6 +16,8 @@ import at.hannibal2.skyhanni.utils.ColorUtils.toChromaColor import at.hannibal2.skyhanni.utils.HypixelCommands import at.hannibal2.skyhanni.utils.InventoryUtils import at.hannibal2.skyhanni.utils.LorenzUtils +import at.hannibal2.skyhanni.utils.NumberUtil.formatInt +import at.hannibal2.skyhanni.utils.RegexUtils.groupOrNull import at.hannibal2.skyhanni.utils.RegexUtils.matchMatcher import at.hannibal2.skyhanni.utils.RegexUtils.matches import at.hannibal2.skyhanni.utils.RenderUtils.highlight @@ -140,11 +142,11 @@ object CakeTracker { if (!isEnabled()) return if (inAuctionHouse) { unobtainedCakesDisplayed = getCakeTrackerData()?.let { data -> - InventoryUtils.getItemsInOpenChest().filter { - cakeNamePattern.matches(it.stack.displayName) - }.onEach { cakeItem -> + InventoryUtils.getItemsInOpenChest().onEach { cakeItem -> cakeNamePattern.matchMatcher(cakeItem.stack.displayName) { - group("year").toInt().takeIf { it !in data.cakesOwned }?.let { + group("year").toInt().takeIf { + it !in data.cakesOwned + }?.let { cakeItem highlight config.auctionHighlightColor.toChromaColor() } } @@ -163,9 +165,12 @@ object CakeTracker { if (cakeBagPattern.matches(inventoryName)) inCakeBag = true knownCakesInCurrentInventory = event.inventoryItems.values.mapNotNull { item -> cakeNamePattern.matchMatcher(item.displayName) { - group("year")?.toInt() + groupOrNull("year")?.formatInt()?.let { + addCake(it) + it + } } - }.toMutableList().onEach { year -> addCake(year) } + }.toMutableList() inCakeInventory = true timeOpenedCakeInventory = SimpleTimeMark.now() tracker.firstUpdate() @@ -198,37 +203,43 @@ object CakeTracker { } private fun checkInventoryCakes() { - if (timeOpenedCakeInventory.passedSince() >= 500.milliseconds) { - val currentYears = InventoryUtils.getItemsInOpenChest().mapNotNull { item -> - cakeNamePattern.matchMatcher(item.stack.displayName) { - group("year")?.toInt() - } + if (timeOpenedCakeInventory.passedSince() < 500.milliseconds) return + val currentYears = InventoryUtils.getItemsInOpenChest().mapNotNull { item -> + cakeNamePattern.matchMatcher(item.stack.displayName) { + group("year")?.toInt() } + } - val addedYears = currentYears.filter { it !in knownCakesInCurrentInventory } - val removedYears = knownCakesInCurrentInventory.filter { it !in currentYears } + val addedYears = currentYears.filter { it !in knownCakesInCurrentInventory } + val removedYears = knownCakesInCurrentInventory.filter { it !in currentYears } - addedYears.forEach(::addCake) - removedYears.forEach(::removeCake) + addedYears.forEach(::addCake) + removedYears.forEach(::removeCake) - if (addedYears.isNotEmpty() || removedYears.isNotEmpty()) { - knownCakesInCurrentInventory = currentYears.toMutableList() - } + if (addedYears.isNotEmpty() || removedYears.isNotEmpty()) { + knownCakesInCurrentInventory = currentYears.toMutableList() } } private fun recalculateMissingCakes() { val cakeTrackerData = getCakeTrackerData() ?: return tracker.modify { - it.cakesMissing = (1..currentYear).filterNot { year -> cakeTrackerData.cakesOwned.contains(year) }.toMutableList() + it.cakesMissing = (1..currentYear).filterNot { + year -> cakeTrackerData.cakesOwned.contains(year) + }.toMutableList() } } private class CakeRange(var start: Int, var end: Int = 0) { fun getRenderable(displayType: CakeTrackerDisplayType): Renderable { - val colorCode = if (displayType == CakeTrackerDisplayType.OWNED_CAKES) "§a" else "§c" + val colorCode = + if (displayType == CakeTrackerDisplayType.OWNED_CAKES) "§a" + else "§c" val stringRenderable = - Renderable.string(if (end != 0) "§fYears $colorCode$start§f-$colorCode$end" else "§fYear $colorCode$start") + Renderable.string( + if (end != 0) "§fYears $colorCode$start§f-$colorCode$end" + else "§fYear $colorCode$start" + ) return if (displayType == CakeTrackerDisplayType.MISSING_CAKES) Renderable.link( stringRenderable, { HypixelCommands.auctionHouseSearch("New Year Cake (Year $start)") },