feat(player): decouple Logic, Starter and PlayerClient

Author: xeruf

player/src/main/sc/player2021/Starter.java

@@ -4,7 +4,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sc.player2021.logic.Logic;
-import sc.plugin2021.AbstractClient;
+import sc.plugin2021.PlayerClient;
 import sc.plugin2021.IGameHandler;
 import sc.shared.SharedConfiguration;
 
@@ -14,22 +14,19 @@
  * Hauptklasse des Clients, die über Konsolenargumente gesteuert werden kann.
  * Sie veranlasst eine Verbindung zum Spielserver.
  */
-public class Starter extends AbstractClient {
+public class Starter {
   private static final Logger logger = LoggerFactory.getLogger(Starter.class);
 
   public Starter(String host, int port, String reservation) {
-    // client starten
-    super(host, port);
-
     // Strategie zuweisen
-    IGameHandler logic = new Logic(this);
-    setHandler(logic);
+    IGameHandler logic = new Logic();
 
     // einem Spiel beitreten
+    PlayerClient client = new PlayerClient(host, port, logic);
     if (reservation == null || reservation.isEmpty()) {
-      joinAnyGame();
+      client.joinAnyGame();
     } else {
-      joinPreparedGame(reservation);
+      client.joinPreparedGame(reservation);
     }
   }
 

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

@@ -20,49 +20,32 @@
 public class Logic implements IGameHandler {
   private static final Logger log = LoggerFactory.getLogger(Logic.class);
 
-  /** Internet Client, der mit dem Spielserver kommuniziert. */
-  private final AbstractClient client;
   /** Aktueller Spielstatus. */
   private GameState gameState;
   /** Aktueller eigener Spieler. */
   private Player currentPlayer;
 
-  /** Erzeugt eine neue Instanz dieser Strategie, die über den mitgegebenen Client Züge absendet. */
-  public Logic(AbstractClient client) {
-    this.client = client;
-  }
-
-  /** {@inheritDoc} */
   public void gameEnded(GameResult data, Team color, String errorMessage) {
     log.info("Das Spiel ist beendet.");
   }
 
-  /** {@inheritDoc} */
   @Override
-  public void onRequestAction() {
+  public Move calculateMove() {
     long startTime = System.currentTimeMillis();
     log.info("Es wurde ein Zug angefordert.");
     List<Move> possibleMoves = new ArrayList<>(GameRuleLogic.getPossibleMoves(gameState));
-    sendAction(possibleMoves.get((int) (Math.random() * possibleMoves.size())));
+    return possibleMoves.get((int) (Math.random() * possibleMoves.size()));
   }
 
-  /** {@inheritDoc} */
   @Override
   public void onUpdate(Player player, Player otherPlayer) {
     currentPlayer = player;
   }
 
-  /** {@inheritDoc} */
   @Override
   public void onUpdate(GameState gameState) {
     this.gameState = gameState;
     log.info("Zug: {} Dran: {}", gameState.getTurn(), gameState.getCurrentPlayer().getColor());
   }
 
-  /** {@inheritDoc} */
-  @Override
-  public void sendAction(Move move) {
-    client.sendMove(move);
-  }
-
 }

plugin/src/client/sc/plugin2021/IGameHandler.kt

@@ -6,9 +6,8 @@ import sc.api.plugins.ITeam
 
 /**
  * Das Interface der Logik.
- * Der GameHandler kommuniziert mit dem Server, d.h.
- * Er bekommt Events (Updates, Anfragen, Spielende) und
- * beantwortet Zuganfragen mit einem entsprechenden Zug.
+ * Der GameHandler definiert Reaktionen auf Ereignisse vom Server,
+ * insbesondere die Reaktion mit einem Zug auf eine Zuganfrage.
  */
 interface IGameHandler {
 
@@ -24,19 +23,9 @@ interface IGameHandler {
     fun onUpdate(gamestate: GameState)
 
     /**
-     * Wird aufgerufen, wenn der Spieler zum Zug aufgefordert wurde.
-     *
-     * @see sendAction
-     */
-    fun onRequestAction()
-    
-    /**
-     * Sendet dem Spielserver den gegebenen Zug.
-     * Diese Funktion sollte auf eine Zuganfrage vom Server folgen.
-     *
-     * @param move zu tätigender Zug
+     * Wird aufgerufen, um die Zuganfrage des Servers zu beantworten
      */
-    fun sendAction(move: Move)
+    fun calculateMove(): Move
 
     /**
      * Wird aufgerufen, wenn das Spiel beendet ist.

plugin/src/client/sc/plugin2021/AbstractClient.kt renamed to plugin/src/client/sc/plugin2021/PlayerClient.kt

@@ -1,7 +1,6 @@
 package sc.plugin2021
 
 import org.slf4j.LoggerFactory
-import sc.api.plugins.IGamePlugin
 import sc.api.plugins.IGameState
 import sc.framework.plugins.protocol.MoveRequest
 import sc.networking.clients.AbstractLobbyClientListener
@@ -20,19 +19,17 @@ 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.
  */
-abstract class AbstractClient(
+class PlayerClient(
         host: String,
-        port: Int
+        port: Int,
+        private val handler: IGameHandler
 ): AbstractLobbyClientListener() {
     companion object {
-        private val logger = LoggerFactory.getLogger(AbstractClient::class.java)
+        private val logger = LoggerFactory.getLogger(PlayerClient::class.java)
     }
 
     var isGameOver = false
 
-    /** The handler reacts to messages from the server received by the lobby client. */
-    protected var handler: IGameHandler? = null
-    
     /** The lobby client that connects to the room. Stops on connection failure. */
     private val client: LobbyClient = try {
         LobbyClient(host, port)
@@ -58,11 +55,11 @@ abstract class AbstractClient(
 
     /** 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 -> handler?.onRequestAction()
+            is MoveRequest -> sendMove(handler.calculateMove())
             is WelcomeMessage -> team = Team.valueOf(data.color.toUpperCase())
         }
-        this.roomId = roomId
     }
 
     /** Sends the selected move to the server. */
@@ -87,11 +84,11 @@ abstract class AbstractClient(
             return
 
         if (gameState.currentTeam == team) {
-            handler?.onUpdate(gameState.currentPlayer, gameState.otherPlayer)
+            handler.onUpdate(gameState.currentPlayer, gameState.otherPlayer)
         } else {
-            handler?.onUpdate(gameState.otherPlayer, gameState.currentPlayer)
+            handler.onUpdate(gameState.otherPlayer, gameState.currentPlayer)
         }
-        handler?.onUpdate(gameState)
+        handler.onUpdate(gameState)
     }
 
     /** Start the LobbyClient [client] and listen to it. */
@@ -114,7 +111,7 @@ abstract class AbstractClient(
     override fun onGameOver(roomId: String, data: GameResult) {
         logger.info("$this: Game over with result $data")
         isGameOver = true
-        handler?.gameEnded(data, team, error)
+        handler.gameEnded(data, team, error)
     }
 
     fun joinPreparedGame(reservation: String) {