feat(plugin): implement double ambers

Author: xeruf

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

@@ -22,30 +22,34 @@ data class Board(
 
     /** Moves a piece according to [Move] after verification.
      * @throws InvalidMoveException if something is wrong with the Move.
-     * @return the moved [Piece], null if it turned into an amber. */
+     * @return number of ambers if any */
     @Throws(InvalidMoveException::class)
-    fun movePiece(move: Move): Piece? =
+    fun movePiece(move: Move): Int =
             (piecePositions[move.start] ?: throw InvalidMoveException(MoveMistake.START_EMPTY, move)).let { piece ->
-                if(!move.destination.isValid)
+                if (!move.destination.isValid)
                     throw InvalidMoveException(MoveMistake.OUT_OF_BOUNDS, move)
                 if (move.delta !in piece.possibleMoves)
                     throw InvalidMoveException(MoveMistake.INVALID_MOVEMENT, move)
                 piecePositions[move.destination]?.let {
-                    if(it.team == piece.team)
+                    if (it.team == piece.team)
                         throw InvalidMoveException(MoveMistake.DESTINATION_BLOCKED, move)
                     piece.capture(it)
                 }
                 piecePositions.remove(move.start)
-                if (piece.isAmber || (piece.type.isLight && move.destination.y == piece.team.opponent().startLine)) {
-                    // TODO how to indicate double amber?
-                    piecePositions.remove(move.destination)
-                    null
-                } else {
-                    piecePositions[move.destination] = piece
-                    piece
-                }
+                piecePositions[move.destination] = piece
+                checkAmber(move.destination)
             }
 
+    /** Checks whether the piece at [position] should be turned into an amber
+     * and if yes, removes it.
+     * @return number of ambers */
+    fun checkAmber(position: Coordinates): Int =
+        piecePositions[position]?.let { piece ->
+            arrayOf(piece.isAmber, piece.type.isLight && position.y == piece.team.opponent().startLine)
+                    .sumBy { if(it) 1 else 0 }
+                    .also { if(it > 0) piecePositions.remove(position) }
+        } ?: 0
+    
     override fun toString() =
             boardrange.joinToString("\n") { y ->
                 boardrange.joinToString("") { x ->

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

@@ -28,8 +28,8 @@ data class GameState @JvmOverloads constructor(
     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
+        ambers[currentTeam as Team] = (ambers[currentTeam] ?: 0) +
+                                      board.movePiece(move)
         turn++
     }
 

plugin/src/test/sc/plugin2022/BoardTest.kt

@@ -7,8 +7,6 @@ import io.kotest.matchers.collections.shouldBeOneOf
 import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
 import io.kotest.matchers.maps.shouldBeEmpty
 import io.kotest.matchers.maps.shouldHaveSize
-import io.kotest.matchers.maps.shouldNotBeEmpty
-import io.kotest.matchers.nulls.shouldBeNull
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.string.shouldHaveLineCount
 import io.kotest.matchers.string.shouldNotContain
@@ -67,20 +65,20 @@ class BoardTest: FunSpec({
             test("not for other team") {
                 val moewe = Piece(Moewe, Team.TWO)
                 val board = Board(mutableMapOf(coords to moewe))
-                board.movePiece(Move(coords, coords.copy(y = 7))) shouldBe moewe
-                board.shouldNotBeEmpty()
+                board.movePiece(Move(0 y 6, 0 y 7)) shouldBe 0
+                board shouldHaveSize 1
             }
             test("from position")  {
                 val moewe = Piece(Moewe, Team.ONE)
                 val board = Board(mutableMapOf(coords to moewe))
-                board.movePiece(Move(coords, coords.copy(y = 7))).shouldBeNull()
+                board.movePiece(Move(0 y 6, 0 y 7)) shouldBe 1
                 board.shouldBeEmpty()
             }
             test("not from Robbe in position") {
                 val robbe = Piece(Robbe, Team.ONE)
                 val board = Board(mutableMapOf(coords to robbe))
-                board.movePiece(Move(coords, Coordinates(2, 7))) shouldBe robbe
-                board.shouldNotBeEmpty()
+                board.movePiece(Move(0 y 6, 2 y 7)) shouldBe 0
+                board shouldHaveSize 1
             }
             context("from tower") {
                 val board = makeBoard(0 y 1 to "M", 0 y 0 to "S2", 1 y 0 to "m", 1 y 1 to "r")
@@ -90,11 +88,10 @@ class BoardTest: FunSpec({
                     }.mistake shouldBe MoveMistake.DESTINATION_BLOCKED
                 }
                 test("move tower") {
-                    board.movePiece(Move(0 y 0, 1 y 1)).shouldBeNull()
+                    board.movePiece(Move(0 y 0, 1 y 1)) shouldBe 1
                 }
                 test("move onto tower") {
-                    // TODO that should be a double amber
-                    board.movePiece(Move(1 y 0, 0 y 0)).shouldBeNull()
+                    board.movePiece(Move(1 y 0, 0 y 0)) shouldBe 2
                 }
             }
         }