fix(plugin): ensure that PassMoves throw and throws remove players (#277)

* `PassMove`s now throw a respective `InvalidMoveException`
* Thrown `InvalidMoveException`s were caught and used to set violation flags:
  -> This is now included into the winner list and `WinCondition` calculation
* `WinCondition` calculation now also includes `getPossibleMoves` to check if the current color still has moves

Author: anarchuser

plugin/src/server/sc/plugin2021/Game.kt

@@ -41,14 +41,22 @@ class Game(UUID: String = GamePlugin.PLUGIN_UUID): RoundBasedGameInstance<Player
     }
 
     override fun getWinners(): MutableList<Player> {
-        val winCondition = checkWinCondition()
-        if (winCondition != null)
-            return winCondition.winner.let{players}
+        if (players.first().violated) {
+            if (players.last().violated)
+                return mutableListOf()
+            return players.subList(1, 2)
+        }
+        if (players.last().violated)
+            return players.subList(0, 1)
+        
+        val first = gameState.getPointsForPlayer(players.first().color)
+        val second = gameState.getPointsForPlayer(players.last().color)
 
-        // If no win condition is met, the player with highest score wins.
-        return listOfNotNull(players.maxBy {
-            gameState.getPointsForPlayer(it.color)
-        }).toMutableList()
+        if (first > second)
+            return players.subList(0, 1)
+        if (first < second)
+            return players.subList(1, 2)
+        return players
     }
 
     override fun getPlayerScores(): MutableList<PlayerScore> =
@@ -64,8 +72,9 @@ class Game(UUID: String = GamePlugin.PLUGIN_UUID): RoundBasedGameInstance<Player
      * the player with the highest cumulative score of its colors
      */
     override fun checkWinCondition(): WinCondition? {
-        if (gameState.orderedColors.isNotEmpty())
-            return null
+        if (gameState.orderedColors.any {
+            GameRuleLogic.getPossibleMoves(gameState).isNotEmpty()
+        }) return null
 
         val scoreMap: Map<Team, Int> = Team.values().map {
             it to gameState.getPointsForPlayer(it)
@@ -114,28 +123,28 @@ class Game(UUID: String = GamePlugin.PLUGIN_UUID): RoundBasedGameInstance<Player
                 opponent.hasSoftTimeout() ||
                 opponent.hasHardTimeout())
             score = Constants.WIN_SCORE
-        
-        when {
-            player.hasSoftTimeout() -> {
-                cause = ScoreCause.SOFT_TIMEOUT
-                reason = "Der Spieler hat innerhalb von ${getTimeoutFor(player).softTimeout / 1000} Sekunden nach Aufforderung keinen Zug gesendet"
-            }
-            player.hasHardTimeout() -> {
-                cause = ScoreCause.SOFT_TIMEOUT
-                reason = "Der Spieler hat innerhalb von ${getTimeoutFor(player).hardTimeout / 1000} Sekunden nach Aufforderung keinen Zug gesendet"
+        else
+            when {
+                player.hasSoftTimeout() -> {
+                    cause = ScoreCause.SOFT_TIMEOUT
+                    reason = "Der Spieler hat innerhalb von ${getTimeoutFor(player).softTimeout / 1000} Sekunden nach Aufforderung keinen Zug gesendet"
+                }
+                player.hasHardTimeout() -> {
+                    cause = ScoreCause.SOFT_TIMEOUT
+                    reason = "Der Spieler hat innerhalb von ${getTimeoutFor(player).hardTimeout / 1000} Sekunden nach Aufforderung keinen Zug gesendet"
+                }
+                player.hasViolated() -> {
+                    cause = ScoreCause.RULE_VIOLATION
+                    reason = player.violationReason!!
+                }
+                player.hasLeft() -> {
+                    cause = ScoreCause.LEFT
+                    reason = "Der Spieler hat das Spiel verlassen"
+                }
+                else -> {
+                    score = Constants.DRAW_SCORE
+                }
             }
-            player.hasViolated() -> {
-                cause = ScoreCause.RULE_VIOLATION
-                reason = player.violationReason!!
-            }
-            player.hasLeft() -> {
-                cause = ScoreCause.LEFT
-                reason = "Der Spieler hat das Spiel verlassen"
-            }
-            else -> {
-                score = Constants.DRAW_SCORE
-            }
-        }
         return PlayerScore(cause, reason, score, points)
     }
 

plugin/src/shared/sc/plugin2021/util/GameRuleLogic.kt

@@ -33,7 +33,7 @@ object GameRuleLogic {
 
         when (move) {
             is PassMove -> {
-                gameState.removeActiveColor()
+                throw InvalidMoveException("Color ${move.color} intentionally passed out", move)
             }
             is SetMove -> {
                 if (Constants.VALIDATE_MOVE)

plugin/src/test/sc/plugin2021/GameRuleLogicTest.kt

@@ -97,15 +97,12 @@ class GameRuleLogicTest: StringSpec({
         val perfectPieces = allPieces.reversed()
         GameRuleLogic.getPointsFromDeployedPieces(perfectPieces) shouldBe 20
     }
-    "PassMoves let you pass out" {
-        val gameState = GameState()
+    "After the color check, PassMoves throw" {
+        val state = GameState()
         assertThrows<InvalidMoveException> {
-            GameRuleLogic.performMove(gameState, PassMove(Color.RED))
+            GameRuleLogic.performMove(state, PassMove(Color.BLUE))
         }
-        assertDoesNotThrow {
-            GameRuleLogic.performMove(gameState, PassMove(Color.BLUE))
-        }
-        gameState.orderedColors.size shouldBe 3
+        state.orderedColors.size shouldBe 4
     }
     "All possible start moves get calculated" {
         val piece = PieceShape.PENTO_W

plugin/src/test/sc/plugin2021/GameStateTest.kt

@@ -100,21 +100,4 @@ class GameStateTest: StringSpec({
         gameState.round shouldBe 4
         gameState.currentColor shouldBe Color.BLUE
     }
-    "Passed out colors behave correctly"  {
-        val gameState = GameState(startTurn = 2)
-        gameState.orderedColors shouldBe listOf(Color.BLUE, Color.YELLOW, Color.RED, Color.GREEN)
-        gameState.currentColor  shouldBe Color.RED
-        
-        GameRuleLogic.performMove(gameState, PassMove(Color.RED))
-        gameState.orderedColors shouldBe listOf(Color.BLUE, Color.YELLOW, Color.GREEN)
-        gameState.currentColor  shouldBe Color.GREEN
-        
-        GameRuleLogic.performMove(gameState, PassMove(Color.GREEN))
-        gameState.orderedColors shouldBe listOf(Color.BLUE, Color.YELLOW)
-        gameState.currentColor  shouldBe Color.BLUE
-        
-        GameRuleLogic.performMove(gameState, PassMove(Color.BLUE))
-        gameState.orderedColors shouldBe listOf(Color.YELLOW)
-        gameState.currentColor  shouldBe Color.YELLOW
-    }
 })

plugin/src/test/sc/plugin2021/GameTest.kt

@@ -1,25 +1,39 @@
 package sc.plugin2021
 
+import io.kotlintest.matchers.collections.shouldContainExactly
 import io.kotlintest.shouldBe
 import io.kotlintest.specs.StringSpec
+import org.junit.jupiter.api.assertThrows
 import sc.plugin2020.util.Constants
+import sc.shared.InvalidMoveException
 import sc.shared.PlayerScore
 import sc.shared.ScoreCause
 
 class GameTest: StringSpec({
-    "Game starting and stopping works" {
+    "Game starting works" {
         Color.BLUE.team
         val game = Game()
         val state = game.gameState
-        game.onPlayerJoined().color shouldBe Team.ONE
-        game.onPlayerJoined().color shouldBe Team.TWO
+        val first = game.onPlayerJoined()
+        val second = game.onPlayerJoined()
+        
+        first.color  shouldBe Team.ONE
+        second.color shouldBe Team.TWO
 
         game.start()
-        game.onAction(state.currentPlayer, PassMove(state.currentColor))
-        game.onAction(state.currentPlayer, PassMove(state.currentColor))
-        game.onAction(state.currentPlayer, PassMove(state.currentColor))
-        game.onAction(state.currentPlayer, PassMove(state.currentColor))
 
-        game.playerScores shouldBe List(2) { PlayerScore(ScoreCause.REGULAR, "", Constants.DRAW_SCORE, -178) }
+        val e: InvalidMoveException = assertThrows {
+            state.currentPlayer shouldBe first
+            state.currentColor  shouldBe Color.BLUE
+            game.onAction(state.currentPlayer, PassMove(state.currentColor))
+        }
+    
+        println(game.winners)
+        game.winners shouldBe listOf(second)
+        
+        game.playerScores shouldContainExactly listOf(
+                PlayerScore(ScoreCause.RULE_VIOLATION, e.message, Constants.LOSE_SCORE, -178),
+                PlayerScore(ScoreCause.REGULAR, "", Constants.WIN_SCORE, -178)
+        )
     }
 })

plugin/src/test/sc/plugin2021/ManualGameTest.kts

@@ -45,7 +45,6 @@ fun loop() {
                 game.onAction(game.gameState.getPlayer(move.color.team), move)
                 current = game.gameState.getOpponent(current)!!
             } catch (e: Exception) {
-                println(e)
                 if (move is SetMove) {
                     println("Piece was:")
                     printShapes(move.piece.shape)