Score Tracker started.

Server/src/main/content/minigame/barbassault/arena/BarbScoreManager.kt

@@ -0,0 +1,112 @@
+package content.minigame.barbassault.arena
+
+import content.minigame.barbassault.lobby.BarbTeam
+import core.game.node.entity.player.Player
+
+class BarbScoreManager {
+
+    private val trackers = mutableMapOf<Player, ScoreTracker>()
+
+    fun trackerFor(player: Player): ScoreTracker = trackers.getOrPut(player) { ScoreTracker() }
+
+    fun resetAll() {
+        trackers.values.forEach { it.reset() }
+    }
+
+    fun remove(player: Player) {
+        trackers.remove(player)
+    }
+    fun allTrackers(): Collection<ScoreTracker> = trackers.values
+    fun personal(player: Player, caps: SpawnCaps): RoleScore {
+        return trackerFor(player).toScoreboard(caps)
+    }
+
+    fun team(team: BarbTeam, caps: SpawnCaps): RoleScore {
+        var total = RoleScore.ZERO
+        for (player in team.allPlayers()) {
+            total = total.add(trackerFor(player).toScoreboard(caps))
+        }
+        return total
+    }
+}
+
+data class AttackerStats(var rangersKilled: Int = 0, var fightersKilled: Int = 0, var incorrectStyleAttacks: Int = 0)
+data class CollectorStats(var eggsCollected: Int = 0, var eggsExploded: Int = 0) { val netEggs: Int get() = eggsCollected - eggsExploded }
+data class DefenderStats(var runnersKilled: Int = 0, var runnersPast: Int = 0)
+data class HealerStats(var healersKilled: Int = 0, var hitpointsReplenished: Int = 0, var wrongPoisonUsed: Int = 0)
+
+data class ScoreTracker(var attackerStats: AttackerStats = AttackerStats(), var collectorStats: CollectorStats = CollectorStats(),
+                        var defenderStats: DefenderStats = DefenderStats(),var healerStats: HealerStats = HealerStats())
+{
+    fun reset() {
+        attackerStats = AttackerStats()
+        collectorStats = CollectorStats()
+        defenderStats = DefenderStats()
+        healerStats = HealerStats()
+    }
+    fun toScoreboard(caps: SpawnCaps): RoleScore = BarbAssaultScoreBuilder.build(this, caps)
+}
+//Wave spawn counts // may pull from wave to count table latter
+data class SpawnCaps(val rangers: Int, val fighters: Int, val runners: Int, val healers: Int)
+data class RoleScore(val rangersKilled: Int, val fightersKilled: Int, val incorrectStylePenalty: Int,
+                     val eggsScore: Int,
+                     val runnersKilledScore: Int, val runnersPastPenalty: Int,
+                     val healersKilledScore: Int, val hitpointsHealedScore: Int, val wrongPoisonPenalty: Int )
+{
+    val attackerTotal: Int get() = rangersKilled + fightersKilled + incorrectStylePenalty
+    val collectorTotal: Int get() = eggsScore
+    val defenderTotal: Int get() = runnersKilledScore + runnersPastPenalty
+    val healerTotal: Int get() = healersKilledScore + hitpointsHealedScore + wrongPoisonPenalty
+    fun add(other: RoleScore): RoleScore = RoleScore(
+        rangersKilled + other.rangersKilled,
+        fightersKilled + other.fightersKilled,
+        incorrectStylePenalty + other.incorrectStylePenalty,
+        eggsScore + other.eggsScore,
+        runnersKilledScore + other.runnersKilledScore,
+        runnersPastPenalty + other.runnersPastPenalty,
+        healersKilledScore + other.healersKilledScore,
+        hitpointsHealedScore + other.hitpointsHealedScore,
+        wrongPoisonPenalty + other.wrongPoisonPenalty
+    )
+    companion object {
+        val ZERO = RoleScore(0,0,0,0,0,0,0,0,0)
+    }
+}
+
+object BarbAssaultScoreBuilder {
+    fun build(tracker: ScoreTracker, caps: SpawnCaps): RoleScore {
+
+        val atk = tracker.attackerStats
+        val col = tracker.collectorStats
+        val def = tracker.defenderStats
+        val heal = tracker.healerStats
+
+        val rangerKillScore = atk.rangersKilled.coerceAtMost(caps.rangers) - 1
+        val fighterKillScore = atk.fightersKilled.coerceAtMost(caps.fighters) - 1
+        val incorrectStylePenalty = (-atk.incorrectStyleAttacks + 1).coerceAtLeast(-10)
+
+        val eggScore = (col.netEggs.coerceAtMost(60) / 4.35).toInt()
+
+        val runnersKilledScore = (1.8 * def.runnersKilled.coerceAtMost(caps.runners)).toInt()
+        val runnersPastPenalty = (-3 * def.runnersPast).coerceAtLeast(-10)
+
+        val healerKillScore = (0.7 * heal.healersKilled.coerceAtMost(caps.healers)).toInt()
+        val hitpointsHealedScore = (heal.hitpointsReplenished / 18).coerceAtMost(28)
+        val wrongPoisonPenalty = -(heal.wrongPoisonUsed.coerceAtMost(512) / 4)
+
+        return RoleScore(
+            rangersKilled = rangerKillScore,
+            fightersKilled = fighterKillScore,
+            incorrectStylePenalty = incorrectStylePenalty,
+
+            eggsScore = eggScore,
+
+            runnersKilledScore = runnersKilledScore,
+            runnersPastPenalty = runnersPastPenalty,
+
+            healersKilledScore = healerKillScore,
+            hitpointsHealedScore = hitpointsHealedScore,
+            wrongPoisonPenalty = wrongPoisonPenalty
+        )
+    }
+}

Server/src/main/content/minigame/barbassault/arena/BarbassaultSession.kt

@@ -54,7 +54,7 @@ class BarbassaultSession(  val activity: BarbassaultActivity ? = null) : MapArea
     val sessionNpcs = mutableListOf<NPC>()
     val groundItems = mutableListOf<GroundItem>()
     val eggHopper = EggCannon.EggHopper()
-
+    val scoreManager = BarbScoreManager()
 
     fun beginStartingPhase() {
         if (state != BarbassaultState.PARTY_CREATION) return
@@ -182,14 +182,6 @@ class BarbassaultSession(  val activity: BarbassaultActivity ? = null) : MapArea
             sendMessage(player, "----- Wave: $waveNum -----")
             openOverlay(player, it)
         }
-
-      /**  BarbassaultTut.BarbassTutNPCs.forEach {
-            npc -> npc.init()
-            npc.isWalks = false
-
-        }
-        BarbassaultTut.spawnItems()
-        **/
     }
 
     override fun areaLeave(entity: Entity, logout: Boolean) {

Server/src/main/content/minigame/barbassault/arena/WaveCompleteInterface.kt

@@ -1,8 +1,11 @@
 package content.minigame.barbassault.arena
 
+
 class WaveCompleteInterface {
+
 }
 
+
 /*
 [TITLE] bold/ Wave Complete!
         bold/ Reward: