opening and final strike, no visuals yet

mrsterner · mrsterner · commit 5ac0dc695153 · 2024-09-16T16:55:37.000+02:00
diff --git a/src/main/kotlin/dev/sterner/common/components/VoidBoundPlayerItemAbilityComponent.kt b/src/main/kotlin/dev/sterner/common/components/VoidBoundPlayerItemAbilityComponent.kt
@@ -23,14 +23,18 @@ import team.lodestar.lodestone.registry.common.LodestoneAttributeRegistry
 class VoidBoundPlayerItemAbilityComponent(private val player: Player) : AutoSyncedComponent, CommonTickingComponent {
 
     private var vampirismCooldown: Int = 0
-    private var wrathCooldown: Int = 0
-    private val wrathCooldownMax = 20 * 60
+    private var wrathStackKiller: Int = 0
+    private val wrathStackKillerMax = 20 * 60
     private var finalStrike = false
     private val finalStrikeCooldownMax = 20 * 20
     private var finalStrikeDuration = 0
     private var wrathCounter = 0
 
-    fun tryUseVampirism(target: LivingEntity){
+    //VAMPIRISM start
+    /**
+     * If the cooldown is 0, perform Vamp, if vamp is successful, heal and play sound
+     */
+    fun tryUseVampirism(target: LivingEntity, amount: Float) : Float{
         if (vampirismCooldown <= 0) {
             val healing = performVampirism(target)
             if (healing > 0) {
@@ -40,8 +44,12 @@ class VoidBoundPlayerItemAbilityComponent(private val player: Player) : AutoSync
                 sync()
             }
         }
+        return amount
     }
 
+    /**
+     * Get amount of health to heal, healing is dependent on amount of spirits or a players armor value. Defaults at half a heart
+     */
     private fun performVampirism(target: LivingEntity): Int {
         var healing = 0
         if (target is Player) {
@@ -54,46 +62,79 @@ class VoidBoundPlayerItemAbilityComponent(private val player: Player) : AutoSync
                     healing += it.count
                 }
             } else {
-                healing += 2
+                healing += 1
             }
         }
 
         return healing
     }
 
+    //VAMPIRISM end
+
+    //OPENER - FINALE start
+
+    /**
+     * If final strike is not active, increase the wrath counter and start the cooldown
+     */
     fun increaseWrath() {
         if (!finalStrike) {
             wrathCounter++
-            wrathCooldown = wrathCooldownMax
+            wrathStackKiller = wrathStackKillerMax
         }
         sync()
     }
 
-    override fun readFromNbt(tag: CompoundTag) {
-        vampirismCooldown = tag.getInt("vampirismCooldown")
-        wrathCooldown = tag.getInt("wrathCooldown")
-        wrathCounter = tag.getInt("wrathCounter")
-        finalStrike = tag.getBoolean("finalStrike")
+    /**
+     * if wrath is not maxed out and target has more than 95% health, increase wrath and increase the damage
+     */
+    fun tryUseOpener(target: LivingEntity, amount: Float) : Float {
+        var outDamage = amount
+        if (wrathCounter < 10 && target.health / target.maxHealth > 0.95) {
+            increaseWrath()
+            outDamage *= 1.2f
+        }
+        return outDamage
     }
 
-    override fun writeToNbt(tag: CompoundTag) {
-        tag.putInt("vampirismCooldown", vampirismCooldown)
-        tag.putInt("wrathCooldown", wrathCooldown)
-        tag.putInt("wrathCounter", wrathCounter)
-        tag.putBoolean("finalStrike", finalStrike)
+    /**
+     * if final strike is active, multiply output damage with wrath and reset
+     */
+    fun tryUseFinale(entity: LivingEntity?, amount: Float): Float {
+        var outAmount = amount
+        if (finalStrike) {
+            finalStrike = false
+            outAmount *= (wrathCounter / 2)
+            wrathCounter = 0
+        }
+        return outAmount
     }
 
+    //OPENER - FINALE end
+
     override fun tick() {
+        //Count down vampirism only when vampirism ability is selected
         if (vampirismCooldown > 0 && VoidBoundItemUtils.getActiveAbility(player.mainHandItem) == ItemAbility.VAMPIRISM) {
             vampirismCooldown--
             sync()
         }
 
+        if (VoidBoundItemUtils.getActiveAbility(player.mainHandItem) != ItemAbility.OPENER) {
+            if (finalStrike) {
+                finalStrike = false
+                sync()
+            }
+            if (wrathCounter > 0) {
+                wrathCounter = 0
+                sync()
+            }
+        }
+
         if (!finalStrike) {
             // Wrath logic
             if (wrathCounter in 1..9) {
-                if (wrathCooldown > 0) {
-                    wrathCooldown--
+                //if cooldown hits 0
+                if (wrathStackKiller > 0) {
+                    wrathStackKiller--
                 } else {
                     // If cooldown hits 0, reset the wrath counter
                     wrathCounter = 0
@@ -104,28 +145,46 @@ class VoidBoundPlayerItemAbilityComponent(private val player: Player) : AutoSync
             // FinalStrike logic when wrathCounter reaches 10
             if (wrathCounter == 10) {
                 finalStrike = true
-                wrathCounter = 0
-                wrathCooldown = 0
+                wrathStackKiller = 0
                 finalStrikeDuration = finalStrikeCooldownMax
                 sync()
             }
+
         } else {
             // Handle ticking down the finalStrike duration
             if (finalStrikeDuration > 0) {
                 finalStrikeDuration--
             } else {
+                wrathCounter = 0
                 finalStrike = false
             }
             sync()
         }
     }
 
+    override fun readFromNbt(tag: CompoundTag) {
+        vampirismCooldown = tag.getInt("vampirismCooldown")
+        wrathStackKiller = tag.getInt("wrathCooldown")
+        wrathCounter = tag.getInt("wrathCounter")
+        finalStrike = tag.getBoolean("finalStrike")
+        finalStrikeDuration = tag.getInt("finalStrikeDuration")
+    }
+
+    override fun writeToNbt(tag: CompoundTag) {
+        tag.putInt("vampirismCooldown", vampirismCooldown)
+        tag.putInt("wrathCooldown", wrathStackKiller)
+        tag.putInt("wrathCounter", wrathCounter)
+        tag.putBoolean("finalStrike", finalStrike)
+        tag.putInt("finalStrikeDuration", finalStrikeDuration)
+    }
+
+
     private fun sync(){
         VoidBoundComponentRegistry.VOID_BOUND_PLAYER_ITEM_ABILITY_COMPONENT.sync(player)
     }
 
     companion object {
-       fun onRightClickItem(player: ServerPlayer, interactionHand: InteractionHand?, stack: ItemStack): Boolean {
+       fun onRightClickItem(player: ServerPlayer, interactionHand: InteractionHand, stack: ItemStack): Boolean {
            if (VoidBoundItemUtils.getActiveAbility(stack) == ItemAbility.TRIPLE_REBOUND) {
                val level = player.level()
                if (!level.isClientSide) {
@@ -157,5 +216,7 @@ class VoidBoundPlayerItemAbilityComponent(private val player: Player) : AutoSync
 
            return false
        }
+
+
     }
 }
diff --git a/src/main/kotlin/dev/sterner/common/item/equipment/ichor/IchoriumVorpal.kt b/src/main/kotlin/dev/sterner/common/item/equipment/ichor/IchoriumVorpal.kt
@@ -23,7 +23,6 @@ import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.Tier
 import net.minecraft.world.item.context.UseOnContext
 import net.minecraft.world.level.Level
-import net.minecraft.world.level.block.Blocks
 import net.minecraft.world.level.block.state.BlockState
 import net.minecraft.world.level.levelgen.structure.BoundingBox
 import net.minecraft.world.phys.BlockHitResult
@@ -48,13 +47,6 @@ class IchoriumVorpal(
         return 72000
     }
 
-    override fun hurtEnemy(stack: ItemStack, target: LivingEntity, attacker: LivingEntity): Boolean {
-        if (attacker is Player && VoidBoundItemUtils.getActiveAbility(stack) == ItemAbility.VAMPIRISM) {
-            VoidBoundComponentRegistry.VOID_BOUND_PLAYER_ITEM_ABILITY_COMPONENT.get(attacker).tryUseVampirism(target)
-        }
-        return super.hurtEnemy(stack, target, attacker)
-    }
-
     override fun canAttackBlock(state: BlockState?, level: Level?, pos: BlockPos?, player: Player): Boolean {
         return VoidBoundItemUtils.getActiveAbility(player.mainHandItem) == ItemAbility.HARVEST
     }
diff --git a/src/main/kotlin/dev/sterner/registry/VoidBoundEvents.kt b/src/main/kotlin/dev/sterner/registry/VoidBoundEvents.kt
@@ -46,14 +46,14 @@ object VoidBoundEvents {
             val attacker = it.source.entity
             if (attacker is Player) {
                 val item = attacker.mainHandItem
-                val bl = VoidBoundItemUtils.getActiveAbility(item) == ItemAbility.VAMPIRISM
-                if (bl) {
-                    attacker.heal(attacker.random.nextInt(2).toFloat())
-                }
+                val component = VoidBoundComponentRegistry.VOID_BOUND_PLAYER_ITEM_ABILITY_COMPONENT.get(attacker)
 
-                val bl2 = VoidBoundItemUtils.getActiveAbility(item) == ItemAbility.OPENER
-                if (bl2 && it.entity.health / it.entity.maxHealth > 0.95) {
-                    it.amount *= 1.5f
+                if (VoidBoundItemUtils.getActiveAbility(item) == ItemAbility.OPENER) {
+                    it.amount = component.tryUseOpener(it.entity, it.amount)
+                } else if (VoidBoundItemUtils.getActiveAbility(item) == ItemAbility.VAMPIRISM) {
+                    it.amount = component.tryUseVampirism(it.entity, it.amount)
+                } else if (VoidBoundItemUtils.getActiveAbility(item) == ItemAbility.FINALE) {
+                    it.amount = component.tryUseFinale(it.entity, it.amount)
                 }
             }
         }
