From ac185e35ced8752a96ddd28a9924a70605afc3a6 Mon Sep 17 00:00:00 2001 From: Laurin <100531026+TDSTOS@users.noreply.github.com> Date: Mon, 1 Dec 2025 19:45:49 +0100 Subject: [PATCH] Cleanup ability context --- .../speedhg/ability/AbilityContext.kt | 63 ++++++++++++------- .../speedhg/ability/AbilityHitListener.kt | 35 +++++++---- .../mcscrims/speedhg/ability/AbilityResult.kt | 15 +++-- .../speedhg/ability/CooldownManager.kt | 52 ++++++++++----- .../speedhg/ability/HitCounterManager.kt | 55 +++++++++++----- 5 files changed, 147 insertions(+), 73 deletions(-) diff --git a/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityContext.kt b/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityContext.kt index 8cf29cc..1d9b7f2 100644 --- a/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityContext.kt +++ b/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityContext.kt @@ -12,47 +12,64 @@ class AbilityContext( key: String, requiredHits: Int? = null, cooldownSeconds: Int? = null - ): AbilityResult { - if (cooldownSeconds != null && cooldownManager.isOnCooldown(player, key)) { - val remaining = cooldownManager.getRemainingSeconds(player, key) - return AbilityResult.onCooldown(remaining) + ): AbilityResult + { + if ( cooldownSeconds != null && cooldownManager.isOnCooldown( player, key )) + { + val remaining = cooldownManager.getRemainingSeconds( player, key ) + return AbilityResult.onCooldown( remaining ) } - if (requiredHits != null && !hitCounterManager.hasReachedThreshold(player, key, requiredHits)) { - val missing = hitCounterManager.getRemainingHits(player, key, requiredHits) - return AbilityResult.insufficientHits(missing) + if ( requiredHits != null && !hitCounterManager.hasReachedThreshold( player, key, requiredHits )) + { + val missing = hitCounterManager.getRemainingHits( player, key, requiredHits ) + return AbilityResult.insufficientHits( missing ) } - if (requiredHits != null) { - hitCounterManager.resetHits(player, key) - } + if ( requiredHits != null ) + hitCounterManager.resetHits( player, key ) - if (cooldownSeconds != null) { - cooldownManager.startCooldown(player, key, cooldownSeconds) - } + if ( cooldownSeconds != null ) + cooldownManager.startCooldown( player, key, cooldownSeconds ) return AbilityResult.success() } - fun incrementHit(player: Player, key: String): Int { - return hitCounterManager.incrementHit(player, key) + fun incrementHit( + player: Player, + key: String + ): Int + { + return hitCounterManager.incrementHit( player, key ) } - fun getHits(player: Player, key: String): Int { - return hitCounterManager.getHits(player, key) + fun getHits( + player: Player, + key: String + ): Int + { + return hitCounterManager.getHits( player, key ) } - fun getRemainingCooldown(player: Player, key: String): Double { - return cooldownManager.getRemainingSeconds(player, key) + fun getRemainingCooldown( + player: Player, + key: String + ): Double + { + return cooldownManager.getRemainingSeconds( player, key ) } - fun clearPlayerData(player: Player) { - cooldownManager.clearAllCooldowns(player) - hitCounterManager.clearAllHits(player) + fun clearPlayerData( + player: Player + ) { + cooldownManager.clearAllCooldowns( player ) + hitCounterManager.clearAllHits( player ) } - fun clearAll() { + fun clearAll() + { cooldownManager.clearAll() hitCounterManager.clearAll() } + } diff --git a/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityHitListener.kt b/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityHitListener.kt index 667ed05..5495f1a 100644 --- a/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityHitListener.kt +++ b/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityHitListener.kt @@ -1,22 +1,27 @@ package club.mcscrims.speedhg.ability +import club.mcscrims.speedhg.SpeedHG import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.Listener import org.bukkit.event.entity.EntityDamageByEntityEvent -class AbilityHitListener(private val abilityContext: AbilityContext) : Listener { +class AbilityHitListener( + private val plugin: SpeedHG, + private val abilityContext: AbilityContext +) : Listener { @EventHandler - fun onEntityDamage(event: EntityDamageByEntityEvent) { + fun onEntityDamage( + event: EntityDamageByEntityEvent + ) { val damager = event.damager val victim = event.entity - if (damager !is Player || victim !is Player) { - return - } + if ( damager !is Player || victim !is Player ) + return - val hitCount = abilityContext.incrementHit(damager, "melee_hit") + val hitCount = abilityContext.incrementHit( damager, "melee_hit" ) val result = abilityContext.canUseAbility( player = damager, @@ -25,12 +30,18 @@ class AbilityHitListener(private val abilityContext: AbilityContext) : Listener cooldownSeconds = 10 ) - if (result.success) { - damager.sendMessage("§aAbility activated! You hit ${victim.name}") - } else if (result.missingHits > 0) { - damager.sendMessage("§e${result.missingHits} more hit(s) needed (Current: ${hitCount})") - } else if (result.remainingCooldown > 0) { - damager.sendMessage("§cAbility on cooldown: ${String.format("%.1f", result.remainingCooldown)}s remaining") + if ( result.success ) + { + plugin.chatManager.sendMessage( damager, "ability.activated", "{player}" to victim.name ) + } + else if ( result.missingHits > 0 ) + { + plugin.chatManager.sendMessage( damager, "ability.more_hits", "{current}" to hitCount.toString(), "{needed}" to result.missingHits.toString() ) + } + else if ( result.remainingCooldown > 0 ) + { + plugin.chatManager.sendMessage( damager, "ability.cooldown", "{cooldown}" to result.remainingCooldown.toString() ) } } + } diff --git a/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityResult.kt b/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityResult.kt index 734d1b7..fd821be 100644 --- a/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityResult.kt +++ b/src/main/kotlin/club/mcscrims/speedhg/ability/AbilityResult.kt @@ -6,13 +6,16 @@ data class AbilityResult( val remainingCooldown: Double = 0.0, val missingHits: Int = 0 ) { - companion object { - fun success(): AbilityResult = AbilityResult(true, null) + companion object + { - fun onCooldown(remaining: Double): AbilityResult = - AbilityResult(false, "Ability is on cooldown", remainingCooldown = remaining) + fun success(): AbilityResult = AbilityResult( true, null ) + + fun onCooldown( remaining: Double ): AbilityResult = + AbilityResult( false, "Ability is on cooldown", remainingCooldown = remaining ) + + fun insufficientHits( missing: Int ): AbilityResult = + AbilityResult( false, "Not enough hits", missingHits = missing ) - fun insufficientHits(missing: Int): AbilityResult = - AbilityResult(false, "Not enough hits", missingHits = missing) } } diff --git a/src/main/kotlin/club/mcscrims/speedhg/ability/CooldownManager.kt b/src/main/kotlin/club/mcscrims/speedhg/ability/CooldownManager.kt index f3cf41d..36268e9 100644 --- a/src/main/kotlin/club/mcscrims/speedhg/ability/CooldownManager.kt +++ b/src/main/kotlin/club/mcscrims/speedhg/ability/CooldownManager.kt @@ -8,43 +8,61 @@ class CooldownManager { private val cooldowns = ConcurrentHashMap>() - fun startCooldown(player: Player, key: String, seconds: Int) { - val expiryTime = System.currentTimeMillis() + (seconds * 1000L) - cooldowns.computeIfAbsent(player.uniqueId) { ConcurrentHashMap() }[key] = expiryTime + fun startCooldown( + player: Player, + key: String, + seconds: Int + ) { + val expiryTime = System.currentTimeMillis() + ( seconds * 1000L ) + cooldowns.computeIfAbsent( player.uniqueId ) { ConcurrentHashMap() }[ key ] = expiryTime } - fun isOnCooldown(player: Player, key: String): Boolean { + fun isOnCooldown( + player: Player, + key: String + ): Boolean + { val playerCooldowns = cooldowns[player.uniqueId] ?: return false val expiryTime = playerCooldowns[key] ?: return false - if (System.currentTimeMillis() >= expiryTime) { - playerCooldowns.remove(key) - if (playerCooldowns.isEmpty()) { - cooldowns.remove(player.uniqueId) - } + if ( System.currentTimeMillis() >= expiryTime ) + { + playerCooldowns.remove( key ) + if ( playerCooldowns.isEmpty() ) cooldowns.remove( player.uniqueId ) return false } return true } - fun getRemainingSeconds(player: Player, key: String): Double { + fun getRemainingSeconds( + player: Player, + key: String + ): Double + { val playerCooldowns = cooldowns[player.uniqueId] ?: return 0.0 val expiryTime = playerCooldowns[key] ?: return 0.0 - val remaining = (expiryTime - System.currentTimeMillis()) / 1000.0 - return if (remaining > 0) remaining else 0.0 + val remaining = ( expiryTime - System.currentTimeMillis() ) / 1000.0 + return if ( remaining > 0 ) remaining else 0.0 } - fun clearCooldown(player: Player, key: String) { - cooldowns[player.uniqueId]?.remove(key) + fun clearCooldown( + player: Player, + key: String + ) { + cooldowns[player.uniqueId]?.remove( key ) } - fun clearAllCooldowns(player: Player) { - cooldowns.remove(player.uniqueId) + fun clearAllCooldowns( + player: Player + ) { + cooldowns.remove( player.uniqueId ) } - fun clearAll() { + fun clearAll() + { cooldowns.clear() } + } diff --git a/src/main/kotlin/club/mcscrims/speedhg/ability/HitCounterManager.kt b/src/main/kotlin/club/mcscrims/speedhg/ability/HitCounterManager.kt index fc21156..34bb0fe 100644 --- a/src/main/kotlin/club/mcscrims/speedhg/ability/HitCounterManager.kt +++ b/src/main/kotlin/club/mcscrims/speedhg/ability/HitCounterManager.kt @@ -8,34 +8,59 @@ class HitCounterManager { private val hitCounts = ConcurrentHashMap>() - fun incrementHit(player: Player, key: String): Int { - val playerHits = hitCounts.computeIfAbsent(player.uniqueId) { ConcurrentHashMap() } - val newCount = playerHits.compute(key) { _, current -> (current ?: 0) + 1 } ?: 1 + fun incrementHit( + player: Player, + key: String + ): Int + { + val playerHits = hitCounts.computeIfAbsent( player.uniqueId ) { ConcurrentHashMap() } + val newCount = playerHits.compute( key ) { _, current -> ( current ?: 0 ) + 1 } ?: 1 return newCount } - fun getHits(player: Player, key: String): Int { - return hitCounts[player.uniqueId]?.get(key) ?: 0 + fun getHits( + player: Player, + key: String + ): Int + { + return hitCounts[player.uniqueId]?.get( key ) ?: 0 } - fun resetHits(player: Player, key: String) { - hitCounts[player.uniqueId]?.remove(key) + fun resetHits( + player: Player, + key: String + ) { + hitCounts[player.uniqueId]?.remove( key ) } - fun hasReachedThreshold(player: Player, key: String, requiredHits: Int): Boolean { - return getHits(player, key) >= requiredHits + fun hasReachedThreshold( + player: Player, + key: String, + requiredHits: Int + ): Boolean + { + return getHits( player, key ) >= requiredHits } - fun getRemainingHits(player: Player, key: String, requiredHits: Int): Int { - val current = getHits(player, key) - return maxOf(0, requiredHits - current) + fun getRemainingHits( + player: Player, + key: String, + requiredHits: Int + ): Int + { + val current = getHits( player, key ) + return maxOf( 0, requiredHits - current ) } - fun clearAllHits(player: Player) { - hitCounts.remove(player.uniqueId) + fun clearAllHits( + player: Player + ) { + hitCounts.remove( player.uniqueId ) } - fun clearAll() { + fun clearAll() + { hitCounts.clear() } + }