rework: simplify plugin & start migration to season 2022

Author: xeruf

player/src/main/sc/player2021/logic/Logic.java

@@ -5,9 +5,8 @@
 import sc.api.plugins.TwoPlayerGameState;
 import sc.framework.plugins.Player;
 import sc.player.IGameHandler;
-import sc.plugin2021.GameState;
-import sc.plugin2021.Move;
-import sc.plugin2021.util.GameRuleLogic;
+import sc.plugin2022.GameState;
+import sc.plugin2022.Move;
 import sc.shared.GameResult;
 
 import java.util.ArrayList;
@@ -33,20 +32,19 @@ public void onGameOver(GameResult data, String errorMessage) {
   @Override
   public Move calculateMove() {
     long startTime = System.currentTimeMillis();
-    Player player = gameState.getCurrentPlayer();
-    log.info("Es wurde ein Zug von {} angefordert.", player);
+    log.info("Es wurde ein Zug von {} angefordert.", gameState.getCurrentTeam());
 
-    List<Move> possibleMoves = new ArrayList<>(GameRuleLogic.getPossibleMoves(gameState));
+    List<Move> possibleMoves = gameState.getPossibleMoves();
     Move move = possibleMoves.get((int) (Math.random() * possibleMoves.size()));
 
     log.info("Sende {} nach {}ms.", move, System.currentTimeMillis() - startTime);
     return move;
   }
 
   @Override
-  public void onUpdate(TwoPlayerGameState<?> gameState) {
+  public void onUpdate(TwoPlayerGameState gameState) {
     this.gameState = (GameState) gameState;
-    log.info("Zug: {} Dran: {}", gameState.getTurn(), gameState.getCurrentPlayer().getColor());
+    log.info("Zug: {} Dran: {}", gameState.getTurn(), gameState.getCurrentTeam());
   }
 
 }

plugin/build.gradle.kts

@@ -2,7 +2,7 @@ val game: String by project
 
 sourceSets {
     main {
-        java.setSrcDirs(listOf("src/shared", "src/client", "src/server"))
+        java.setSrcDirs(listOf("src/main"))
         resources.setSrcDirs(listOf("src/resources"))
     }
     test {

plugin/src/main/sc/plugin2022/Board.kt

@@ -0,0 +1,70 @@
+package sc.plugin2022
+
+import com.thoughtworks.xstream.annotations.XStreamAlias
+import sc.api.plugins.IBoard
+import sc.api.plugins.ITeam
+import sc.api.plugins.Team
+import sc.plugin2022.util.Constants.boardrange
+import sc.plugin2022.util.MoveMistake
+import sc.shared.InvalidMoveException
+
+/** Das Spielbrett besteht aus 8x8 Feldern. */
+@XStreamAlias(value = "board")
+data class Board(
+        private val board: MutableMap<Coordinates, Piece>,
+): IBoard, Map<Coordinates, Piece> by board {
+    
+    constructor(): this(generateBoard())
+    
+    /** Gibt das Feld an den gegebenen Koordinaten zurück. */
+    operator fun get(x: Int, y: Int) =
+            get(Coordinates(x, y))
+    
+    /** Moves a piece according to [Move].
+     * @throws InvalidMoveException if something is wrong with the Move.
+     * @return the moved [Piece], null if it turned into an amber. */
+    @Throws(InvalidMoveException::class)
+    fun movePiece(move: Move): Piece? =
+            board[move.start]?.let { piece ->
+                if (move.delta !in piece.possibleMoves)
+                    throw InvalidMoveException(MoveMistake.INVALID_MOVEMENT, move)
+                board[move.destination]?.let { piece.capture(it) }
+                board.remove(move.start)
+                if (piece.isAmber || (piece.type.isLight && move.destination.y == piece.team.opponent().startLine)) {
+                    board.remove(move.destination)
+                    null
+                } else {
+                    board[move.destination] = piece
+                    piece
+                }
+            } ?: throw InvalidMoveException(MoveMistake.START_EMPTY, move)
+    
+    override fun toString() =
+            boardrange.joinToString("\n") { y ->
+                boardrange.joinToString("") { x ->
+                    get(x, y)?.shortString() ?: "--"
+                }
+            }
+    
+    override fun clone() = Board(HashMap(board))
+    
+    companion object {
+        @JvmStatic
+        fun generateBoard() =
+                (PieceType.values() + PieceType.values()).let { pieces ->
+                    pieces.shuffle()
+                    pieces.withIndex().flatMap { (index, type) ->
+                        Team.values().map { team ->
+                            createField(team, index, type)
+                        }
+                    }.toMap(HashMap())
+                }
+        
+        @JvmStatic
+        fun createField(team: ITeam, x: Int, type: PieceType) =
+                Coordinates(if (team.index == 0) x else boardrange.last - x, team.startLine) to Piece(type, team)
+    }
+}
+
+val ITeam.startLine
+    get() = index * boardrange.last

plugin/src/shared/sc/plugin2021/Color.kt renamed to plugin/src/main/sc/plugin2022/Color.kt

@@ -1,6 +1,7 @@
-package sc.plugin2021
+package sc.plugin2022
 
 import com.thoughtworks.xstream.annotations.XStreamAlias
+import sc.api.plugins.Team
 
 /** Die vier verschiedenen Farben im Spiel. */
 @XStreamAlias(value = "color")
@@ -26,14 +27,6 @@ enum class Color {
             YELLOW, GREEN -> Team.TWO
         }
 
-    /** @return [FieldContent], der dieser Farbe entspricht. */
-    operator fun unaryPlus(): FieldContent = when (this) {
-        BLUE -> FieldContent.BLUE
-        YELLOW -> FieldContent.YELLOW
-        RED -> FieldContent.RED
-        GREEN -> FieldContent.GREEN
-    }
-    
     override fun toString() = "Farbe $german"
 
     val german: String

plugin/src/shared/sc/plugin2021/Coordinates.kt renamed to plugin/src/main/sc/plugin2022/Coordinates.kt

@@ -1,7 +1,8 @@
-package sc.plugin2021
+package sc.plugin2022
 
 import com.thoughtworks.xstream.annotations.XStreamAlias
 import com.thoughtworks.xstream.annotations.XStreamAsAttribute
+import sc.plugin2022.util.Constants
 import kotlin.math.min
 
 /** Eine 2D Koordinate der Form (x, y). */
@@ -27,14 +28,15 @@ data class Coordinates(
     /** Wandelt die [Coordinates] in einen entsprechenden [Vector]. */
     operator fun unaryPlus(): Vector = Vector(x, y)
 
-    /** Gibt ein Set der vier Ecken dieser Koordinaten zurück. */
-    val corners: Set<Coordinates>
-        get() = Vector.diagonals.mapTo(HashSet()) { this + it }
-
     /** Gibt ein Set der vier benachbarten Felder dieser Koordinaten zurück. */
     val neighbors: Set<Coordinates>
         get() = Vector.cardinals.mapTo(HashSet()) { this + it }
-
+    
+    /** Whether these coordinates mark a field on the board. */
+    val isValid =
+            x >= 0 && x < Constants.BOARD_SIZE &&
+            y >= 0 && y < Constants.BOARD_SIZE
+    
     companion object {
         /** Der Ursprung des Koordinatensystems (0, 0). */
         val origin = Coordinates(0, 0)
@@ -64,19 +66,19 @@ data class Vector(val dx: Int, val dy: Int) {
     operator fun compareTo(other: Vector): Int =
             min(other.dx - dx, other.dy - dy)
 
-    /** Konvertiert den Vektor zu entsprechendn [Coordinates]. */
+    /** Konvertiert den Vektor zu entsprechenden [Coordinates]. */
     operator fun unaryPlus(): Coordinates = Coordinates(dx, dy)
 
     companion object {
         /** Die vier Vektoren in diagonaler Richtung. */
-        val diagonals: Set<Vector> = setOf(
+        val diagonals: Array<Vector> = arrayOf(
                 Vector(-1, -1),
                 Vector(-1, 1),
                 Vector(1, -1),
                 Vector(1, 1)
         )
         /** Die vier Vektoren in kardinaler Richtung. */
-        val cardinals: Set<Vector> = setOf(
+        val cardinals: Array<Vector> = arrayOf(
                 Vector(-1, 0),
                 Vector(0, -1),
                 Vector(1, 0),

plugin/src/server/sc/plugin2021/Game.kt renamed to plugin/src/main/sc/plugin2022/Game.kt

@@ -1,14 +1,15 @@
-package sc.plugin2021
+package sc.plugin2022
 
 import org.slf4j.LoggerFactory
+import sc.api.plugins.ITeam
+import sc.api.plugins.Team
 import sc.api.plugins.exceptions.TooManyPlayersException
 import sc.framework.plugins.AbstractGame
 import sc.framework.plugins.ActionTimeout
 import sc.framework.plugins.Player
-import sc.plugin2021.util.Constants
-import sc.plugin2021.util.GameRuleLogic
-import sc.plugin2021.util.MoveMistake
-import sc.plugin2021.util.WinReason
+import sc.plugin2022.util.Constants
+import sc.plugin2022.util.MoveMistake
+import sc.plugin2022.util.WinReason
 import sc.protocol.room.RoomMessage
 import sc.shared.InvalidMoveException
 import sc.shared.PlayerScore
@@ -20,14 +21,13 @@ class Game(override val currentState: GameState = GameState()): AbstractGame<Pla
         val logger = LoggerFactory.getLogger(Game::class.java)
     }
 
-    private val availableTeams = mutableListOf(Team.ONE, Team.TWO)
+    private val availableTeams = ArrayDeque<ITeam>().also { it.addAll(Team.values()) }
     override fun onPlayerJoined(): Player {
         if (availableTeams.isEmpty())
             throw TooManyPlayersException()
-        val player = currentState.getPlayer(availableTeams.removeAt(0))
 
+        val player = Player(availableTeams.removeFirst())
         players.add(player)
-        currentState.addPlayer(player)
         return player
     }
 
@@ -41,8 +41,8 @@ class Game(override val currentState: GameState = GameState()): AbstractGame<Pla
             if (players.last().hasViolated())
                 return players.subList(0, 1)
 
-            val first = currentState.getPointsForPlayer(players.first().color)
-            val second = currentState.getPointsForPlayer(players.last().color)
+            val first = currentState.getPointsForTeam(players.first().team)
+            val second = currentState.getPointsForTeam(players.last().team)
 
             if (first > second)
                 return players.subList(0, 1)
@@ -55,7 +55,7 @@ class Game(override val currentState: GameState = GameState()): AbstractGame<Pla
         get() = players.mapTo(ArrayList(players.size)) { getScoreFor(it) }
 
     val isGameOver: Boolean
-        get() = !currentState.hasValidColors() || currentState.round > Constants.ROUND_LIMIT
+        get() = currentState.isOver
 
     /**
      * Checks whether and why the game is over.
@@ -65,10 +65,10 @@ class Game(override val currentState: GameState = GameState()): AbstractGame<Pla
     override fun checkWinCondition(): WinCondition? {
         if (!isGameOver) return null
 
-        val scores: Map<Team, Int> = Team.values().map {
-            it to currentState.getPointsForPlayer(it)
-        }.toMap()
-        
+        val scores: Map<Team, Int> = Team.values().associate {
+            it to currentState.getPointsForTeam(it)
+        }
+    
         return when {
             scores.getValue(Team.ONE) > scores.getValue(Team.TWO) -> WinCondition(Team.ONE, WinReason.DIFFERING_SCORES)
             scores.getValue(Team.ONE) < scores.getValue(Team.TWO) -> WinCondition(Team.TWO, WinReason.DIFFERING_SCORES)
@@ -77,15 +77,15 @@ class Game(override val currentState: GameState = GameState()): AbstractGame<Pla
     }
 
     override fun getScoreFor(player: Player): PlayerScore {
-        val team = player.color as Team
+        val team = player.team as Team
         logger.debug("Get score for player $team (violated: ${if (player.hasViolated()) "yes" else "no"})")
-        val opponent = currentState.getOpponent(player)
+        val opponent = players[team.opponent().index]
         val winCondition = checkWinCondition()
 
         var cause: ScoreCause = ScoreCause.REGULAR
         var reason = ""
         var score: Int = Constants.LOSE_SCORE
-        val points = currentState.getPointsForPlayer(team)
+        val points = currentState.getPointsForTeam(team)
 
         // Is the game already finished?
         if (winCondition?.reason == WinReason.EQUAL_SCORE)
@@ -126,16 +126,14 @@ class Game(override val currentState: GameState = GameState()): AbstractGame<Pla
             ActionTimeout(true, Constants.HARD_TIMEOUT, Constants.SOFT_TIMEOUT)
 
     @Throws(InvalidMoveException::class)
-    override fun onRoundBasedAction(fromPlayer: Player, data: RoomMessage) {
+    override fun onRoundBasedAction(data: RoomMessage) {
         if (data !is Move)
             throw InvalidMoveException(MoveMistake.INVALID_FORMAT)
 
-        logger.debug("Current State: $currentState")
-        logger.debug("Performing Move $data")
-        GameRuleLogic.performMove(currentState, data)
-        GameRuleLogic.removeInvalidColors(currentState)
-        next(if (isGameOver) null else currentState.currentPlayer)
-        logger.debug("Current Board:\n${currentState.board}")
+        logger.debug("Performing $data")
+        currentState.performMove(data)
+        next()
+        logger.debug("Current State: ${currentState.longString()}")
     }
 
     override fun toString(): String =

plugin/src/server/sc/plugin2021/GamePlugin.kt renamed to plugin/src/main/sc/plugin2022/GamePlugin.kt

@@ -1,9 +1,9 @@
-package sc.plugin2021
+package sc.plugin2022
 
 import sc.api.plugins.IGameInstance
 import sc.api.plugins.IGamePlugin
 import sc.api.plugins.IGameState
-import sc.plugin2021.util.Constants
+import sc.plugin2022.util.Constants
 import sc.plugins.PluginDescriptor
 import sc.shared.ScoreAggregation
 import sc.shared.ScoreDefinition
@@ -16,7 +16,8 @@ class GamePlugin: IGamePlugin {
         val scoreDefinition: ScoreDefinition =
                 ScoreDefinition(arrayOf(
                         ScoreFragment("Gewinner"),
-                        ScoreFragment("\u2205 Punkte", ScoreAggregation.AVERAGE)
+                        ScoreFragment("Bernsteine", ScoreAggregation.AVERAGE),
+                        ScoreFragment("Figur vorne", ScoreAggregation.AVERAGE)
                 ))
     }
 

plugin/src/main/sc/plugin2022/GameState.kt

@@ -0,0 +1,61 @@
+package sc.plugin2022
+
+import com.thoughtworks.xstream.annotations.XStreamAlias
+import com.thoughtworks.xstream.annotations.XStreamAsAttribute
+import sc.api.plugins.ITeam
+import sc.api.plugins.Team
+import sc.api.plugins.TwoPlayerGameState
+import sc.plugin2022.util.Constants
+import java.util.EnumMap
+
+/**
+ * Der aktuelle Spielstand.
+ *
+ * Er hält alle Informationen zur momentanen Runde,
+ * mit deren Hilfe der nächste Zug berechnet werden kann.
+ */
+@XStreamAlias(value = "state")
+class GameState @JvmOverloads constructor(
+        /** Das aktuelle Spielfeld. */
+        override val board: Board = Board(),
+        /** Die Anzahl an bereits getätigten Zügen. */
+        @XStreamAsAttribute override var turn: Int = 0,
+        /** Der zuletzt gespielte Zug. */
+        override var lastMove: Move? = null,
+        private val ambers: EnumMap<Team, Int> = EnumMap(Team::class.java),
+): TwoPlayerGameState(Team.ONE) {
+    
+    constructor(other: GameState): this(other.board.clone(), other.turn, other.lastMove, other.ambers.clone())
+    
+    fun performMove(move: Move) {
+        if (board.movePiece(move) == null)
+            ambers[currentTeam as Team] = (ambers[currentTeam] ?: 0) + 1
+        turn++
+    }
+    
+    val currentPieces
+        get() = board.filterValues { it.team == currentTeam }
+    
+    val possibleMoves
+        get() = currentPieces.flatMap { (pos, piece) ->
+            piece.possibleMoves.mapNotNull {
+                Move.create(pos, it)
+            }
+        }
+    
+    val isOver
+        get() = round > Constants.ROUND_LIMIT || ambers.any { it.value >= 2 }
+    
+    /** Berechne die Punkteanzahl für das gegebene Team. */
+    override fun getPointsForTeam(team: ITeam): Int =
+            ambers[team]!!
+    
+    override fun clone() = GameState(this)
+    
+    override fun toString(): String =
+            "GameState $round/$turn -> ${currentTeam.color} (ambers: $ambers)"
+    
+}
+
+val ITeam.color
+    get() = if (index == 0) "Rot" else "Blau"