fix: only pass IMove as player action

xeruf · xeruf · commit 340a73fad428 · 2021-05-28T16:19:48.000+02:00
diff --git a/plugin/src/server/sc/plugin2021/Game.kt b/plugin/src/server/sc/plugin2021/Game.kt
@@ -1,6 +1,7 @@
 package sc.plugin2021
 
 import org.slf4j.LoggerFactory
+import sc.api.plugins.IMove
 import sc.api.plugins.exceptions.TooManyPlayersException
 import sc.framework.plugins.AbstractGame
 import sc.framework.plugins.ActionTimeout
@@ -9,7 +10,6 @@ import sc.plugin2021.util.Constants
 import sc.plugin2021.util.GameRuleLogic
 import sc.plugin2021.util.MoveMistake
 import sc.plugin2021.util.WinReason
-import sc.protocol.room.RoomMessage
 import sc.shared.InvalidMoveException
 import sc.shared.PlayerScore
 import sc.shared.ScoreCause
@@ -126,13 +126,13 @@ 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) {
-        if (data !is Move)
+    override fun onRoundBasedAction(fromPlayer: Player, move: IMove) {
+        if (move !is Move)
             throw InvalidMoveException(MoveMistake.INVALID_FORMAT)
         
         logger.debug("Current State: $currentState")
-        logger.debug("Performing Move $data")
-        GameRuleLogic.performMove(currentState, data)
+        logger.debug("Performing Move $move")
+        GameRuleLogic.performMove(currentState, move)
         GameRuleLogic.removeInvalidColors(currentState)
         next(if (isGameOver) null else currentState.currentPlayer)
         logger.debug("Current Board:\n${currentState.board}")
diff --git a/sdk/src/server-api/sc/api/plugins/IGameInstance.kt b/sdk/src/server-api/sc/api/plugins/IGameInstance.kt
@@ -3,7 +3,6 @@ package sc.api.plugins
 import sc.api.plugins.exceptions.GameLogicException
 import sc.api.plugins.host.IGameListener
 import sc.framework.plugins.Player
-import sc.protocol.room.RoomMessage
 import sc.shared.InvalidMoveException
 import sc.shared.PlayerScore
 import sc.shared.ScoreCause
@@ -15,16 +14,15 @@ interface IGameInstance {
     fun onPlayerLeft(player: Player, cause: ScoreCause? = null)
 
     /**
-     * Called by the Server once an action was received.
+     * Called by the Server upon receiving a Move.
      *
      * @param fromPlayer The player who invoked this action.
-     * @param data       ProtocolMessage with the action
      *
      * @throws GameLogicException   if any invalid action is done
      * @throws InvalidMoveException if the received move violates the rules
      */
     @Throws(GameLogicException::class, InvalidMoveException::class)
-    fun onAction(fromPlayer: Player, data: RoomMessage)
+    fun onAction(fromPlayer: Player, move: IMove)
     fun addGameListener(listener: IGameListener)
     fun removeGameListener(listener: IGameListener)
 
diff --git a/sdk/src/server-api/sc/framework/plugins/AbstractGame.kt b/sdk/src/server-api/sc/framework/plugins/AbstractGame.kt
@@ -3,10 +3,10 @@ package sc.framework.plugins
 import org.slf4j.LoggerFactory
 import sc.api.plugins.IGameInstance
 import sc.api.plugins.IGameState
+import sc.api.plugins.IMove
 import sc.api.plugins.exceptions.GameLogicException
 import sc.api.plugins.exceptions.NotYourTurnException
 import sc.api.plugins.host.IGameListener
-import sc.protocol.room.RoomMessage
 import sc.shared.*
 
 abstract class AbstractGame<P : Player>(override val pluginUUID: String) : IGameInstance {
@@ -31,18 +31,15 @@ abstract class AbstractGame<P : Player>(override val pluginUUID: String) : IGame
     }
     
     /**
-     * Called by the Server once an action was received.
-     *
-     * @param fromPlayer The player who invoked this action.
-     * @param data       The plugin-specific data.
+     * Called by the Server upon receiving a Move.
      *
      * @throws GameLogicException if no move has been requested from the given [Player]
      * @throws InvalidMoveException when the given Move is not possible
      */
     @Throws(GameLogicException::class, InvalidMoveException::class)
-    override fun onAction(fromPlayer: Player, data: RoomMessage) {
+    override fun onAction(fromPlayer: Player, move: IMove) {
         if (fromPlayer != activePlayer)
-            throw NotYourTurnException(activePlayer, fromPlayer, data)
+            throw NotYourTurnException(activePlayer, fromPlayer, move)
         moveRequestTimeout?.let { timer ->
             timer.stop()
             logger.info("Time needed for move: " + timer.timeDiff)
@@ -51,14 +48,14 @@ abstract class AbstractGame<P : Player>(override val pluginUUID: String) : IGame
                 fromPlayer.softTimeout = true
                 onPlayerLeft(fromPlayer, ScoreCause.SOFT_TIMEOUT)
             } else {
-                onRoundBasedAction(fromPlayer, data)
+                onRoundBasedAction(fromPlayer, move)
             }
-        } ?: throw GameLogicException("We didn't request a move from you yet.")
+        } ?: throw GameLogicException("Move from $fromPlayer has not been requested.")
     }
 
     /** Called by [onAction] to execute a move of a Player. */
     @Throws(InvalidMoveException::class)
-    abstract fun onRoundBasedAction(fromPlayer: Player, data: RoomMessage)
+    abstract fun onRoundBasedAction(fromPlayer: Player, move: IMove)
 
     /**
      * Returns a WinCondition if the Game is over.
diff --git a/server/src/sc/server/Lobby.kt b/server/src/sc/server/Lobby.kt
@@ -1,6 +1,7 @@
 package sc.server
 
 import org.slf4j.LoggerFactory
+import sc.api.plugins.IMove
 import sc.api.plugins.exceptions.GameRoomException
 import sc.api.plugins.exceptions.RescuableClientException
 import sc.protocol.requests.*
@@ -35,7 +36,10 @@ class Lobby: GameRoomManager(), Closeable, IClientRequestListener {
             is RoomPacket -> {
                 // i.e. new move
                 val room = this.findRoom(packet.roomId)
-                room.onEvent(source, packet.data)
+                val move = packet.data
+                if(move !is IMove)
+                    throw GameRoomException("Received non-move packet: $packet")
+                room.onEvent(source, move)
             }
             is JoinPreparedRoomRequest ->
                 ReservationManager.redeemReservationCode(source, packet.reservationCode)
diff --git a/server/src/sc/server/gaming/GameRoom.java b/server/src/sc/server/gaming/GameRoom.java
@@ -5,6 +5,7 @@
 import org.slf4j.LoggerFactory;
 import sc.api.plugins.IGameInstance;
 import sc.api.plugins.IGameState;
+import sc.api.plugins.IMove;
 import sc.api.plugins.exceptions.GameException;
 import sc.api.plugins.exceptions.GameLogicException;
 import sc.api.plugins.exceptions.GameRoomException;
@@ -310,27 +311,27 @@ public synchronized List<String> reserveSlots(SlotDescriptor[] descriptors) {
    * Execute received action.
    *
    * @param source Client which caused the event
-   * @param data   ProtocolMessage containing the action
+   * @param move   ProtocolMessage containing the action
    */
-  public synchronized void onEvent(Client source, RoomMessage data) throws GameRoomException {
+  public synchronized void onEvent(Client source, IMove move) throws GameRoomException {
     if (isOver())
-      throw new GameException("Game is already over, but got " + data);
+      throw new GameException("Game is already over, but got " + move);
 
     Player player = resolvePlayer(source);
     try {
-      game.onAction(player, data);
+      game.onAction(player, move);
     } catch (InvalidMoveException e) {
       final String error = String.format("Ungueltiger Zug von '%s'.\n%s", player.getDisplayName(), e);
       logger.error(error);
       player.setViolationReason(e.getMessage());
-      ErrorMessage errorMessage = new ErrorMessage(data, error);
+      ErrorMessage errorMessage = new ErrorMessage(move, error);
       player.notifyListeners(errorMessage);
       observerBroadcast(errorMessage);
       history.add(errorMessage);
       game.onPlayerLeft(player, ScoreCause.RULE_VIOLATION);
       throw new GameLogicException(e.toString(), e);
     } catch (GameLogicException e) {
-      player.notifyListeners(new ErrorMessage(data, e.getMessage()));
+      player.notifyListeners(new ErrorMessage(move, e.getMessage()));
       throw e;
     }
   }
diff --git a/server/test/sc/server/plugins/TestGame.kt b/server/test/sc/server/plugins/TestGame.kt
@@ -1,10 +1,10 @@
 package sc.server.plugins
 
+import sc.api.plugins.IMove
 import sc.api.plugins.exceptions.TooManyPlayersException
 import sc.framework.plugins.AbstractGame
 import sc.framework.plugins.ActionTimeout
 import sc.framework.plugins.Player
-import sc.protocol.room.RoomMessage
 import sc.server.helpers.TestTeam
 import sc.shared.*
 
@@ -15,11 +15,13 @@ data class TestGame(
     override val playerScores: List<PlayerScore> = emptyList()
     override val winners: List<Player> = emptyList()
     
-    override fun onRoundBasedAction(fromPlayer: Player, data: RoomMessage) {
-        if (data is TestMove) {
-            data.perform(currentState)
-            next(if (currentState.currentPlayer === TestTeam.RED) currentState.red else currentState.blue)
-        } else throw InvalidMoveException(TestMoveMistake.INVALID_FORMAT)
+    override fun onRoundBasedAction(fromPlayer: Player, move: IMove) {
+        if (move !is TestMove)
+            throw InvalidMoveException(object: IMoveMistake {
+                override val message = "TestGame only processes TestMove"
+            })
+        move.perform(currentState)
+        next(if (currentState.currentPlayer === TestTeam.RED) currentState.red else currentState.blue)
     }
 
     override fun checkWinCondition(): WinCondition? {
diff --git a/server/test/sc/server/plugins/TestMoveMistake.kt b/server/test/sc/server/plugins/TestMoveMistake.kt
