feat(plugin26): move validation and generation

Author: xeruf

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

@@ -1,6 +1,7 @@
 package sc.plugin2026
 
 import com.thoughtworks.xstream.annotations.XStreamAlias
+import sc.api.plugins.Coordinates
 import sc.api.plugins.MutableTwoDBoard
 import sc.api.plugins.RectangularBoard
 import sc.api.plugins.Team
@@ -31,6 +32,9 @@ class Board(gameField: MutableTwoDBoard<FieldS> = randomFields()): RectangularBo
     override fun clone(): Board =
         Board(Array(gameField.size) { column -> this.gameField[column].clone() })
 
+    fun getTeam(pos: Coordinates): Team? =
+        this[pos].state.team
+    
     companion object {
         /** Erstellt eine zufälliges Spielbrett.  */
         private fun randomFields(): MutableTwoDBoard<FieldS> {

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

@@ -59,5 +59,5 @@ class Field @JvmOverloads constructor(
         get() = state == FieldState.OBSTRUCTED
 
     override val isEmpty: Boolean
-        get() = false
+        get() = state == FieldState.EMPTY
 }

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

@@ -24,6 +24,14 @@ enum class FieldState {
         else -> ' '
     }
 
+    val team: Team?
+        get() = when(this) {
+            ONE -> Team.ONE
+            TWO -> Team.TWO
+            OBSTRUCTED -> null
+            EMPTY -> null
+        }
+    
     companion object {
         @JvmStatic
         fun from(team: Team): FieldState {

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

@@ -2,10 +2,21 @@ package sc.plugin2019
 
 import com.thoughtworks.xstream.annotations.XStreamAlias
 import com.thoughtworks.xstream.annotations.XStreamAsAttribute
+import sc.api.plugins.Direction
+import sc.api.plugins.ITeam
+import sc.api.plugins.Stat
 import sc.api.plugins.Team
 import sc.api.plugins.TwoPlayerGameState
 import sc.plugin2026.Board
+import sc.plugin2026.FieldState
 import sc.plugin2026.Move
+import sc.plugin2026.PiranhaMoveMistake
+import sc.plugin2026.util.GameRuleLogic
+import sc.plugin2026.util.PiranhaConstants
+import sc.shared.IMoveMistake
+import sc.shared.InvalidMoveException
+import sc.shared.MoveMistake
+import sc.shared.WinCondition
 
 /**
  * The GameState class represents the current state of the game.
@@ -28,8 +39,91 @@ data class GameState @JvmOverloads constructor(
 ): TwoPlayerGameState<Move>(Team.ONE) {
 
     override fun getPointsForTeam(team: ITeam): IntArray =
-        GameRuleLogic.greatestSwarmSize(board, playerColor) // TODO important
+        GameRuleLogic.greatestSwarmSize(board, team) // TODO important
+    
+    // TODO test if one player is surrounded he loses
+    override val isOver: Boolean
+        get() = players.any { it.inGoal } && turn.mod(2) == 0 || turn / 2 >= PiranhaConstants.ROUND_LIMIT
+    
+    override val winCondition: WinCondition?
+        get() = TODO("Not yet implemented")
+    
+    override fun performMoveDirectly(move: Move) {
+        if (board.getTeam(move.from) != currentTeam) {
+            throw InvalidMoveException(PiranhaMoveMistake.WRONG_START, move)
+        }
+        checkMove(move)?.let { throw InvalidMoveException(it, move) }
+        val distance = movementDistance(move)
+        board[move.from].state = FieldState.EMPTY
+        board[move.from + move.direction.vector * distance].state = FieldState.from(currentTeam)
+    }
+    
+    fun movementDistance(move: Move): Int {
+        var count = 1
+        var pos = move.from
+        while(true) {
+            pos += move.direction
+            val field = board.getOrNull(pos) ?: break
+            if(field.state.team != null) {
+                count++
+            }
+        }
+        pos = move.from
+        while(true) {
+            pos += move.direction.opposite
+            val field = board.getOrNull(pos) ?: break
+            if(field.state.team != null) {
+                count++
+            }
+        }
+        return count
+    }
+    
+    fun checkMove(move: Move): IMoveMistake? {
+        val distance = movementDistance(move)
+        var pos = move.from
+        var moved = 1
+        while(moved < distance) {
+            pos += move.direction
+            val field = board.getOrNull(pos) ?: return MoveMistake.DESTINATION_OUT_OF_BOUNDS
+            if(field.state.team == otherTeam) {
+                return PiranhaMoveMistake.JUMP_OVER_OPPONENT
+            }
+            moved++
+        }
+        pos += move.direction
+        val state = board.getOrNull(pos)?.state
+        return when(state) {
+            null -> MoveMistake.DESTINATION_OUT_OF_BOUNDS
+            FieldState.OBSTRUCTED -> MoveMistake.DESTINATION_BLOCKED
+            else -> {
+                if(state.team == currentTeam) {
+                    MoveMistake.DESTINATION_BLOCKED_BY_SELF
+                } else {
+                    null
+                }
+            }
+        }
+    }
+    
+    override fun moveIterator(): Iterator<Move> {
+        val piranhas = board.filterValues { field -> field.state.team == currentTeam }
+        val moves = ArrayList<Move>(piranhas.size * 2)
+        for(piranha in piranhas) {
+            for(direction in Direction.values()) {
+                val move = Move(piranha.key, direction)
+                if(checkMove(move) == null) {
+                    moves.add(move)
+                }
+            }
+        }
+        return moves.iterator()
+    }
+    
+    override fun clone(): TwoPlayerGameState<Move> =
+        copy(board = board.clone())
+    
+    override fun teamStats(team: ITeam): List<Stat> = listOf() // TODO
 
-    // TODO implement missing methods - check previous years
 
 }

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

@@ -2,6 +2,9 @@ package sc.plugin2026
 
 import sc.shared.IMoveMistake
 
+/** Spielspezifische Zug-Fehler. Siehe auch [sc.shared.MoveMistake]. */
 enum class PiranhaMoveMistake(override val message: String) : IMoveMistake {
     // TODO relevant bei performMove(Directly)
+    WRONG_START("Das Startfeld ist kein Piranha des eigenen Teams"),
+    JUMP_OVER_OPPONENT("Gegnerische Piranhas können nicht übersprungen werden"),
 }