feat(plugin26): implement GameRuleLogic swarm checks

Author: xeruf

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

@@ -35,6 +35,9 @@ class Board(gameField: MutableTwoDBoard<FieldS> = randomFields()): RectangularBo
     fun getTeam(pos: Coordinates): Team? =
         this[pos].state.team
 
+    fun fieldsForTeam(team: Team): Collection<Coordinates> =
+        filterValues { field -> field.state.team == team }.map { it.key }
+    
     companion object {
         /** Erstellt eine zufälliges Spielbrett.  */
         private fun randomFields(): MutableTwoDBoard<FieldS> {

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

@@ -4,7 +4,6 @@ import sc.api.plugins.Coordinates
 import sc.api.plugins.Direction
 import sc.api.plugins.Team
 import sc.plugin2026.Board
-import sc.plugin2026.Field
 import sc.plugin2026.FieldState
 import sc.plugin2026.Move
 import sc.plugin2026.PiranhaMoveMistake
@@ -86,58 +85,58 @@ object GameRuleLogic {
             .map { direction -> Move(pos, direction)}
             .filter { move -> checkMove(board, move) == null }
 
-    private fun getDirectNeighbour(board: Board, f: Field, parentSet: Set<Field>): Set<Field> {
-        val returnSet: MutableSet<Field> = java.util.HashSet()
+    private fun getDirectNeighbour(f: Coordinates, parentSet: Set<Coordinates>): Set<Coordinates> {
+        val returnSet: MutableSet<Coordinates> = HashSet()
         for(i in -1..1) {
             for(j in -1..1) {
                 val x = f.x + i
                 val y = f.y + j
                 if(x < 0 || x >= PiranhaConstants.BOARD_LENGTH || y < 0 || y >= PiranhaConstants.BOARD_LENGTH || (i == 0 && j == 0)) continue
 
-                val field: Field = board.getField(x, y)
-                if(parentSet.contains(field)) {
-                    returnSet.add(field)
+                val coord = Coordinates(x, y)
+                if(parentSet.contains(coord)) {
+                    returnSet.add(coord)
                 }
             }
         }
         return returnSet
     }
 
-    private fun getSwarm(board: Board, found: MutableSet<Field>, swarm: MutableSet<Field>): MutableSet<Field> {
+    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)
         }
 
-        var tmpSwarm: MutableSet<Field> = java.util.HashSet(swarm)
+        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(board, field, found)
+            val neighbours = getDirectNeighbour(field, found)
             tmpSwarm.addAll(neighbours)
         }
 
         // O(found.size()*swarm.size()) time
         // FIXME: Might be improved O(swarm.size()) should be possible
-        if(swarm.size != tmpSwarm.size) tmpSwarm = getSwarm(board, found, tmpSwarm)
+        if(swarm.size != tmpSwarm.size) tmpSwarm = getSwarm(found, tmpSwarm)
 
         swarm.addAll(tmpSwarm)
 
         found.removeAll(swarm)
         return swarm
     }
 
-    fun greatestSwarm(board: Board, fieldsToCheck: Set<Field>): Set<Field> {
+    @JvmStatic
+    fun greatestSwarm(fieldsToCheck: Set<Coordinates>): Set<Coordinates> {
         // Make a copy, so there will be no conflict with direct calls.
-        val occupiedFields: MutableSet<Field> = java.util.HashSet(fieldsToCheck)
-        var greatestSwarm: Set<Field> = java.util.HashSet()
+        val occupiedFields: MutableSet<Coordinates> = HashSet(fieldsToCheck)
+        var greatestSwarm: Set<Coordinates> = HashSet()
         var maxSize = -1
 
         // this is a maximum of MAX_FISH iterations, so it is a linear iteration altogether
         while(!occupiedFields.isEmpty() && occupiedFields.size > maxSize) {
-            val empty: MutableSet<Field> = java.util.HashSet()
-            val swarm: Set<Field> = getSwarm(board, occupiedFields, empty)
+            val swarm: Set<Coordinates> = getSwarm(occupiedFields, HashSet())
             if(maxSize < swarm.size) {
                 maxSize = swarm.size
                 greatestSwarm = swarm
@@ -146,22 +145,24 @@ object GameRuleLogic {
         return greatestSwarm
     }
 
-    fun greatestSwarm(board: Board, player: Team?): Set<Field> {
-        val occupiedFields = getOwnFields(board, player)
-        return greatestSwarm(board, occupiedFields)
+    @JvmStatic
+    fun greatestSwarm(board: Board, team: Team): Set<Coordinates> {
+        val occupiedFields = board.fieldsForTeam(team)
+        return greatestSwarm(occupiedFields.toHashSet())
     }
 
-    fun greatestSwarmSize(board: Board, player: Team?): Int {
-        return greatestSwarm(board, player).size
-    }
+    @JvmStatic
+    fun greatestSwarmSize(board: Board, team: Team): Int =
+        greatestSwarm(board, team).size
 
-    fun greatestSwarmSize(board: Board, set: Set<Field?>): Int {
-        return greatestSwarm(board, set).size
-    }
+    @JvmStatic
+    fun greatestSwarmSize(set: Set<Coordinates>): Int =
+        greatestSwarm(set).size
 
-    fun isSwarmConnected(board: Board, player: Team?): Boolean {
-        val fieldsWithFish = getOwnFields(board, player)
-        val numGreatestSwarm: Int = greatestSwarmSize(board, fieldsWithFish)
+    @JvmStatic
+    fun isSwarmConnected(board: Board, team: Team): Boolean {
+        val fieldsWithFish = board.fieldsForTeam(team)
+        val numGreatestSwarm: Int = greatestSwarmSize(fieldsWithFish.toHashSet())
         return numGreatestSwarm == fieldsWithFish.size
     }
 }