feat(plugin26): working Piranhas implementation

Author: xeruf

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

@@ -2,18 +2,19 @@ package sc.plugin2026
 
 import com.thoughtworks.xstream.annotations.XStreamAlias
 import sc.api.plugins.Coordinates
+import sc.api.plugins.IBoard
 import sc.api.plugins.ITeam
 import sc.api.plugins.MutableTwoDBoard
 import sc.api.plugins.RectangularBoard
 import sc.api.plugins.Team
+import sc.api.plugins.deepCopy
 import sc.plugin2026.util.*
-import kotlin.math.floor
-
-typealias FieldS = FieldState
+import kotlin.random.Random
 
 /** Spielbrett für Piranhas mit [PiranhaConstants.BOARD_LENGTH]² Feldern.  */
 @XStreamAlias(value = "board")
-class Board(gameField: MutableTwoDBoard<FieldS> = randomFields()): RectangularBoard<FieldS>(gameField) {
+class Board(gameField: MutableTwoDBoard<FieldState> = randomFields()):
+    RectangularBoard<FieldState>(gameField), IBoard {
 
     // TODO later
     //override fun toString() =
@@ -31,8 +32,8 @@ class Board(gameField: MutableTwoDBoard<FieldS> = randomFields()): RectangularBo
     //}
 
     override fun clone(): Board =
-        Board(Array(gameField.size) { column -> this.gameField[column].clone() })
-
+        Board(gameField.deepCopy())
+    
     fun getTeam(pos: Coordinates): Team? =
         this[pos].team
 
@@ -41,41 +42,45 @@ class Board(gameField: MutableTwoDBoard<FieldS> = randomFields()): RectangularBo
 
     companion object {
         /** Erstellt ein zufälliges Spielbrett.  */
-        private fun randomFields(): MutableTwoDBoard<FieldS> {
-            val fields = generateFields { x, y -> FieldS(x, y) }
+        private fun randomFields(random: Random = Random.Default): MutableTwoDBoard<FieldState> {
+            val fields = Array(PiranhaConstants.BOARD_LENGTH) {
+                Array(PiranhaConstants.BOARD_LENGTH) { FieldState.EMPTY }
+            }
 
             // Place Piranhas
             for(index in 1 until PiranhaConstants.BOARD_LENGTH - 1) {
-                fields[0][index].setPiranha(Team.ONE)
-                fields[PiranhaConstants.BOARD_LENGTH - 1][index].setPiranha(Team.ONE)
-                fields[index][0].setPiranha(Team.TWO)
-                fields[index][PiranhaConstants.BOARD_LENGTH - 1].setPiranha(Team.TWO)
+                val size1 = random.nextInt(2) + 1
+                fields[0][index] = FieldState.from(Team.ONE, size1)
+                fields[index][0] = FieldState.from(Team.TWO, size1)
+                
+                val size2 = random.nextInt(2) + 1
+                fields[PiranhaConstants.BOARD_LENGTH - 1][index] = FieldState.from(Team.ONE, size2)
+                fields[index][PiranhaConstants.BOARD_LENGTH - 1] = FieldState.from(Team.TWO, size2)
             }
 
             // Place Obstacles
             // only consider fields in the middle of the board
-            var blockableFields: List<Field> = fields.slice(PiranhaConstants.OBSTACLES_START..PiranhaConstants.OBSTACLES_END).flatMap { it.slice(PiranhaConstants.OBSTACLES_START..PiranhaConstants.OBSTACLES_END) }
+            val blockableWidth = PiranhaConstants.OBSTACLES_END - PiranhaConstants.OBSTACLES_START + 1
+            val blockableSize = blockableWidth * blockableWidth
             // set fields with randomly selected coordinates to blocked
-            // coordinates may not lay on same horizontal, vertical or diagonal lines with other selected coordinates
-            for(i in 0 until PiranhaConstants.NUM_OBSTACLES) {
-                val indexOfFieldToBlock = floor(Math.random() * blockableFields.size).toInt()
-                val selectedField = blockableFields[indexOfFieldToBlock]
-                selectedField.state = FieldState.OBSTRUCTED
-                blockableFields = blockableFields.filter { field ->
-                    !(field.x == selectedField.x || field.y == selectedField.y ||
-                      field.x - field.y == selectedField.x - selectedField.y ||
-                      field.x + field.y == selectedField.x + selectedField.y)
+            val obstacles = ArrayList<Coordinates>(PiranhaConstants.NUM_OBSTACLES)
+            while(obstacles.size < PiranhaConstants.NUM_OBSTACLES) {
+                val index = random.nextInt(blockableSize + 1)
+                val pos = Coordinates(
+                    PiranhaConstants.OBSTACLES_START + index.rem(blockableWidth),
+                    PiranhaConstants.OBSTACLES_START + index.div(blockableWidth)
+                )
+                // coordinates may not lay on same horizontal, vertical or diagonal lines with other selected coordinates
+                if(obstacles.none {
+                        it.x == pos.x || it.y == pos.y ||
+                        it.x - it.y == pos.x - pos.y ||
+                        it.x + it.y == pos.x + pos.y
+                    }) {
+                    obstacles.add(pos)
+                    fields[pos.x][pos.y] = FieldState.OBSTRUCTED
                 }
             }
             return fields
         }
-        
-        private fun generateFields(generator: (Int, Int) -> FieldS): Array<Array<FieldS>> {
-            return Array(PiranhaConstants.BOARD_LENGTH) { x ->
-                Array(PiranhaConstants.BOARD_LENGTH) { y ->
-                    generator(x, y)
-                }
-            }
-        }
     }
 }

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

@@ -13,6 +13,8 @@ enum class FieldState(val size: Int): IField<FieldState> {
     OBSTRUCTED(0),
     EMPTY(0);
 
+    override fun copy(): FieldState = this
+    
     override val isEmpty: Boolean
         get() = this == EMPTY
 
@@ -37,4 +39,23 @@ enum class FieldState(val size: Int): IField<FieldState> {
             else -> team?.letter.toString() + size.toString()
         }
 
+    companion object {
+        fun from(team: Team, size: Int): FieldState =
+            when(team) {
+                Team.ONE -> when(size) {
+                    1 -> ONE_S
+                    2 -> ONE_M
+                    3 -> ONE_L
+                    else -> throw IllegalArgumentException("Invalid size: $size")
+                }
+                Team.TWO -> when(size) {
+                    1 -> TWO_S
+                    2 -> TWO_M
+                    3 -> TWO_L
+                    else -> throw IllegalArgumentException("Invalid size: $size")
+                }
+            }
+        
+    }
+    
 }

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

@@ -62,12 +62,13 @@ data class GameState @JvmOverloads constructor(
         }
         GameRuleLogic.checkMove(board, move)?.let { throw InvalidMoveException(it, move) }
         val distance = GameRuleLogic.movementDistance(board, move)
-        board[move.from].state = FieldState.EMPTY
-        board[move.from + move.direction.vector * distance].state = FieldState.from(currentTeam)
+        board[move.from + move.direction.vector * distance] = board[move.from]
+        board[move.from] = FieldState.EMPTY
+        lastMove = move
     }
 
     override fun getSensibleMoves(): List<Move> {
-        val piranhas = board.filterValues { field -> field.state.team == currentTeam }
+        val piranhas = board.filterValues { field -> field.team == currentTeam }
         val moves = ArrayList<Move>(piranhas.size * 2)
         for(piranha in piranhas) {
             moves.addAll(GameRuleLogic.possibleMovesFor(board, piranha.key))
@@ -78,7 +79,7 @@ data class GameState @JvmOverloads constructor(
     override fun moveIterator(): Iterator<Move> =
         getSensibleMoves().iterator()
 
-    override fun clone(): TwoPlayerGameState<Move> =
+    override fun clone(): GameState =
         copy(board = board.clone())
 
     override fun teamStats(team: ITeam): List<Stat> =

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

@@ -19,15 +19,15 @@ object GameRuleLogic {
         while(true) {
             pos += move.direction
             val field = board.getOrNull(pos) ?: break
-            if(field.state.team != null) {
+            if(field.team != null) {
                 count++
             }
         }
         pos = move.from
         while(true) {
             pos += move.direction.opposite
             val field = board.getOrNull(pos) ?: break
-            if(field.state.team != null) {
+            if(field.team != null) {
                 count++
             }
         }
@@ -41,20 +41,20 @@ object GameRuleLogic {
         val distance = movementDistance(board, move)
         var pos = move.from
 
-        val team = board[move.from].state.team ?: return MoveMistake.START_EMPTY
+        val team = board[move.from].team ?: return MoveMistake.START_EMPTY
         val opponent = team.opponent()
 
         var moved = 1
         while(moved < distance) {
             pos += move.direction
             val field = board.getOrNull(pos) ?: return MoveMistake.DESTINATION_OUT_OF_BOUNDS
-            if(field.state.team == opponent) {
+            if(field.team == opponent) {
                 return PiranhaMoveMistake.JUMP_OVER_OPPONENT
             }
             moved++
         }
         pos += move.direction
-        val state = board.getOrNull(pos)?.state
+        val state = board.getOrNull(pos)
         return when(state) {
             null -> MoveMistake.DESTINATION_OUT_OF_BOUNDS
             FieldState.OBSTRUCTED -> MoveMistake.DESTINATION_BLOCKED