Cleanup ability context

src/main/kotlin/club/mcscrims/speedhg/ability/AbilityContext.kt

@@ -12,47 +12,64 @@ class AbilityContext(
         key: String,
         requiredHits: Int? = null,
         cooldownSeconds: Int? = null
-    ): AbilityResult {
+    ): AbilityResult
-        if (cooldownSeconds != null && cooldownManager.isOnCooldown(player, key)) {
+	{
+        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)) {
+        if ( requiredHits != null && !hitCounterManager.hasReachedThreshold( player, key, requiredHits ))
+		{
             val missing = hitCounterManager.getRemainingHits( player, key, requiredHits )
             return AbilityResult.insufficientHits( missing )
         }
 
-        if (requiredHits != null) {
+        if ( requiredHits != null )
 			hitCounterManager.resetHits( player, key )
-        }
 
-        if (cooldownSeconds != null) {
+        if ( cooldownSeconds != null )
 			cooldownManager.startCooldown( player, key, cooldownSeconds )
-        }
 
         return AbilityResult.success()
     }
 
-    fun incrementHit(player: Player, key: String): Int {
+    fun incrementHit(
+	    player: Player,
+	    key: String
+	): Int
+	{
         return hitCounterManager.incrementHit( player, key )
     }
 
-    fun getHits(player: Player, key: String): Int {
+    fun getHits(
+	    player: Player,
+	    key: String
+	): Int
+	{
         return hitCounterManager.getHits( player, key )
     }
 
-    fun getRemainingCooldown(player: Player, key: String): Double {
+    fun getRemainingCooldown(
+	    player: Player,
+	    key: String
+	): Double
+	{
         return cooldownManager.getRemainingSeconds( player, key )
     }
 
-    fun clearPlayerData(player: Player) {
+    fun clearPlayerData(
+	    player: Player
+	) {
         cooldownManager.clearAllCooldowns( player )
         hitCounterManager.clearAllHits( player )
     }
 
-    fun clearAll() {
+    fun clearAll()
+	{
         cooldownManager.clearAll()
         hitCounterManager.clearAll()
     }
+
 }

src/main/kotlin/club/mcscrims/speedhg/ability/AbilityHitListener.kt

@@ -1,20 +1,25 @@
 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) {
+        if ( damager !is Player || victim !is Player )
 			return
-        }
 
         val hitCount = abilityContext.incrementHit( damager, "melee_hit" )
 
@@ -25,12 +30,18 @@ class AbilityHitListener(private val abilityContext: AbilityContext) : Listener
             cooldownSeconds = 10
         )
 
-        if (result.success) {
+        if ( result.success )
-            damager.sendMessage("§aAbility activated! You hit ${victim.name}")
+        {
-        } else if (result.missingHits > 0) {
+	        plugin.chatManager.sendMessage( damager, "ability.activated", "{player}" to victim.name )
-            damager.sendMessage("§e${result.missingHits} more hit(s) needed (Current: ${hitCount})")
+        }
-        } else if (result.remainingCooldown > 0) {
+        else if ( result.missingHits > 0 )
-            damager.sendMessage("§cAbility on cooldown: ${String.format("%.1f", result.remainingCooldown)}s remaining")
+        {
+	        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() )
         }
     }
+
 }

src/main/kotlin/club/mcscrims/speedhg/ability/AbilityResult.kt

@@ -6,7 +6,9 @@ data class AbilityResult(
     val remainingCooldown: Double = 0.0,
     val missingHits: Int = 0
 ) {
-    companion object {
+    companion object
+    {
+
 		fun success(): AbilityResult = AbilityResult( true, null )
 
         fun onCooldown( remaining: Double ): AbilityResult =
@@ -14,5 +16,6 @@ data class AbilityResult(
 
         fun insufficientHits( missing: Int ): AbilityResult =
             AbilityResult( false, "Not enough hits", missingHits = missing )
+
     }
 }

src/main/kotlin/club/mcscrims/speedhg/ability/CooldownManager.kt

@@ -8,27 +8,38 @@ class CooldownManager {
 
     private val cooldowns = ConcurrentHashMap<UUID, ConcurrentHashMap<String, Long>>()
 
-    fun startCooldown(player: Player, key: String, seconds: Int) {
+    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) {
+        if ( System.currentTimeMillis() >= expiryTime )
+		{
             playerCooldowns.remove( key )
-            if (playerCooldowns.isEmpty()) {
+            if ( playerCooldowns.isEmpty() ) cooldowns.remove( player.uniqueId )
-                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
 
@@ -36,15 +47,22 @@ class CooldownManager {
         return if ( remaining > 0 ) remaining else 0.0
     }
 
-    fun clearCooldown(player: Player, key: String) {
+    fun clearCooldown(
+	    player: Player,
+	    key: String
+	) {
         cooldowns[player.uniqueId]?.remove( key )
     }
 
-    fun clearAllCooldowns(player: Player) {
+    fun clearAllCooldowns(
+	    player: Player
+	) {
         cooldowns.remove( player.uniqueId )
     }
 
-    fun clearAll() {
+    fun clearAll()
+	{
         cooldowns.clear()
     }
+
 }

src/main/kotlin/club/mcscrims/speedhg/ability/HitCounterManager.kt

@@ -8,34 +8,59 @@ class HitCounterManager {
 
     private val hitCounts = ConcurrentHashMap<UUID, ConcurrentHashMap<String, Int>>()
 
-    fun incrementHit(player: Player, key: String): Int {
+    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 {
+    fun getHits(
+	    player: Player,
+	    key: String
+	): Int
+	{
         return hitCounts[player.uniqueId]?.get( key ) ?: 0
     }
 
-    fun resetHits(player: Player, key: String) {
+    fun resetHits(
+	    player: Player,
+	    key: String
+	) {
         hitCounts[player.uniqueId]?.remove( key )
     }
 
-    fun hasReachedThreshold(player: Player, key: String, requiredHits: Int): Boolean {
+    fun hasReachedThreshold(
+	    player: Player,
+	    key: String,
+	    requiredHits: Int
+	): Boolean
+	{
         return getHits( player, key ) >= requiredHits
     }
 
-    fun getRemainingHits(player: Player, key: String, requiredHits: Int): Int {
+    fun getRemainingHits(
+	    player: Player,
+	    key: String,
+	    requiredHits: Int
+	): Int
+	{
         val current = getHits( player, key )
         return maxOf( 0, requiredHits - current )
     }
 
-    fun clearAllHits(player: Player) {
+    fun clearAllHits(
+	    player: Player
+	) {
         hitCounts.remove( player.uniqueId )
     }
 
-    fun clearAll() {
+    fun clearAll()
+	{
         hitCounts.clear()
     }
+
 }