ability activation and utils

Author: mrsterner

Diff for: src/main/kotlin/dev/sterner/api/VoidBoundApi.kt

@@ -142,39 +142,63 @@ object VoidBoundApi {
         return false
     }
 
-    fun getItemAbility(stack: ItemStack): List<ItemAbility> {
-        val abilities = mutableListOf<ItemAbility>()
+    // Function to retrieve abilities from the ItemStack's NBT, returns a Set
+    fun getItemAbilities(stack: ItemStack): Set<ItemAbility> {
+        val abilities = mutableSetOf<ItemAbility>()
         val tag = stack.tag ?: return abilities // Return empty if no NBT
 
         val abilitiesTag = tag.getList("Abilities", 10) // 10 is the NBT type for CompoundTag
         for (i in 0 until abilitiesTag.size) {
             val abilityTag = abilitiesTag.getCompound(i)
             val ability = ItemAbility.readNbt(abilityTag)
-            abilities.add(ability)
+            abilities.add(ability) // Add to the set, prevents duplicates
         }
+
         return abilities
     }
 
-    // Function to add an ItemAbilityWithLevel to an ItemStack's NBT
-    fun addItemAbility(stack: ItemStack, abilityWithLevel: ItemAbility) {
+    // Function to add an ItemAbility to the ItemStack's NBT
+    fun addItemAbility(stack: ItemStack, ability: ItemAbility, makeActive: Boolean = false) {
         val tag = stack.orCreateTag // Ensures the stack has NBT
         val abilitiesTag = tag.getList("Abilities", 10) // Fetch or create list
 
-        // Check if ability already exists, if so, skip adding a duplicate
+        // Check if ability already exists, if so, exit
         for (i in 0 until abilitiesTag.size) {
             val abilityTag = abilitiesTag.getCompound(i)
             val existingAbility = ItemAbility.readNbt(abilityTag)
-            if (existingAbility == abilityWithLevel) {
+            if (existingAbility == ability) {
                 return // Ability already exists, exit without adding
             }
         }
 
         // Add new ability
-        abilitiesTag.add(abilityWithLevel.writeNbt())
+        abilitiesTag.add(ability.writeNbt())
         tag.put("Abilities", abilitiesTag)
+
+        // Optionally set the new ability as the active one
+        if (makeActive) {
+            setActiveAbility(stack, ability)
+        }
+    }
+
+    // Function to set the active ability in NBT
+    fun setActiveAbility(stack: ItemStack, ability: ItemAbility) {
+        val tag = stack.orCreateTag
+        val abilities = getItemAbilities(stack)
+
+        if (abilities.contains(ability)) {
+            // Store the active ability as a string in NBT
+            tag.putString("ActiveAbility", ability.name)
+        }
     }
 
-    fun hasItemAbility(stack: ItemStack, ability: ItemAbility): Boolean {
-        return !getItemAbility(stack).none { it == ability }
+    // Function to get the active ability from the ItemStack's NBT
+    fun getActiveAbility(stack: ItemStack): ItemAbility? {
+        val tag = stack.tag ?: return null
+        val activeAbilityName = tag.getString("ActiveAbility")
+
+        // Check if the active ability is one of the stored abilities
+        val abilities = getItemAbilities(stack)
+        return abilities.firstOrNull { it.name == activeAbilityName }
     }
 }

Diff for: src/main/kotlin/dev/sterner/client/screen/ItemAbilityScreen.kt

@@ -4,39 +4,44 @@ import com.mojang.blaze3d.systems.RenderSystem
 import dev.sterner.VoidBound
 import dev.sterner.api.VoidBoundApi
 import dev.sterner.api.item.ItemAbility
+import dev.sterner.networking.AbilityUpdatePacket
+import dev.sterner.registry.VoidBoundComponentRegistry
+import dev.sterner.registry.VoidBoundPacketRegistry
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.client.gui.screens.Screen
 import net.minecraft.network.chat.Component
 import net.minecraft.world.item.ItemStack
-import kotlin.math.max
 
 class ItemAbilityScreen(stack: ItemStack) : Screen(Component.literal("Ability Selection")) {
 
     var focus: Boolean = false
     private var yOffset = 0f
     private var selection: Int = 0
     private var initialized = false
-    var abilities: List<ItemAbility>? = null
+    var abilities: Set<ItemAbility>? = null
 
     private var w: Int = 0
     private var h: Int = 0
 
     init {
         this.minecraft = Minecraft.getInstance()
-        abilities = VoidBoundApi.getItemAbility(stack)
+
         focus = false
         yOffset = 0f
         selection = 0
         initialized = false
 
         w = 180
         h = 37
+        abilities = VoidBoundComponentRegistry.VOID_BOUND_REVELATION_COMPONENT.get(minecraft!!.player!!).unlockedItemAbilities
     }
 
     fun cycle(direction: Int) {
-        selection += if ((direction < 0)) 1 else -1
-        selection = (selection + abilities!!.size) % abilities!!.size
+        if (abilities!!.isNotEmpty()) {
+            selection += if ((direction < 0)) 1 else -1
+            selection = (selection + abilities!!.size) % abilities!!.size
+        }
     }
 
     fun update() {
@@ -49,7 +54,7 @@ class ItemAbilityScreen(stack: ItemStack) : Screen(Component.literal("Ability Se
 
     fun render(guiGraphics: GuiGraphics, partialTick: Float) {
 
-        if (abilities == null) {
+        if (abilities?.isEmpty() == true) {
             return
         }
 
@@ -59,7 +64,7 @@ class ItemAbilityScreen(stack: ItemStack) : Screen(Component.literal("Ability Se
         val y = mainWindow.guiScaledHeight - h + 20
 
         matrixStack.pushPose()
-        matrixStack.translate(0f, 20 - yOffset, (if (focus) 100 else 0).toFloat())
+        matrixStack.translate(0f, 20 - yOffset, -100f)
 
         val gray = VoidBound.id("textures/gui/ability_selection.png")
         RenderSystem.enableBlend()
@@ -82,39 +87,47 @@ class ItemAbilityScreen(stack: ItemStack) : Screen(Component.literal("Ability Se
 
         val startX = (mainWindow.guiScaledWidth - totalWidth) / 2
 
-        for (i in abilities!!.indices) {
+        for ((index, ability) in abilities!!.withIndex()) {  // Loop through the Set directly
             RenderSystem.enableBlend()
             matrixStack.pushPose()
 
             val alpha = if (focus) 1f else 0.2f
 
-            if (i == selection) {
-                matrixStack.translate(0f, -10f, 0f)
+            if (index == selection) {
+                matrixStack.translate(0f, -10f, 0f)  // Move selected ability
             } else {
-                matrixStack.translate(0f, -5f, 0f)
+                matrixStack.translate(0f, -5f, 0f)   // Move unselected abilities
             }
 
             RenderSystem.setShaderColor(1f, 1f, 1f, alpha)
 
-            val abilityX = startX + i * abilityWidth
+            val abilityX = startX + index * abilityWidth
 
-            if (i == selection) {
+            if (index == selection) {
                 guiGraphics.drawCenteredString(
                     minecraft!!.font,
-                    abilities!![i].name.lowercase().replaceFirstChar { it.uppercase() },
+                    ability.name.lowercase().replaceFirstChar { it.uppercase() }, // Access ability directly
                     abilityX + 24,
                     y + 32,
                     0xDDCCFF
                 )
             }
 
-            val texture = VoidBound.id("textures/gui/" + abilities!![i].name.lowercase() + ".png")
+            val texture = VoidBound.id("textures/gui/" + ability.name.lowercase() + ".png")
             guiGraphics.blit(texture, abilityX + 16, y + 16, 0, 0f, 0f, 16, 16, 16, 16)
 
             matrixStack.popPose()
+
+            // Increment index manually
         }
 
         RenderSystem.disableBlend()
         matrixStack.popPose()
     }
+
+    override fun onClose() {
+        if (Minecraft.getInstance().player != null && abilities!!.elementAtOrNull(selection) != null) {
+            VoidBoundPacketRegistry.VOID_BOUND_CHANNEL.sendToServer(AbilityUpdatePacket(Minecraft.getInstance().player!!.uuid, abilities!!.elementAt(selection)))
+        }
+    }
 }

Diff for: src/main/kotlin/dev/sterner/common/ItemAbilityHandler.kt

@@ -1,5 +1,6 @@
 package dev.sterner.common
 
+import dev.sterner.VoidBound
 import dev.sterner.api.item.ItemAbility
 import dev.sterner.client.screen.ItemAbilityScreen
 import net.minecraft.client.Minecraft
@@ -11,10 +12,14 @@ import org.lwjgl.glfw.GLFW
 
 class ItemAbilityHandler {
 
-    var selectionScreen: ItemAbilityScreen = ItemAbilityScreen(ItemStack.EMPTY)
+    var selectionScreen: ItemAbilityScreen? = null
     var currentAbility: ItemAbility? = ItemAbility.NONE
     var active: Boolean = false
 
+    init {
+        currentAbility = ItemAbility.NONE
+
+    }
 
     fun tick() {
         val mc = Minecraft.getInstance()
@@ -25,6 +30,9 @@ class ItemAbilityHandler {
             return
         }
         val player = mc.player
+        if (player != null && selectionScreen == null) {
+            selectionScreen = ItemAbilityScreen(player.mainHandItem)
+        }
         val stack = player?.mainHandItem
         if (stack == null) {
             active = false
@@ -35,15 +43,15 @@ class ItemAbilityHandler {
             return
         }
 
-        selectionScreen.update()
+        selectionScreen?.update()
     }
 
     fun render(graphics: GuiGraphics, partialTicks: Float, width: Int, height: Int) {
         if (Minecraft.getInstance().options.hideGui || !active) {
             return
         }
 
-        selectionScreen.render(graphics, partialTicks)
+        selectionScreen?.render(graphics, partialTicks)
     }
 
     private fun init(player: LocalPlayer?) {
@@ -59,12 +67,12 @@ class ItemAbilityHandler {
             return
         }
 
-        if (pressed && !selectionScreen.focus) {
-            selectionScreen.focus = true
+        if (pressed && selectionScreen?.focus != true) {
+            selectionScreen?.focus = true
         }
-        if (!pressed && selectionScreen.focus) {
-            selectionScreen.focus = false
-            selectionScreen.onClose()
+        if (!pressed && selectionScreen?.focus == true) {
+            selectionScreen!!.focus = false
+            selectionScreen!!.onClose()
         }
     }
 
@@ -73,8 +81,8 @@ class ItemAbilityHandler {
             return false
         }
 
-        if (selectionScreen.focus) {
-            selectionScreen.cycle(delta.toInt())
+        if (selectionScreen?.focus == true) {
+            selectionScreen?.cycle(delta.toInt())
             return true
         }
         return false

Diff for: src/main/kotlin/dev/sterner/common/VoidBoundLootModifier.kt

@@ -31,7 +31,7 @@ class VoidBoundLootModifier(conditionsIn: Array<out LootItemCondition>?) : LootM
     ): ObjectArrayList<ItemStack> {
 
         val stack = context?.getParamOrNull(LootContextParams.TOOL)
-        if (stack != null && VoidBoundApi.hasItemAbility(stack, ItemAbility.AUTOSMELT)) {
+        if (stack != null && VoidBoundApi.getActiveAbility(stack) == ItemAbility.AUTOSMELT) {
 
             val level = context.level
             val smeltedItems = generatedLoot?.asSequence()?.map { originalStack ->

Diff for: src/main/kotlin/dev/sterner/common/components/VoidBoundRevelationComponent.kt

@@ -2,6 +2,8 @@ package dev.sterner.common.components
 
 import dev.onyxstudios.cca.api.v3.component.sync.AutoSyncedComponent
 import dev.onyxstudios.cca.api.v3.component.tick.CommonTickingComponent
+import dev.sterner.api.VoidBoundApi
+import dev.sterner.api.item.ItemAbility
 import dev.sterner.registry.VoidBoundComponentRegistry
 import dev.sterner.registry.VoidBoundSoundEvents
 import net.minecraft.nbt.CompoundTag
@@ -15,6 +17,13 @@ class VoidBoundRevelationComponent(private val player: Player) : AutoSyncedCompo
 
     var thoughtsQueue: MutableMap<Component, ThoughtData> = mutableMapOf()
 
+    var unlockedItemAbilities = mutableSetOf<ItemAbility>(ItemAbility.VAMPIRISM, ItemAbility.AUTOSMELT)
+
+    fun addUnlockedItemAbility(ability: ItemAbility) {
+        unlockedItemAbilities.add(ability)
+        sync()
+    }
+
     override fun tick() {
         // Ensure the queue does not exceed 16 elements
         while (thoughtsQueue.size > 16) {
@@ -140,6 +149,15 @@ class VoidBoundRevelationComponent(private val player: Player) : AutoSyncedCompo
                 thoughtsQueue[thought] = ThoughtData(duration, delay)
             }
         }
+
+        unlockedItemAbilities.clear()
+        val unlockedList = tag.getList("UnlockedItems", 10)
+        for (i in 0 until unlockedList.size) {
+            val item = unlockedList.getCompound(i)
+            val itemAbility = ItemAbility.readNbt(item)
+            println("TT: $itemAbility")
+            unlockedItemAbilities.add(itemAbility)
+        }
     }
 
     override fun writeToNbt(tag: CompoundTag) {
@@ -164,5 +182,13 @@ class VoidBoundRevelationComponent(private val player: Player) : AutoSyncedCompo
             thoughtsList.add(thoughtTag)
         }
         tag.put("ThoughtsQueue", thoughtsList)
+
+        val unlockedList = ListTag()
+        unlockedItemAbilities.forEach { unlockedTag ->
+            println(unlockedTag)
+            val abilityTag = unlockedTag.writeNbt()
+            unlockedList.add(abilityTag)
+        }
+        tag.put("UnlockedItems", unlockedList)
     }
 }

Diff for: src/main/kotlin/dev/sterner/common/item/tool/ichor/IchoriumPickaxeItem.kt

@@ -1,9 +1,14 @@
 package dev.sterner.common.item.tool.ichor
 
+import dev.sterner.api.item.ItemAbility
 import dev.sterner.common.item.tool.CragbreakerItem
+import dev.sterner.registry.VoidBoundComponentRegistry
 import net.minecraft.ChatFormatting
 import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.Style
+import net.minecraft.world.InteractionHand
+import net.minecraft.world.InteractionResultHolder
+import net.minecraft.world.entity.player.Player
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.Tier
 import net.minecraft.world.item.TooltipFlag

Diff for: src/main/kotlin/dev/sterner/networking/AbilityUpdatePacket.kt

@@ -0,0 +1,38 @@
+package dev.sterner.networking
+
+import dev.sterner.api.VoidBoundApi
+import dev.sterner.api.item.ItemAbility
+import me.pepperbell.simplenetworking.SimpleChannel
+import net.fabricmc.fabric.api.networking.v1.PacketSender
+import net.minecraft.network.FriendlyByteBuf
+import net.minecraft.server.MinecraftServer
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.network.ServerGamePacketListenerImpl
+import team.lodestar.lodestone.systems.network.LodestoneServerPacket
+import java.util.UUID
+
+class AbilityUpdatePacket(val uuid: UUID, val itemAbility: ItemAbility) : LodestoneServerPacket() {
+
+    override fun encode(buf: FriendlyByteBuf) {
+        buf.writeUUID(uuid)
+        buf.writeUtf(itemAbility.name)
+    }
+
+    constructor(buf: FriendlyByteBuf) : this(buf.readUUID(), ItemAbility.valueOf(buf.readUtf()))
+
+
+    override fun executeServer(
+        server: MinecraftServer?,
+        player: ServerPlayer?,
+        listener: ServerGamePacketListenerImpl?,
+        responseSender: PacketSender?,
+        channel: SimpleChannel?
+    ) {
+        server?.execute {
+            if (player?.uuid == uuid) {
+                val item = player.mainHandItem
+                VoidBoundApi.addItemAbility(item, itemAbility, true)
+            }
+        }
+    }
+}