fix(player): simplify IGameHandler

Author: xeruf

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

@@ -5,43 +5,42 @@
 import sc.api.plugins.TwoPlayerGameState;
 import sc.framework.plugins.Player;
 import sc.player.IGameHandler;
-import sc.plugin2021.*;
+import sc.plugin2021.GameState;
+import sc.plugin2021.Move;
 import sc.plugin2021.util.GameRuleLogic;
 import sc.shared.GameResult;
 
-import java.util.List;
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Das Herz des Clients:
  * Eine sehr simple Logik, die ihre Zuege zufaellig waehlt,
  * aber gueltige Zuege macht.
- *
+ * <p>
  * Ausserdem werden zum Spielverlauf Konsolenausgaben gemacht.
  */
 public class Logic implements IGameHandler {
   private static final Logger log = LoggerFactory.getLogger(Logic.class);
 
   /** Aktueller Spielstatus. */
   private GameState gameState;
-  /** Aktueller eigener Spieler. */
-  private Player currentPlayer;
 
-  public void gameEnded(GameResult data, String errorMessage) {
+  public void onGameOver(GameResult data, String errorMessage) {
     log.info("Das Spiel ist beendet, Ergebnis: {}", data);
   }
 
   @Override
   public Move calculateMove() {
     long startTime = System.currentTimeMillis();
-    log.info("Es wurde ein Zug angefordert.");
+    Player player = gameState.getCurrentPlayer();
+    log.info("Es wurde ein Zug von {} angefordert.", player);
+
     List<Move> possibleMoves = new ArrayList<>(GameRuleLogic.getPossibleMoves(gameState));
-    return possibleMoves.get((int) (Math.random() * possibleMoves.size()));
-  }
+    Move move = possibleMoves.get((int) (Math.random() * possibleMoves.size()));
 
-  @Override
-  public void onUpdate(Player player, Player otherPlayer) {
-    currentPlayer = player;
+    log.info("Sende {} nach {}ms.", move, System.currentTimeMillis() - startTime);
+    return move;
   }
 
   @Override

sdk/src/player/sc/player/IGameHandler.kt

@@ -12,28 +12,18 @@ import sc.shared.GameResult
  */
 interface IGameHandler {
 
-    /**
-     * Wird aufgerufen, wenn Spieler aktualisiert werden.
-     *
-     * @param player      eigener Spieler
-     * @param otherPlayer anderer Spieler
-     */
-    fun onUpdate(player: Player, otherPlayer: Player)
-    
     /** Wird aufgerufen, wenn sich das Spielbrett ändert. */
     fun onUpdate(gamestate: TwoPlayerGameState<*>)
 
-    /**
-     * Wird aufgerufen, um die Zuganfrage des Servers zu beantworten
-     */
+    /** Wird aufgerufen, um die Zuganfrage des Servers zu beantworten. */
     fun calculateMove(): IMove
 
     /**
      * Wird aufgerufen, wenn das Spiel beendet ist.
      *
      * @param data         Das Spielergebnis
-     * @param errorMessage Optionale Fehlernachricht
+     * @param errorMessage Eventuelle Fehlernachricht
      */
-    fun gameEnded(data: GameResult, errorMessage: String?)
+    fun onGameOver(data: GameResult, errorMessage: String?)
 
 }

sdk/src/player/sc/player/PlayerClient.kt

@@ -4,21 +4,16 @@ import org.slf4j.LoggerFactory
 import sc.api.plugins.*
 import sc.framework.plugins.protocol.MoveRequest
 import sc.networking.clients.AbstractLobbyClientListener
-import sc.networking.clients.IControllableGame
-import sc.networking.clients.ILobbyClientListener
 import sc.networking.clients.LobbyClient
-import sc.protocol.responses.GamePreparedResponse
 import sc.protocol.responses.ProtocolErrorMessage
 import sc.protocol.responses.ProtocolMessage
 import sc.shared.GameResult
-import sc.shared.WelcomeMessage
 import java.net.ConnectException
-import java.util.ServiceLoader
 import kotlin.system.exitProcess
 
 /**
- * Eine abstrakte Implementation des [ILobbyClientListener].
- * Hier sind alle Methoden implementiert, die unabhängig von der Logik der Clients der Spieler sind.
+ * Eine Implementation des [AbstractLobbyClientListener],
+ * um die Server-Kommunikation mit der Logik der Spieler zu verbinden.
  */
 class PlayerClient(
         host: String,
@@ -46,16 +41,11 @@ class PlayerClient(
     /** Current room of the player. */
     private lateinit var roomId: String
 
-    /** The team the client belongs to. Needed to connect client and player. */
-    var teamName: String? = null
-        private set
-    
     /** Called for any new message sent to the game room, e.g., move requests. */
     override fun onRoomMessage(roomId: String, data: ProtocolMessage) {
         this.roomId = roomId
         when (data) {
             is MoveRequest -> sendMove(handler.calculateMove())
-            is WelcomeMessage -> teamName = data.color
         }
     }
 
@@ -76,15 +66,7 @@ class PlayerClient(
     override fun onNewState(roomId: String, state: IGameState) {
         val gameState = state as TwoPlayerGameState<*>
         logger.debug("$this got a new state $gameState")
-        
-        teamName?.let { teamName ->
-            if (gameState.currentTeam.name == teamName) {
-                handler.onUpdate(gameState.currentPlayer, gameState.otherPlayer)
-            } else {
-                handler.onUpdate(gameState.otherPlayer, gameState.currentPlayer)
-            }
-            handler.onUpdate(gameState)
-        }
+        handler.onUpdate(gameState)
     }
 
     /** Start the LobbyClient [client] and listen to it. */
@@ -107,7 +89,7 @@ class PlayerClient(
     override fun onGameOver(roomId: String, data: GameResult) {
         logger.info("$this: Game over with result $data")
         isGameOver = true
-        handler.gameEnded(data, error)
+        handler.onGameOver(data, error)
     }
 
     fun joinPreparedGame(reservation: String) {