refactor(plugin): plugin-specific MoveMistake class naming without dots in strings

xeruf · xeruf · commit 298043c51b2a · 2024-05-21T22:59:12.000+03:00
diff --git a/plugin/src/main/kotlin/sc/plugin2024/GameState.kt b/plugin/src/main/kotlin/sc/plugin2024/GameState.kt
@@ -9,7 +9,7 @@ import sc.plugin2024.actions.Advance
 import sc.plugin2024.actions.Push
 import sc.plugin2024.actions.Turn
 import sc.plugin2024.mistake.AdvanceProblem
-import sc.plugin2024.mistake.MoveMistake
+import sc.plugin2024.mistake.MQMoveMistake
 import sc.plugin2024.util.MQConstants
 import sc.plugin2024.util.MQConstants.POINTS_PER_SEGMENT
 import sc.plugin2024.util.MQWinReason
@@ -90,7 +90,7 @@ data class GameState @JvmOverloads constructor(
      * @throws InvalidMoveException wenn der Zug ungültig ist
      */
     override fun performMoveDirectly(move: Move) {
-        if(move.actions.isEmpty()) throw InvalidMoveException(MoveMistake.NO_ACTIONS)
+        if(move.actions.isEmpty()) throw InvalidMoveException(MQMoveMistake.NO_ACTIONS)
         
         val actions = move.actions.fold(ArrayList<Action>()) { acc, act ->
             val last = acc.lastOrNull()
@@ -103,16 +103,16 @@ data class GameState @JvmOverloads constructor(
         }
         actions.forEachIndexed { index, action ->
             when {
-                board[currentShip.position] == Field.SANDBANK && index != 0 -> throw InvalidMoveException(MoveMistake.SAND_BANK_END, move)
-                mustPush && action !is Push -> throw InvalidMoveException(MoveMistake.PUSH_ACTION_REQUIRED, move)
-                action is Accelerate && index != 0 -> throw InvalidMoveException(MoveMistake.FIRST_ACTION_ACCELERATE, move)
+                board[currentShip.position] == Field.SANDBANK && index != 0 -> throw InvalidMoveException(MQMoveMistake.SAND_BANK_END, move)
+                mustPush && action !is Push -> throw InvalidMoveException(MQMoveMistake.PUSH_ACTION_REQUIRED, move)
+                action is Accelerate && index != 0 -> throw InvalidMoveException(MQMoveMistake.FIRST_ACTION_ACCELERATE, move)
                 else -> action.perform(this)?.let { throw InvalidMoveException(it, move) }
             }
         }
         
         when {
-            currentShip.movement > 0 -> throw InvalidMoveException(MoveMistake.MOVEMENT_POINTS_LEFT, move)
-            currentShip.movement < 0 -> throw InvalidMoveException(MoveMistake.MOVEMENT_POINTS_MISSING, move)
+            currentShip.movement > 0 -> throw InvalidMoveException(MQMoveMistake.MOVEMENT_POINTS_LEFT, move)
+            currentShip.movement < 0 -> throw InvalidMoveException(MQMoveMistake.MOVEMENT_POINTS_MISSING, move)
         }
         
         board.pickupPassenger(currentShip)
diff --git a/plugin/src/main/kotlin/sc/plugin2024/mistake/MQMoveMistake.kt b/plugin/src/main/kotlin/sc/plugin2024/mistake/MQMoveMistake.kt
@@ -0,0 +1,12 @@
+package sc.plugin2024.mistake
+
+import sc.shared.IMoveMistake
+
+enum class MQMoveMistake(override val message: String) : IMoveMistake {
+    NO_ACTIONS("Der Zug enthält keine Aktionen"),
+    PUSH_ACTION_REQUIRED("Wenn du auf einem gegnerischen Schiff landest, muss darauf eine Abdrängaktion folgen"),
+    SAND_BANK_END("Zug auf eine Sandbank muss letzte Aktion sein"),
+    FIRST_ACTION_ACCELERATE("Du kannst nur in der ersten Aktion beschleunigen"),
+    MOVEMENT_POINTS_LEFT("Es sind noch Bewegungspunkte übrig"),
+    MOVEMENT_POINTS_MISSING("Nicht genug Bewegungspunkte");
+}
diff --git a/plugin/src/main/kotlin/sc/plugin2024/mistake/MoveMistake.kt b/plugin/src/main/kotlin/sc/plugin2024/mistake/MoveMistake.kt
diff --git a/plugin/src/main/kotlin/sc/plugin2025/Advance.kt b/plugin/src/main/kotlin/sc/plugin2025/Advance.kt
@@ -26,7 +26,7 @@ class Advance(@XStreamAsAttribute val distance: Int, vararg val cards: Card): Hu
         var bought = false
         return cards.firstNotNullOfOrNull {
             if(bought)
-                return MoveMistake.MUST_BUY_ONE_CARD
+                return HuIMoveMistake.MUST_BUY_ONE_CARD
             if(state.currentField == Field.MARKET) {
                 return@firstNotNullOfOrNull player.consumeCarrots(10) ?: run {
                     bought = true
@@ -35,13 +35,13 @@ class Advance(@XStreamAsAttribute val distance: Int, vararg val cards: Card): Hu
                 }
             }
             if(state.currentField != Field.HARE || lastCard?.moves == false)
-                return MoveMistake.CANNOT_PLAY_CARD
+                return HuIMoveMistake.CANNOT_PLAY_CARD
             lastCard = it
             it.perform(state)
-        } ?: MoveMistake.MUST_BUY_ONE_CARD.takeIf {
+        } ?: HuIMoveMistake.MUST_BUY_ONE_CARD.takeIf {
             // On Market field and no card bought or just moved there through card
             state.currentField == Field.MARKET && !bought
-        } ?: MoveMistake.MUST_PLAY_CARD.takeIf {
+        } ?: HuIMoveMistake.MUST_PLAY_CARD.takeIf {
             // On Hare field and no card played or just moved there through card
             state.currentField == Field.HARE && lastCard?.moves != false
         }
diff --git a/plugin/src/main/kotlin/sc/plugin2025/Card.kt b/plugin/src/main/kotlin/sc/plugin2025/Card.kt
@@ -5,25 +5,25 @@ import sc.shared.IMoveMistake
 
 /** Mögliche Aktionen, die durch das Ausspielen einer Karte ausgelöst werden können. */
 @XStreamAlias(value = "card")
-enum class Card(val moves: Boolean, val playable: (GameState) -> MoveMistake?, val play: (GameState) -> Unit): HuIMove {
+enum class Card(val moves: Boolean, val playable: (GameState) -> HuIMoveMistake?, val play: (GameState) -> Unit): HuIMove {
     /** Falle hinter den Gegenspieler. */
     FALL_BACK(true,
         { state ->
-            MoveMistake.CANNOT_PLAY_FALL_BACK.takeUnless { state.isAhead() }
+            HuIMoveMistake.CANNOT_PLAY_FALL_BACK.takeUnless { state.isAhead() }
             ?: state.validateTargetField(state.otherPlayer.position - 1)
         },
         { it.moveToField(it.otherPlayer.position - 1) }),
     /** Rücke vor den Gegenspieler. */
     HURRY_AHEAD(true,
         { state ->
-            MoveMistake.CANNOT_PLAY_HURRY_AHEAD.takeIf { state.isAhead() }
+            HuIMoveMistake.CANNOT_PLAY_HURRY_AHEAD.takeIf { state.isAhead() }
             ?: state.validateTargetField(state.otherPlayer.position + 1)
         },
         { it.moveToField(it.otherPlayer.position + 1) }),
     /** Friss sofort einen Salat. */
     EAT_SALAD(
         false,
-        { state -> MoveMistake.NO_SALAD.takeUnless { state.currentPlayer.salads > 0 } },
+        { state -> HuIMoveMistake.NO_SALAD.takeUnless { state.currentPlayer.salads > 0 } },
         { it.eatSalad() }),
     /** Karottenvorrat mit dem Gegner tauschen. */
     SWAP_CARROTS(false,
@@ -36,9 +36,9 @@ enum class Card(val moves: Boolean, val playable: (GameState) -> MoveMistake?, v
     
     override fun perform(state: GameState): IMoveMistake? {
         if(state.currentField != Field.HARE)
-            return MoveMistake.CANNOT_PLAY_CARD
+            return HuIMoveMistake.CANNOT_PLAY_CARD
         if(!state.currentPlayer.removeCard(this))
-            return MoveMistake.CARD_NOT_OWNED
+            return HuIMoveMistake.CARD_NOT_OWNED
         return playable(state) ?: run {
             play(state)
             null
diff --git a/plugin/src/main/kotlin/sc/plugin2025/EatSalad.kt b/plugin/src/main/kotlin/sc/plugin2025/EatSalad.kt
@@ -18,7 +18,7 @@ object EatSalad: HuIMove {
             state.eatSalad()
             return null
         } else {
-            return MoveMistake.CANNOT_EAT_SALAD
+            return HuIMoveMistake.CANNOT_EAT_SALAD
         }
     }
     
diff --git a/plugin/src/main/kotlin/sc/plugin2025/ExchangeCarrots.kt b/plugin/src/main/kotlin/sc/plugin2025/ExchangeCarrots.kt
@@ -15,7 +15,7 @@ data class ExchangeCarrots(val value: Int): HuIMove {
             state.currentPlayer.carrots += value
             return null
         } else {
-            return MoveMistake.CANNOT_EXCHANGE_CARROTS
+            return HuIMoveMistake.CANNOT_EXCHANGE_CARROTS
         }
     }
 }
diff --git a/plugin/src/main/kotlin/sc/plugin2025/FallBack.kt b/plugin/src/main/kotlin/sc/plugin2025/FallBack.kt
@@ -10,14 +10,14 @@ import com.thoughtworks.xstream.annotations.XStreamAlias
  */
 @XStreamAlias(value = "fallBack")
 object FallBack: HuIMove {
-    override fun perform(state: GameState): MoveMistake? {
+    override fun perform(state: GameState): HuIMoveMistake? {
         val previousFieldIndex = state.nextFallBack()
         if(previousFieldIndex != null) {
             state.currentPlayer.carrots += 10 * (state.currentPlayer.position - previousFieldIndex)
             state.currentPlayer.position = previousFieldIndex
             return null
         } else {
-            return MoveMistake.CANNOT_FALL_BACK
+            return HuIMoveMistake.CANNOT_FALL_BACK
         }
     }
     
diff --git a/plugin/src/main/kotlin/sc/plugin2025/GameState.kt b/plugin/src/main/kotlin/sc/plugin2025/GameState.kt
@@ -131,7 +131,7 @@ data class GameState @JvmOverloads constructor(
     
     override fun performMoveDirectly(move: HuIMove) {
         val mist =
-            MoveMistake.MUST_EAT_SALAD.takeIf {
+            HuIMoveMistake.MUST_EAT_SALAD.takeIf {
                 mustEatSalad() && move != EatSalad
             }.also { currentPlayer.saladEaten = false } ?: move.perform(this)
         if(mist != null)
@@ -160,37 +160,37 @@ data class GameState @JvmOverloads constructor(
         }
     }
     
-    fun moveToField(newPosition: Int, player: Hare = currentPlayer): MoveMistake? =
+    fun moveToField(newPosition: Int, player: Hare = currentPlayer): HuIMoveMistake? =
         validateTargetField(newPosition, player) ?: run {
             player.position = newPosition
             null
         }
     
     /** Basic validation whether a player may move forward by that distance.
      * Does not validate whether a card can be played on hare field. */
-    fun checkAdvance(distance: Int, player: Hare = currentPlayer): MoveMistake? {
+    fun checkAdvance(distance: Int, player: Hare = currentPlayer): HuIMoveMistake? {
         return validateTargetField(
             player.position + distance,
             player,
-            (player.carrots - calculateCarrots(distance)).takeIf { it >= 0 } ?: return MoveMistake.MISSING_CARROTS
+            (player.carrots - calculateCarrots(distance)).takeIf { it >= 0 } ?: return HuIMoveMistake.MISSING_CARROTS
         )
     }
     
     /** Basic validation whether a field may be entered via a jump that is not backward.
      * Does not validate whether a card can be played on hare field. */
-    fun validateTargetField(newPosition: Int, player: Hare = currentPlayer, carrots: Int = player.carrots): MoveMistake? {
+    fun validateTargetField(newPosition: Int, player: Hare = currentPlayer, carrots: Int = player.carrots): HuIMoveMistake? {
         if(newPosition == 0)
-            return MoveMistake.CANNOT_ENTER_FIELD
+            return HuIMoveMistake.CANNOT_ENTER_FIELD
         val field = board.getField(newPosition)
         if(field != Field.GOAL && newPosition == player.opponent.position)
-            return MoveMistake.FIELD_OCCUPIED
+            return HuIMoveMistake.FIELD_OCCUPIED
         when(field) {
-            Field.SALAD -> player.salads > 0 || return MoveMistake.NO_SALAD
-            Field.MARKET -> carrots >= 10 || return MoveMistake.MISSING_CARROTS
-            Field.HARE -> player.getCards().isNotEmpty() || return MoveMistake.CARD_NOT_OWNED
-            Field.GOAL -> carrots <= 10 && player.salads == 0 || return MoveMistake.GOAL_CONDITIONS
-            Field.HEDGEHOG -> return MoveMistake.HEDGEHOG_ONLY_BACKWARDS
-            null -> return MoveMistake.FIELD_NONEXISTENT
+            Field.SALAD -> player.salads > 0 || return HuIMoveMistake.NO_SALAD
+            Field.MARKET -> carrots >= 10 || return HuIMoveMistake.MISSING_CARROTS
+            Field.HARE -> player.getCards().isNotEmpty() || return HuIMoveMistake.CARD_NOT_OWNED
+            Field.GOAL -> carrots <= 10 && player.salads == 0 || return HuIMoveMistake.GOAL_CONDITIONS
+            Field.HEDGEHOG -> return HuIMoveMistake.HEDGEHOG_ONLY_BACKWARDS
+            null -> return HuIMoveMistake.FIELD_NONEXISTENT
             else -> return null
         }
         return null
diff --git a/plugin/src/main/kotlin/sc/plugin2025/Hare.kt b/plugin/src/main/kotlin/sc/plugin2025/Hare.kt
@@ -32,9 +32,9 @@ data class Hare(
         position += distance
     }
     
-    fun consumeCarrots(count: Int): MoveMistake? =
+    fun consumeCarrots(count: Int): HuIMoveMistake? =
         if(carrots < count) {
-            MoveMistake.MISSING_CARROTS
+            HuIMoveMistake.MISSING_CARROTS
         } else {
             carrots -= count
             null
diff --git a/plugin/src/main/kotlin/sc/plugin2025/HuIMoveMistake.kt b/plugin/src/main/kotlin/sc/plugin2025/HuIMoveMistake.kt
@@ -0,0 +1,25 @@
+package sc.plugin2025
+
+import sc.shared.IMoveMistake
+
+enum class HuIMoveMistake(override val message: String) : IMoveMistake {
+    GOAL_CONDITIONS("Voraussetzungen für Zielfeld nicht erfüllt"),
+    NO_SALAD("Kein Salat verfügbar"),
+    MISSING_CARROTS("Nicht genügend Karotten"),
+    MUST_EAT_SALAD("Auf einem Salatfeld muss ein Salat gegessen werden"),
+    CANNOT_ENTER_FIELD("Feld kann nicht betreten werden"),
+    FIELD_OCCUPIED("Das Feld ist besetzt"),
+    FIELD_NONEXISTENT("Das Feld existiert nicht"),
+    HEDGEHOG_ONLY_BACKWARDS("Ein Igelfeld kann nur mit einem Rückwärtzug betreten werden"),
+    CANNOT_MOVE_FORWARD("Vorwärtszug ist nicht möglich"),
+    CANNOT_FALL_BACK("Rückwärtszug ist nicht möglich"),
+    CANNOT_EAT_SALAD("Es kann gerade kein Salat gegessen werden"),
+    CANNOT_EXCHANGE_CARROTS("Karottentauschen kann nicht mit dieser Karottenanzahl gespielt werden"),
+    
+    MUST_BUY_ONE_CARD("Auf einem Marktfeld muss genau eine Karte gekauft werden"),
+    MUST_PLAY_CARD("Beim Betreten eines Hasenfeldes muss eine Hasenkarte gespielt werden"),
+    CARD_NOT_OWNED("Karte kann nicht gespielt werden, da nicht im Besitz"),
+    CANNOT_PLAY_CARD("Karte kann nicht gespielt werden"),
+    CANNOT_PLAY_FALL_BACK("Rückzugskarte nicht spielbar"),
+    CANNOT_PLAY_HURRY_AHEAD("Vorwärtssprungkarte nicht spielbar"),
+}
diff --git a/plugin/src/main/kotlin/sc/plugin2025/MoveMistake.kt b/plugin/src/main/kotlin/sc/plugin2025/MoveMistake.kt
diff --git a/plugin/src/main/kotlin/sc/plugin2025/util/Constants.kt b/plugin/src/main/kotlin/sc/plugin2025/util/Constants.kt
@@ -3,7 +3,9 @@ package sc.plugin2025.util
 /** Eine Sammlung an verschiedenen Konstanten, die im Spiel verwendet werden. */
 object HuIConstants {
     const val NUM_FIELDS: Int = 65
+    
     const val INITIAL_SALADS: Int = 5
     const val INITIAL_CARROTS: Int = 68
+    
     const val ROUND_LIMIT: Int = 30
 }
diff --git a/plugin/src/test/kotlin/sc/plugin2024/GameResultTest.kt b/plugin/src/test/kotlin/sc/plugin2024/GameResultTest.kt
@@ -11,7 +11,7 @@ import sc.helpers.testXStream
 import sc.plugin2024.actions.Accelerate
 import sc.plugin2024.actions.Advance
 import sc.plugin2024.actions.Turn
-import sc.plugin2024.mistake.MoveMistake
+import sc.plugin2024.mistake.MQMoveMistake
 import sc.plugin2024.util.GamePlugin
 import sc.shared.InvalidMoveException
 import sc.shared.Violation
@@ -89,7 +89,7 @@ class GameResultTest: WordSpec({
         game.currentState.performMoveDirectly(Move(Accelerate(2), Advance(3)))
         game.currentState.performMoveDirectly(Move(Accelerate(1), Advance(1), Turn(CubeDirection.DOWN_RIGHT), Advance(1)))
         "work with violation result" {
-            game.players.first().violation = Violation.RULE_VIOLATION(InvalidMoveException(MoveMistake.NO_ACTIONS, Move()))
+            game.players.first().violation = Violation.RULE_VIOLATION(InvalidMoveException(MQMoveMistake.NO_ACTIONS, Move()))
             game.getResult() shouldSerializeTo """
                 <result>
                   <definition>
diff --git a/plugin/src/test/kotlin/sc/plugin2024/GameStateTest.kt b/plugin/src/test/kotlin/sc/plugin2024/GameStateTest.kt
@@ -19,7 +19,7 @@ import sc.plugin2024.actions.Advance
 import sc.plugin2024.actions.Push
 import sc.plugin2024.actions.Turn
 import sc.plugin2024.mistake.AdvanceProblem
-import sc.plugin2024.mistake.MoveMistake
+import sc.plugin2024.mistake.MQMoveMistake
 import sc.plugin2024.util.MQConstants
 import sc.shared.InvalidMoveException
 
@@ -264,7 +264,7 @@ class GameStateTest: FunSpec({
                         state.performMove(Move(Accelerate(3), Advance(4)))
                         state.performMove(Move(Accelerate(4), Advance(5)))
                     }
-                    shouldThrow<InvalidMoveException> { state.performMove(Move(Accelerate(2), Advance(3))) }.mistake shouldBe MoveMistake.MOVEMENT_POINTS_LEFT
+                    shouldThrow<InvalidMoveException> { state.performMove(Move(Accelerate(2), Advance(3))) }.mistake shouldBe MQMoveMistake.MOVEMENT_POINTS_LEFT
                     shouldThrow<InvalidMoveException> { state.performMove(Move(Accelerate(2), Advance(4))) }.mistake shouldBe AdvanceProblem.MOVEMENT_POINTS_MISSING
                 }
             }
diff --git a/plugin/src/test/kotlin/sc/plugin2025/MoveTest.kt b/plugin/src/test/kotlin/sc/plugin2025/MoveTest.kt
@@ -13,9 +13,9 @@ class MoveTest: WordSpec({
         
         state.checkAdvance(1) shouldBe null
         state.checkAdvance(2) shouldBe null
-        state.checkAdvance(3) shouldBe MoveMistake.CARD_NOT_OWNED
-        state.checkAdvance(4) shouldBe MoveMistake.GOAL_CONDITIONS
-        state.checkAdvance(5) shouldBe MoveMistake.FIELD_NONEXISTENT
+        state.checkAdvance(3) shouldBe HuIMoveMistake.CARD_NOT_OWNED
+        state.checkAdvance(4) shouldBe HuIMoveMistake.GOAL_CONDITIONS
+        state.checkAdvance(5) shouldBe HuIMoveMistake.FIELD_NONEXISTENT
         
         state.getSensibleMoves() shouldBe listOf(
             *Card.values().map { Advance(1, it) }.toTypedArray(),
@@ -25,10 +25,10 @@ class MoveTest: WordSpec({
         state.performMoveDirectly(Advance(2))
         state.turn shouldBe 1
         
-        state.checkAdvance(2) shouldBe MoveMistake.FIELD_OCCUPIED
-        state.checkAdvance(3) shouldBe MoveMistake.CARD_NOT_OWNED
-        state.checkAdvance(4) shouldBe MoveMistake.GOAL_CONDITIONS
-        state.checkAdvance(5) shouldBe MoveMistake.FIELD_NONEXISTENT
+        state.checkAdvance(2) shouldBe HuIMoveMistake.FIELD_OCCUPIED
+        state.checkAdvance(3) shouldBe HuIMoveMistake.CARD_NOT_OWNED
+        state.checkAdvance(4) shouldBe HuIMoveMistake.GOAL_CONDITIONS
+        state.checkAdvance(5) shouldBe HuIMoveMistake.FIELD_NONEXISTENT
         "one player advanced" should {
             "allow eat salad" {
                 state.currentPlayer.addCard(Card.EAT_SALAD)
@@ -88,7 +88,7 @@ class MoveTest: WordSpec({
             
             "allow fallback and buy" {
                 state.checkAdvance(3) shouldBe null
-                Advance(3, Card.FALL_BACK).perform(state.clone()) shouldBe MoveMistake.MUST_BUY_ONE_CARD
+                Advance(3, Card.FALL_BACK).perform(state.clone()) shouldBe HuIMoveMistake.MUST_BUY_ONE_CARD
                 state.cloneCurrentPlayer { it.position = 1 }.nextCards() shouldBe Card.values().map { listOf(it) }
                 state.cloneCurrentPlayer { it.position = 3 }.nextCards() shouldBe Card.values().map { listOf(Card.FALL_BACK, it) }
                 
diff --git a/server/src/test/java/sc/server/plugins/TestGameState.kt b/server/src/test/java/sc/server/plugins/TestGameState.kt
@@ -23,6 +23,9 @@ data class TestGameState(
     override fun moveIterator(): Iterator<IMove> =
             throw NotImplementedError("TestGame has no Moves")
     
+    override fun teamStats(team: ITeam): List<Pair<String, Int>> =
+            throw NotImplementedError("TestGame has no teamStats")
+    
     override val round get() = turn / 2
     
     val red = Player(Team.ONE)

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ object EatSalad: HuIMove {`
`18`	`18`	`state.eatSalad()`
`19`	`19`	`return null`
`20`	`20`	`} else {`
`21`		`- return MoveMistake.CANNOT_EAT_SALAD`
	`21`	`+ return HuIMoveMistake.CANNOT_EAT_SALAD`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ data class ExchangeCarrots(val value: Int): HuIMove {`
`15`	`15`	`state.currentPlayer.carrots += value`
`16`	`16`	`return null`
`17`	`17`	`} else {`
`18`		`- return MoveMistake.CANNOT_EXCHANGE_CARROTS`
	`18`	`+ return HuIMoveMistake.CANNOT_EXCHANGE_CARROTS`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`	`}`