Feature: Reforge helper

src/main/java/at/hannibal2/skyhanni/api/ReforgeAPI.kt

@@ -0,0 +1,198 @@
+package at.hannibal2.skyhanni.api
+
+import at.hannibal2.skyhanni.data.jsonobjects.repo.neu.NeuReforgeJson
+import at.hannibal2.skyhanni.data.model.SkyblockStat
+import at.hannibal2.skyhanni.data.model.SkyblockStatList
+import at.hannibal2.skyhanni.events.NeuRepositoryReloadEvent
+import at.hannibal2.skyhanni.skyhannimodule.SkyHanniModule
+import at.hannibal2.skyhanni.utils.ItemCategory
+import at.hannibal2.skyhanni.utils.ItemUtils.getInternalName
+import at.hannibal2.skyhanni.utils.ItemUtils.getItemCategoryOrNull
+import at.hannibal2.skyhanni.utils.ItemUtils.itemNameWithoutColor
+import at.hannibal2.skyhanni.utils.LorenzRarity
+import at.hannibal2.skyhanni.utils.LorenzUtils
+import at.hannibal2.skyhanni.utils.NEUInternalName
+import at.hannibal2.skyhanni.utils.json.BaseGsonBuilder
+import at.hannibal2.skyhanni.utils.json.SkyHanniTypeAdapters
+import com.google.gson.Gson
+import com.google.gson.TypeAdapter
+import com.google.gson.stream.JsonReader
+import com.google.gson.stream.JsonWriter
+import net.minecraft.item.ItemStack
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
+
+@SkyHanniModule
+object ReforgeAPI {
+    var reforgeList: List<Reforge> = emptyList()
+        private set(value) {
+            field = value
+            nonePowerStoneReforge = value.filterNot { it.isReforgeStone }
+            onlyPowerStoneReforge = value.filter { it.isReforgeStone }
+        }
+
+    var nonePowerStoneReforge: List<Reforge> = emptyList()
+        private set
+
+    var onlyPowerStoneReforge: List<Reforge> = emptyList()
+        private set
+
+    enum class ReforgeType {
+        SWORD,
+        BOW,
+        ARMOR,
+        CHESTPLATE,
+        HELMET,
+        CLOAK,
+        AXE,
+        HOE,
+        AXE_AND_HOE,
+        PICKAXE,
+        EQUIPMENT,
+        ROD,
+        SWORD_AND_ROD,
+        SPECIAL_ITEMS,
+        VACUUM
+    }
+
+    class Reforge(
+        val name: String,
+        val type: ReforgeType,
+        val stats: Map<LorenzRarity, SkyblockStatList>,
+        val reforgeStone: NEUInternalName? = null,
+        val specialItems: List<NEUInternalName>? = null,
+        val extraProperty: Map<LorenzRarity, String> = emptyMap(),
+        val costs: Map<LorenzRarity, Long>? = null,
+    ) {
+
+        val isReforgeStone = reforgeStone != null
+
+        val rawReforgeStoneName = reforgeStone?.itemNameWithoutColor
+
+        val lowercaseName = name.lowercase()
+
+        fun isValid(itemStack: ItemStack) = isValid(itemStack.getItemCategoryOrNull(), itemStack.getInternalName())
+
+        fun isValid(itemCategory: ItemCategory?, internalName: NEUInternalName) = when (type) {
+            ReforgeType.SWORD -> setOf(
+                ItemCategory.SWORD,
+                ItemCategory.GAUNTLET,
+                ItemCategory.LONGSWORD,
+                ItemCategory.FISHING_WEAPON,
+            ).contains(itemCategory)
+
+            ReforgeType.BOW -> itemCategory == ItemCategory.BOW || itemCategory == ItemCategory.SHORT_BOW
+            ReforgeType.ARMOR -> setOf(
+                ItemCategory.HELMET,
+                ItemCategory.CHESTPLATE,
+                ItemCategory.LEGGINGS,
+                ItemCategory.BOOTS,
+            ).contains(itemCategory)
+
+            ReforgeType.CHESTPLATE -> itemCategory == ItemCategory.CHESTPLATE
+            ReforgeType.HELMET -> itemCategory == ItemCategory.HELMET
+            ReforgeType.CLOAK -> itemCategory == ItemCategory.CLOAK
+            ReforgeType.AXE -> itemCategory == ItemCategory.AXE
+            ReforgeType.HOE -> itemCategory == ItemCategory.HOE
+            ReforgeType.AXE_AND_HOE -> itemCategory == ItemCategory.HOE || itemCategory == ItemCategory.AXE
+            ReforgeType.PICKAXE ->
+                itemCategory == ItemCategory.PICKAXE ||
+                    itemCategory == ItemCategory.DRILL ||
+                    itemCategory == ItemCategory.GAUNTLET
+
+            ReforgeType.EQUIPMENT -> setOf(
+                ItemCategory.CLOAK,
+                ItemCategory.BELT,
+                ItemCategory.NECKLACE,
+                ItemCategory.BRACELET,
+                ItemCategory.GLOVES,
+            ).contains(itemCategory)
+
+            ReforgeType.ROD -> itemCategory == ItemCategory.FISHING_ROD || itemCategory == ItemCategory.FISHING_WEAPON
+            ReforgeType.SWORD_AND_ROD -> setOf(
+                ItemCategory.SWORD,
+                ItemCategory.GAUNTLET,
+                ItemCategory.LONGSWORD,
+                ItemCategory.FISHING_ROD,
+                ItemCategory.FISHING_WEAPON,
+            ).contains(itemCategory)
+
+            ReforgeType.VACUUM -> itemCategory == ItemCategory.VACUUM
+            ReforgeType.SPECIAL_ITEMS -> specialItems?.contains(internalName) ?: false
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (javaClass != other?.javaClass) return false
+
+            other as Reforge
+
+            if (name != other.name) return false
+            if (type != other.type) return false
+            if (stats != other.stats) return false
+            if (reforgeStone != other.reforgeStone) return false
+            if (specialItems != other.specialItems) return false
+            if (extraProperty != other.extraProperty) return false
+
+            return true
+        }
+
+        override fun hashCode(): Int {
+            var result = name.hashCode()
+            result = 31 * result + type.hashCode()
+            result = 31 * result + stats.hashCode()
+            result = 31 * result + (reforgeStone?.hashCode() ?: 0)
+            result = 31 * result + (specialItems?.hashCode() ?: 0)
+            result = 31 * result + extraProperty.hashCode()
+            return result
+        }
+
+        override fun toString(): String = "Reforge $name"
+    }
+
+    @SubscribeEvent
+    fun onNeuRepoReload(event: NeuRepositoryReloadEvent) {
+        val reforgeStoneData = event.readConstant<Map<String, NeuReforgeJson>>("reforgestones", reforgeGson).values
+        val reforgeData = event.readConstant<Map<String, NeuReforgeJson>>("reforges", reforgeGson).values
+        reforgeList = (reforgeStoneData + reforgeData).map(::mapReforge)
+    }
+
+    private val reforgeGson: Gson = BaseGsonBuilder.gson()
+        .registerTypeAdapter(SkyblockStat::class.java, SkyHanniTypeAdapters.SKYBLOCK_STAT.nullSafe())
+        .registerTypeAdapter(
+            SkyblockStatList::class.java,
+            object : TypeAdapter<SkyblockStatList>() {
+                override fun write(out: JsonWriter, value: SkyblockStatList) {
+                    out.beginObject()
+                    value.entries.forEach {
+                        out.name(it.key.name.lowercase()).value(it.value)
+                    }
+                    out.endObject()
+                }
+
+                override fun read(reader: JsonReader): SkyblockStatList {
+                    reader.beginObject()
+                    val list = SkyblockStatList()
+                    while (reader.hasNext()) {
+                        val name = reader.nextName()
+                        val value = reader.nextDouble()
+                        list[SkyblockStat.valueOf(name.uppercase())] = value
+                    }
+                    reader.endObject()
+                    return list
+                }
+            },
+        ).create()
+
+    private fun mapReforge(it: NeuReforgeJson): Reforge {
+        val type = it.itemType
+        return Reforge(
+            name = it.reforgeName,
+            type = LorenzUtils.enumValueOf<ReforgeType>(type.first),
+            stats = it.reforgeStats ?: emptyMap(),
+            reforgeStone = it.internalName,
+            specialItems = type.second.takeIf { it.isNotEmpty() },
+            extraProperty = it.reforgeAbility,
+            costs = it.reforgeCosts,
+        )
+    }
+}

src/main/java/at/hannibal2/skyhanni/config/features/inventory/helper/HelperConfig.java

@@ -52,6 +52,11 @@ public static class HarpConfig {
     @Accordion
     public TiaRelayConfig tiaRelay = new TiaRelayConfig();
 
+    @Expose
+    @ConfigOption(name = "Reforge Helper", desc = "")
+    @Accordion
+    public ReforgeHelperConfig reforge = new ReforgeHelperConfig();
+
     @Expose
     @ConfigOption(name = "Enchanting", desc = "")
     @Accordion

src/main/java/at/hannibal2/skyhanni/config/features/inventory/helper/ReforgeHelperConfig.java

@@ -0,0 +1,36 @@
+package at.hannibal2.skyhanni.config.features.inventory.helper;
+
+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 ReforgeHelperConfig {
+
+    @Expose
+    @ConfigLink(owner = ReforgeHelperConfig.class, field = "enabled")
+    public Position position = new Position(80, 85, true, true);
+
+    @Expose
+    @ConfigOption(name = "Enable", desc = "Enables the reforge helper.")
+    @ConfigEditorBoolean
+    @FeatureToggle
+    public boolean enabled = true;
+
+    @Expose
+    @ConfigOption(name = "Stones Hex Only", desc = "Displays reforge stones only when in Hex.")
+    @ConfigEditorBoolean
+    public boolean reforgeStonesOnlyHex = true;
+
+    @Expose
+    @ConfigOption(name = "Show Diff", desc = "Shows the difference of the new reforge to the current one in the slecetion list.")
+    @ConfigEditorBoolean
+    public boolean showDiff = false;
+
+    @Expose
+    @ConfigOption(name = "Hide chat", desc = "Hides the vanilla chat messages from reforging.")
+    @ConfigEditorBoolean
+    public boolean hideChat = false;
+}

src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/neu/NeuReforgeStoneJson.kt → src/main/java/at/hannibal2/skyhanni/data/jsonobjects/repo/neu/NeuReforgeJson.kt

@@ -1,21 +1,26 @@
 package at.hannibal2.skyhanni.data.jsonobjects.repo.neu
 
+import at.hannibal2.skyhanni.data.model.SkyblockStatList
 import at.hannibal2.skyhanni.utils.LorenzRarity
 import at.hannibal2.skyhanni.utils.NEUInternalName
+import at.hannibal2.skyhanni.utils.NEUInternalName.Companion.asInternalName
+import at.hannibal2.skyhanni.utils.NEUItems
 import com.google.gson.annotations.Expose
 import com.google.gson.annotations.SerializedName
+import net.minecraft.item.Item
 
-data class NeuReforgeStoneJson(
-    @Expose val internalName: NEUInternalName,
+data class NeuReforgeJson(
+    @Expose val internalName: NEUInternalName?,
     @Expose val reforgeName: String,
     @Expose @SerializedName("itemTypes") val rawItemTypes: Any,
     @Expose val requiredRarities: List<LorenzRarity>,
-    @Expose val reforgeCosts: Map<LorenzRarity, Long>,
-    @Expose val reforgeStats: Map<LorenzRarity, Map<String, Double>>,
+    @Expose val reforgeCosts: Map<LorenzRarity, Long>?,
+    @Expose val reforgeStats: Map<LorenzRarity, SkyblockStatList>?,
     @Expose @SerializedName("reforgeAbility") val rawReforgeAbility: Any?,
 ) {
 
     private lateinit var reforgeAbilityField: Map<LorenzRarity, String>
+    private lateinit var itemTypeField: Pair<String, List<NEUInternalName>>
 
     val reforgeAbility
         get() = if (this::reforgeAbilityField.isInitialized) reforgeAbilityField
@@ -27,7 +32,7 @@ data class NeuReforgeStoneJson(
 
                 is Map<*, *> -> (this.rawReforgeAbility as? Map<String, String>)?.mapKeys {
                     LorenzRarity.valueOf(
-                        it.key.uppercase().replace(" ", "_")
+                        it.key.uppercase().replace(" ", "_"),
                     )
                 } ?: emptyMap()
 
@@ -36,28 +41,27 @@ data class NeuReforgeStoneJson(
             reforgeAbilityField
         }
 
-    /* used in ReforgeAPI which isn't in beta yet
-        val itemType: Pair<String, List<NEUInternalName>> by lazy {
+    val itemType: Pair<String, List<NEUInternalName>>
+        get() = if (this::itemTypeField.isInitialized) itemTypeField
+        else run {
             val any = this.rawItemTypes
-            return@lazy when (any) {
+            return when (any) {
                 is String -> {
                     any.replace("/", "_AND_").uppercase() to emptyList()
                 }
 
                 is Map<*, *> -> {
                     val type = "SPECIAL_ITEMS"
-                    val map = any as? Map<String, List<String>> ?: return@lazy type to emptyList()
+                    val map = any as? Map<String, List<String>> ?: return type to emptyList()
                     val internalNames = map["internalName"]?.map { it.asInternalName() } ?: emptyList()
                     val itemType = map["itemid"]?.map {
                         NEUItems.getInternalNamesForItemId(Item.getByNameOrId(it))
-                    }?.flatten()
-                        ?: emptyList()
+                    }?.flatten() ?: emptyList()
                     type to (internalNames + itemType)
                 }
 
                 else -> throw IllegalStateException()
             }
         }
-*/
 }