feat(plugin26): swarm calculation with fish size

Author: xeruf

plugin2026/src/main/kotlin/sc/plugin2026/Board.kt

@@ -32,8 +32,9 @@ class Board(gameField: MutableTwoDBoard<FieldState> = randomFields()):
     fun getTeam(pos: Coordinates): Team? =
         this[pos].team
 
-    fun fieldsForTeam(team: ITeam): Collection<Coordinates> =
-        filterValues { field -> field.team == team }.map { it.key }
+    fun fieldsForTeam(team: ITeam): Map<Coordinates, Int> =
+        filterValues { field -> field.team == team }
+            .mapValues { (_, field) -> field.size }
 
     companion object {
         /** Erstellt ein zufälliges Spielbrett.  */

plugin2026/src/main/kotlin/sc/plugin2026/util/GameRuleLogic.kt

@@ -102,68 +102,52 @@ object GameRuleLogic {
         return returnSet
     }
 
-    private fun getSwarm(found: MutableSet<Coordinates>, swarm: MutableSet<Coordinates>): MutableSet<Coordinates> {
-        if(swarm.isEmpty() && !found.isEmpty()) {
-            val field = found.iterator().next()
-            swarm.add(field)
-            found.remove(field)
-        }
+    /** Called with a single fish in [swarm] and the [looseFishes] left,
+     * recursively calling with neighbors added to [swarm] to find the whole swarm. */
+    private fun getSwarm(looseFishes: Set<Coordinates>, swarm: List<Coordinates>): List<Coordinates> {
+        val swarmNeighbours =
+            swarm.flatMap { getDirectNeighbour(it, looseFishes) }
 
-        var tmpSwarm: MutableSet<Coordinates> = HashSet(swarm)
-        // O(swarm.size()) time
-        for(field in swarm) {
-            // Constant time for both calls (max of 8 neighbors)
-            val neighbours = getDirectNeighbour(field, found)
-            tmpSwarm.addAll(neighbours)
+        // only search on if any neighbors were added
+        if(swarmNeighbours.isNotEmpty()) {
+            return getSwarm(looseFishes - swarmNeighbours, swarm + swarmNeighbours)
         }
-        
-        // O(found.size()*swarm.size()) time
-        // FIXME: Might be improved O(swarm.size()) should be possible
-        if(swarm.size != tmpSwarm.size) tmpSwarm = getSwarm(found, tmpSwarm)
-        
-        swarm.addAll(tmpSwarm)
-        
-        found.removeAll(swarm)
         return swarm
     }
 
     @JvmStatic
-    fun greatestSwarm(fieldsToCheck: Set<Coordinates>): Set<Coordinates> {
+    fun greatestSwarm(fieldsToCheck: Map<Coordinates, Int>): Map<Coordinates, Int>? {
         // Make a copy, so there will be no conflict with direct calls.
-        val occupiedFields: MutableSet<Coordinates> = HashSet(fieldsToCheck)
-        var greatestSwarm: Set<Coordinates> = HashSet()
+        val fieldsLeft = fieldsToCheck.keys.toMutableList()
         var maxSize = -1
+        var maxSwarm: Map<Coordinates, Int>? = null
 
         // this is a maximum of MAX_FISH iterations, so it is a linear iteration altogether
-        while(!occupiedFields.isEmpty() && occupiedFields.size > maxSize) {
-            val swarm: Set<Coordinates> = getSwarm(occupiedFields, HashSet())
-            // TODO consider fish weights
-            if(maxSize < swarm.size) {
-                maxSize = swarm.size
-                greatestSwarm = swarm
+        while(!fieldsLeft.isEmpty() && fieldsLeft.size > maxSize) {
+            val swarmCoords = getSwarm(fieldsToCheck.keys, listOf(fieldsLeft.removeLast()))
+            fieldsLeft.removeAll(swarmCoords)
+            val swarm = fieldsToCheck.filterKeys { swarmCoords.contains(it) }
+            val swarmSize = swarm.values.sum()
+            if(maxSize < swarmSize) {
+                maxSwarm = swarm
+                maxSize = swarmSize
             }
         }
-        return greatestSwarm
+        return maxSwarm
     }
 
     @JvmStatic
-    fun greatestSwarm(board: Board, team: ITeam): Set<Coordinates> {
-        val occupiedFields = board.fieldsForTeam(team)
-        return greatestSwarm(occupiedFields.toHashSet())
-    }
+    fun greatestSwarmSize(fields: Map<Coordinates, Int>): Int =
+        greatestSwarm(fields)?.values?.sum() ?: -1
 
     @JvmStatic
     fun greatestSwarmSize(board: Board, team: ITeam): Int =
-        greatestSwarm(board, team).size
-    
-    @JvmStatic
-    fun greatestSwarmSize(set: Set<Coordinates>): Int =
-        greatestSwarm(set).size
+        greatestSwarmSize(board.fieldsForTeam(team))
 
     @JvmStatic
     fun isSwarmConnected(board: Board, team: ITeam): Boolean {
         val fieldsWithFish = board.fieldsForTeam(team)
-        val numGreatestSwarm: Int = greatestSwarmSize(fieldsWithFish.toHashSet())
-        return numGreatestSwarm == fieldsWithFish.size
+        val greatestSwarm = greatestSwarm(fieldsWithFish)
+        return greatestSwarm?.size == fieldsWithFish.size
     }
 }

plugin2026/src/test/kotlin/sc/plugin2026/GameRuleLogicTest.kt

@@ -0,0 +1,34 @@
+package sc.plugin2026
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.inspectors.forAll
+import io.kotest.matchers.*
+import io.kotest.matchers.ints.*
+import sc.api.plugins.Team
+import sc.plugin2026.util.GameRuleLogic
+
+class GameRuleLogicTest: FunSpec({
+    context("swarm size") {
+        test("generated board") {
+            val newBoard = Board()
+            Team.values().forAll { team ->
+                GameRuleLogic.greatestSwarmSize(newBoard, team) shouldBeGreaterThanOrEqual 8
+                GameRuleLogic.isSwarmConnected(newBoard, team) shouldBe false
+            }
+        }
+        test("board of only red fishes") {
+            val board = Board(arrayOf(arrayOf(FieldState.ONE_S, FieldState.ONE_M, FieldState.ONE_L)))
+            GameRuleLogic.isSwarmConnected(board, Team.ONE) shouldBe true
+            GameRuleLogic.isSwarmConnected(board, Team.TWO) shouldBe false
+            GameRuleLogic.greatestSwarmSize(board, Team.ONE) shouldBe 6
+            GameRuleLogic.greatestSwarmSize(board, Team.TWO) shouldBe -1
+        }
+        test("board with red and blue fishes") {
+            val board = Board(arrayOf(arrayOf(FieldState.ONE_S, FieldState.ONE_L, FieldState.TWO_M, FieldState.ONE_L)))
+            GameRuleLogic.isSwarmConnected(board, Team.ONE) shouldBe false
+            GameRuleLogic.isSwarmConnected(board, Team.TWO) shouldBe true
+            GameRuleLogic.greatestSwarmSize(board, Team.ONE) shouldBe 4
+            GameRuleLogic.greatestSwarmSize(board, Team.TWO) shouldBe 2
+        }
+    }
+})