feat: dungeon breaker charges display

build.gradle.kts

@@ -1,6 +1,7 @@
 @file:Suppress("UnstableApiUsage")
 
-import org.gradle.kotlin.dsl.withType
+import org.gradle.internal.impldep.org.junit.experimental.categories.Categories.CategoryFilter.exclude
+import org.gradle.kotlin.dsl.modImplementation
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
@@ -25,6 +26,12 @@ repositories {
     mavenCentral()
 }
 
+configurations {
+    modImplementation {
+        attributes.attribute(Attribute.of("earth.terrarium.cloche.modLoader", String::class.java), "fabric")
+    }
+}
+
 dependencies {
     attributesSchema {
         attribute(Attribute.of("earth.terrarium.cloche.minecraftVersion", String::class.java)) {
@@ -41,22 +48,16 @@ dependencies {
             artifactType("zip")
         })
     })
-    modImplementation(libs.skyblockapi)
-    include(libs.skyblockapi)
-    modImplementation(libs.meowdding.lib)
-    include(libs.meowdding.lib)
-    modImplementation(versionedCatalog["placeholders"])
-    include(versionedCatalog["placeholders"])
+    includeImplementation(libs.skyblockapi)
+    includeImplementation(libs.meowdding.lib)
+    includeImplementation(versionedCatalog["placeholders"])
     modImplementation(libs.fabric.loader)
     modImplementation(libs.repo.lib)
     modImplementation(libs.fabric.language.kotlin)
     modImplementation(versionedCatalog["fabric.api"])
-    modImplementation(versionedCatalog["resourceful.lib"])
-    include(versionedCatalog["resourceful.lib"])
-    modImplementation(versionedCatalog["resourceful.config"])
-    include(versionedCatalog["resourceful.config"])
-    modImplementation(libs.resourceful.config.kotlin)
-    include(libs.resourceful.config.kotlin)
+    includeImplementation(versionedCatalog["resourceful.lib"])
+    includeImplementation(versionedCatalog["resourceful.config"])
+    includeImplementation(libs.resourceful.config.kotlin)
     compileOnly(libs.meowdding.ktmodules)
     compileOnly(libs.meowdding.ktcodecs)
     ksp(libs.meowdding.ktmodules)
@@ -65,6 +66,11 @@ dependencies {
     modRuntimeOnly(libs.devauth)
 }
 
+fun DependencyHandler.includeImplementation(dep: Any) {
+    include(dep)
+    modImplementation(dep)
+}
+
 val mcVersion = stonecutter.current.version.replace(".", "")
 loom {
     runConfigs["client"].apply {

gradle/libs.versions.toml

@@ -3,7 +3,7 @@
 fabric-loader = "0.17.3"
 fabric-language-kotlin = "1.13.6+kotlin.2.2.20"
 
-skyblockapi = "3.0.10"
+skyblockapi = "3.0.16"
 repo-lib = "3.0.2"
 devauth = "1.2.1"
 

src/main/kotlin/me/owdding/mortem/Mortem.kt

@@ -4,14 +4,18 @@ import me.owdding.ktmodules.Module
 import me.owdding.lib.utils.MeowddingLogger
 import me.owdding.mortem.generated.MortemModules
 import net.fabricmc.api.ClientModInitializer
+import net.fabricmc.loader.api.FabricLoader
 import net.minecraft.resources.ResourceLocation
 import org.intellij.lang.annotations.Pattern
 import tech.thatgravyboat.skyblockapi.api.SkyBlockAPI
 
 @Module
 object Mortem : ClientModInitializer, MeowddingLogger by MeowddingLogger.autoResolve() {
 
-    const val MOD_ID = "mortem"
+    val SELF = FabricLoader.getInstance().getModContainer("mortem").get()
+    val MOD_ID: String = SELF.metadata.id
+    val VERSION: String = SELF.metadata.version.friendlyString
+    const val DISCORD = "https://meowdd.ing/discord"
 
     override fun onInitializeClient() {
         info("MortemModules client initialized!")

src/main/kotlin/me/owdding/mortem/config/Config.kt

@@ -0,0 +1,27 @@
+package me.owdding.mortem.config
+
+import com.google.gson.JsonObject
+import com.teamresourceful.resourcefulconfig.api.types.info.ResourcefulConfigLink
+import com.teamresourceful.resourcefulconfig.api.types.options.TranslatableValue
+import com.teamresourceful.resourcefulconfigkt.api.ConfigKt
+import me.owdding.mortem.Mortem
+import me.owdding.mortem.config.category.OverlayConfig
+import me.owdding.mortem.config.category.OverlayPositions
+import java.util.function.UnaryOperator
+
+object Config : ConfigKt("mortem/config") {
+
+    override val name: TranslatableValue = TranslatableValue("Mortem")
+    override val description: TranslatableValue = TranslatableValue("Mortem (${Mortem.VERSION})")
+    override val links: Array<ResourcefulConfigLink> = emptyArray()
+
+    init {
+        category(OverlayConfig)
+
+        category(OverlayPositions)
+    }
+
+
+    override val patches: Map<Int, UnaryOperator<JsonObject>> = emptyMap()
+    override val version: Int = patches.size + 1
+}

src/main/kotlin/me/owdding/mortem/config/ConfigManager.kt

@@ -0,0 +1,31 @@
+package me.owdding.mortem.config
+
+import com.teamresourceful.resourcefulconfig.api.client.ResourcefulConfigScreen
+import com.teamresourceful.resourcefulconfig.api.loader.Configurator
+import me.owdding.ktmodules.Module
+import me.owdding.lib.overlays.EditOverlaysScreen
+import me.owdding.mortem.Mortem
+import tech.thatgravyboat.skyblockapi.api.events.base.Subscription
+import tech.thatgravyboat.skyblockapi.api.events.misc.RegisterCommandsEvent
+import tech.thatgravyboat.skyblockapi.helpers.McClient
+
+@Module
+object ConfigManager {
+
+    private val configurator = Configurator(Mortem.MOD_ID)
+    val config = Config.register(configurator)
+
+    fun save() = config.save()
+    fun openConfig() = McClient.setScreenAsync { ResourcefulConfigScreen.getFactory(Mortem.MOD_ID).apply(null) }
+
+    @Subscription
+    fun onCommand(event: RegisterCommandsEvent) {
+        event.register("mortem") {
+            thenCallback("overlays") {
+                McClient.setScreenAsync { EditOverlaysScreen(Mortem.MOD_ID) }
+            }
+
+            callback { openConfig() }
+        }
+    }
+}

src/main/kotlin/me/owdding/mortem/config/category/OverlayConfig.kt

@@ -0,0 +1,18 @@
+package me.owdding.mortem.config.category
+
+import com.teamresourceful.resourcefulconfigkt.api.CategoryKt
+import me.owdding.lib.overlays.ConfigPosition
+
+object OverlayConfig  : CategoryKt("overlays") {
+    override val name = Translated("mortem.config.overlays")
+
+    var dungeonBreakerOverlay by boolean(true) {
+        translation = "mortem.config.overlays.dungeon_breaker_overlay"
+    }
+}
+
+object OverlayPositions : CategoryKt("overlaysPositions") {
+    override val hidden: Boolean = true
+
+    val dungeonBreaker by obj(ConfigPosition(100, 200))
+}

src/main/kotlin/me/owdding/mortem/features/DungeonBreakerDisplay.kt

@@ -0,0 +1,66 @@
+package me.owdding.mortem.features
+
+import me.owdding.ktmodules.Module
+import me.owdding.lib.overlays.Position
+import me.owdding.mortem.config.category.OverlayConfig
+import me.owdding.mortem.config.category.OverlayPositions
+import me.owdding.mortem.utils.CachedValue
+import me.owdding.mortem.utils.MortemOverlay
+import me.owdding.mortem.utils.Overlay
+import me.owdding.mortem.utils.ticks
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.network.chat.Component
+import tech.thatgravyboat.skyblockapi.api.datatype.DataType
+import tech.thatgravyboat.skyblockapi.api.datatype.DataTypes
+import tech.thatgravyboat.skyblockapi.api.datatype.getData
+import tech.thatgravyboat.skyblockapi.api.location.SkyBlockIsland
+import tech.thatgravyboat.skyblockapi.helpers.McFont
+import tech.thatgravyboat.skyblockapi.helpers.McPlayer
+import tech.thatgravyboat.skyblockapi.platform.drawString
+import tech.thatgravyboat.skyblockapi.utils.extentions.getRawLore
+import tech.thatgravyboat.skyblockapi.utils.extentions.parseFormattedInt
+import tech.thatgravyboat.skyblockapi.utils.regex.RegexUtils.anyMatch
+import tech.thatgravyboat.skyblockapi.utils.text.Text
+import tech.thatgravyboat.skyblockapi.utils.text.TextBuilder.append
+import tech.thatgravyboat.skyblockapi.utils.text.TextColor
+import tech.thatgravyboat.skyblockapi.utils.text.TextStyle.color
+
+@Module
+@Overlay
+object DungeonBreakerDisplay : MortemOverlay {
+
+    val regex = "Charges: (?<current>\\d+)/(?<max>\\d+)⸕".toRegex()
+
+    val BREAKER_CHARGES: DataType<Pair<Int, Int>> = DataType("breaking") {
+        if (DataTypes.ID.factory(it) != "DUNGEONBREAKER") return@DataType null
+
+        var output: Pair<Int, Int>? = null
+        regex.anyMatch(it.getRawLore(), "current", "max") { (current, max) ->
+            output = current.parseFormattedInt() to max.parseFormattedInt()
+        }
+        output
+    }
+    override val name: Component = Text.of("Dungeonbreaker Charges")
+    override val enabled: Boolean get() = OverlayConfig.dungeonBreakerOverlay && SkyBlockIsland.THE_CATACOMBS.inIsland()
+    override val position: Position = OverlayPositions.dungeonBreaker
+    override val bounds: Pair<Int, Int> get() = display.get()?.let { McFont.width(it) to McFont.height } ?: (0 to 0)
+
+    private val display = CachedValue(1.ticks) {
+        val (current, max) = McPlayer.inventory.firstNotNullOfOrNull { it.getData(BREAKER_CHARGES) } ?: return@CachedValue null
+
+        Text.of("Charges: ") {
+            color = TextColor.GRAY
+
+            append("$current") { color = TextColor.YELLOW }
+            append("/")
+            append("$max") { color = TextColor.YELLOW }
+            append("⸕") { color = TextColor.RED }
+        }
+    }
+
+    override fun render(graphics: GuiGraphics, mouseX: Int, mouseY: Int) {
+        val display = display.get() ?: return
+        graphics.drawString(display, 0, 0, shadow = true)
+    }
+
+}

src/main/kotlin/me/owdding/mortem/utils/CachedValue.kt

@@ -0,0 +1,32 @@
+package me.owdding.mortem.utils
+
+import kotlin.reflect.KProperty0
+import kotlin.reflect.jvm.isAccessible
+import kotlin.time.Duration
+
+class CachedValue<T>(private val cacheTime: Duration, private val supplier: () -> T) {
+
+    private var value: T? = null
+    private var lastUpdate: Long = 0
+
+    operator fun getValue(thisRef: Any?, property: Any?): T = get()
+
+    fun get(): T {
+        if (value == null || System.currentTimeMillis() - lastUpdate > cacheTime.inWholeMilliseconds) {
+            value = supplier()
+            lastUpdate = System.currentTimeMillis()
+        }
+        return value!!
+    }
+
+    fun invalidate() {
+        value = null
+    }
+
+    operator fun invoke(): T = get()
+}
+
+fun KProperty0<*>.invalidateCache() {
+    this.isAccessible = true
+    (this.getDelegate() as? CachedValue<*>)?.invalidate()
+}

src/main/kotlin/me/owdding/mortem/utils/Extensions.kt

@@ -0,0 +1,7 @@
+package me.owdding.mortem.utils
+
+import kotlin.time.Duration
+import kotlin.time.DurationUnit
+import kotlin.time.toDuration
+
+inline val Int.ticks: Duration get() = (this * 20).toDuration(DurationUnit.MILLISECONDS)

src/main/kotlin/me/owdding/mortem/utils/MortemOverlay.kt

@@ -0,0 +1,34 @@
+package me.owdding.mortem.utils
+
+import me.owdding.ktmodules.AutoCollect
+import me.owdding.ktmodules.Module
+import me.owdding.lib.events.overlay.FinishOverlayEditingEvent
+import me.owdding.lib.overlays.Overlay
+import me.owdding.lib.overlays.Overlays
+import me.owdding.mortem.Mortem
+import me.owdding.mortem.config.ConfigManager
+import me.owdding.mortem.generated.MortemOverlays
+import tech.thatgravyboat.skyblockapi.api.events.base.Subscription
+
+interface MortemOverlay : Overlay {
+    override val modId: String get() = Mortem.MOD_ID
+}
+
+@Module
+object MortemOverlaysHandler {
+    init {
+        MortemOverlays.collected.forEach { Overlays.register(it) }
+    }
+
+    @Subscription
+    fun finishEditing(event: FinishOverlayEditingEvent) {
+        if (event.modId == Mortem.MOD_ID) {
+            ConfigManager.save()
+        }
+    }
+}
+
+@AutoCollect("Overlays")
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Overlay