feat: extract player functionality of LobbyClient

Author: xeruf

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

@@ -3,12 +3,15 @@
 import jargs.gnu.CmdLineParser;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import sc.player2021.logic.Logic;
-import sc.player.PlayerClient;
+import sc.api.plugins.IGamePlugin;
+import sc.networking.clients.LobbyClient;
 import sc.player.IGameHandler;
+import sc.player.IPlayerClient;
+import sc.player2021.logic.Logic;
 import sc.shared.SharedConfiguration;
 
 import java.io.File;
+import java.io.IOException;
 
 /**
  * Hauptklasse des Clients, die über Konsolenargumente gesteuert werden kann.
@@ -17,18 +20,18 @@
 public class Starter {
   private static final Logger logger = LoggerFactory.getLogger(Starter.class);
 
-  public Starter(String host, int port, String reservation, String roomId) {
+  public Starter(String host, int port, String reservation, String roomId) throws IOException {
     // Strategie zuweisen
     IGameHandler logic = new Logic();
-    PlayerClient client = new PlayerClient(host, port, logic);
+    IPlayerClient client = new LobbyClient(host, port).asPlayer(logic);
 
     // einem Spiel beitreten
     if (reservation != null && !reservation.isEmpty()) {
-      client.joinPreparedGame(reservation);
+      client.joinGameWithReservation(reservation);
     } else if (roomId != null) {
       client.joinGameRoom(roomId);
     } else {
-      client.joinAnyGame();
+      client.joinGame(IGamePlugin.loadPluginId());
     }
   }
 

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

@@ -2,14 +2,12 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import sc.api.plugins.TwoPlayerGameState;
-import sc.framework.plugins.Player;
+import sc.api.plugins.IGameState;
 import sc.player.IGameHandler;
 import sc.plugin2022.GameState;
 import sc.plugin2022.Move;
 import sc.shared.GameResult;
 
-import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -25,7 +23,7 @@ public class Logic implements IGameHandler {
   /** Aktueller Spielstatus. */
   private GameState gameState;
 
-  public void onGameOver(GameResult data, String errorMessage) {
+  public void onGameOver(GameResult data) {
     log.info("Das Spiel ist beendet, Ergebnis: {}", data);
   }
 
@@ -42,9 +40,13 @@ public Move calculateMove() {
   }
 
   @Override
-  public void onUpdate(TwoPlayerGameState gameState) {
+  public void onUpdate(IGameState gameState) {
     this.gameState = (GameState) gameState;
     log.info("Zug: {} Dran: {}", gameState.getTurn(), gameState.getCurrentTeam());
   }
 
+  @Override
+  public void onError(String error) {
+    log.warn("Fehler: {}", error);
+  }
 }

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

@@ -1,8 +1,7 @@
 package sc.player
 
+import sc.api.plugins.IGameState
 import sc.api.plugins.IMove
-import sc.api.plugins.TwoPlayerGameState
-import sc.framework.plugins.Player
 import sc.shared.GameResult
 
 /**
@@ -13,17 +12,15 @@ import sc.shared.GameResult
 interface IGameHandler {
 
     /** Wird aufgerufen, wenn sich das Spielbrett ändert. */
-    fun onUpdate(gameState: TwoPlayerGameState)
+    fun onUpdate(gameState: IGameState)
 
     /** 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 Eventuelle Fehlernachricht
-     */
-    fun onGameOver(data: GameResult, errorMessage: String?)
+    /** Wird aufgerufen, wenn das Spiel beendet ist. */
+    fun onGameOver(data: GameResult)
+    
+    /** Wird aufgerufen, wenn der Server einen Fehler meldet*/
+    fun onError(error: String)
 
 }

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

@@ -1,102 +1,51 @@
 package sc.player
 
-import org.slf4j.LoggerFactory
-import sc.api.plugins.*
 import sc.framework.plugins.protocol.MoveRequest
-import sc.networking.clients.AbstractLobbyClientListener
-import sc.networking.clients.LobbyClient
+import sc.networking.clients.IClient
+import sc.protocol.requests.JoinGameRequest
+import sc.protocol.requests.JoinPreparedRoomRequest
+import sc.protocol.requests.JoinRoomRequest
 import sc.protocol.room.ErrorMessage
+import sc.protocol.room.MementoMessage
 import sc.protocol.room.RoomMessage
 import sc.shared.GameResult
-import java.net.ConnectException
-import kotlin.system.exitProcess
+import java.util.function.Function
+
+interface IPlayerClient {
+    fun joinGameWithReservation(reservation: String)
+    fun joinGameRoom(roomId: String)
+    /** Join any game with the appropriate [gameType]. */
+    fun joinGame(gameType: String)
+}
 
 /**
- * Eine Implementation des [AbstractLobbyClientListener],
- * um die Server-Kommunikation mit der Logik der Spieler zu verbinden.
+ * Verbindet die Server-Kommunikation mit der Logik der Spieler.
  */
 class PlayerClient(
-        host: String,
-        port: Int,
+        private val client: IClient,
         private val handler: IGameHandler,
-): AbstractLobbyClientListener() {
-    companion object {
-        private val logger = LoggerFactory.getLogger(PlayerClient::class.java)
-    }
-    
-    var isGameOver = false
-    
-    /** The lobby client that connects to the room. Stops on connection failure. */
-    private val client: LobbyClient = try {
-        LobbyClient(host, port)
-    } catch (e: ConnectException) {
-        logger.error("Could not connect to Server: ${e.message}")
-        exitProcess(1)
-    }
-    
-    /** Storage for the reason of a rule violation, if any occurs. */
-    var error: String? = null
-        private set
-    
-    /** Current room of the player. */
-    private lateinit var roomId: String
-    
-    /** Called for any new message sent to the game room, e.g., move requests. */
-    override fun onRoomMessage(roomId: String, data: RoomMessage) {
-        this.roomId = roomId
-        when (data) {
-            is MoveRequest -> sendMove(handler.calculateMove())
-            is ErrorMessage -> {
-                logger.debug("onError: Client $this received error ${data.message} in $roomId")
-                this.error = data.message
-            }
+): Function<RoomMessage, RoomMessage?>, IPlayerClient {
+    
+    override fun apply(msg: RoomMessage): RoomMessage? {
+        when (msg) {
+            is MoveRequest -> return handler.calculateMove()
+            is MementoMessage -> handler.onUpdate(msg.state)
+            is GameResult -> handler.onGameOver(msg)
+            is ErrorMessage -> handler.onError(msg.logMessage)
         }
+        return null
     }
 
-    /** Sends the selected move to the server. */
-    fun sendMove(move: IMove) =
-            client.sendMessageToRoom(roomId, move)
-    
-    /**
-     * Called when game state has been received.
-     * Happens after a client made a move.
-     */
-    override fun onNewState(roomId: String, state: IGameState) {
-        val gameState = state as TwoPlayerGameState
-        logger.debug("$this got a new state $gameState")
-        handler.onUpdate(gameState)
-    }
-    
-    /** Start the LobbyClient [client] and listen to it. */
-    private fun start() {
-        client.start()
-        client.addListener(this)
-    }
-    
-    /** [start] and join any game with the appropriate [gameType]. */
-    fun joinAnyGame() {
-        start()
-        client.joinGame(IGamePlugin.loadPluginId())
-    }
-    
-    fun joinPreparedGame(reservation: String) {
-        start()
-        client.joinGameWithReservation(reservation)
-    }
-    
-    fun joinGameRoom(roomId: String) {
-        start()
-        client.joinGameRoom(roomId)
+    override fun joinGameWithReservation(reservation: String) {
+        client.send(JoinPreparedRoomRequest(reservation))
     }
 
-    override fun onGameLeft(roomId: String) {
-        logger.info("$this: Got game left in room $roomId")
-        client.stop()
+    override fun joinGameRoom(roomId: String) {
+        client.send(JoinRoomRequest(roomId))
     }
 
-    override fun onGameOver(roomId: String, data: GameResult) {
-        logger.info("$this: Game over with result $data")
-        isGameOver = true
-        handler.onGameOver(data, error)
+    /** Join any game with the appropriate [gameType]. */
+    override fun joinGame(gameType: String) {
+        client.send(JoinGameRequest(gameType))
     }
 }

sdk/src/server-api/sc/networking/clients/LobbyClient.java

@@ -3,7 +3,9 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sc.api.plugins.IGameState;
-import sc.framework.plugins.Player;
+import sc.player.IGameHandler;
+import sc.player.IPlayerClient;
+import sc.player.PlayerClient;
 import sc.protocol.ProtocolPacket;
 import sc.protocol.RemovedFromGame;
 import sc.protocol.ResponsePacket;
@@ -18,6 +20,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
+import java.util.function.Function;
 
 /**
  * This class is used to handle all communication with a server.
@@ -32,13 +35,42 @@ public final class LobbyClient extends XStreamClient implements IPollsHistory {
   private final List<ILobbyClientListener> listeners = new ArrayList<>();
   private final List<IHistoryListener> historyListeners = new ArrayList<>();
 
-  private final Map<String, Consumer<ObservableRoomMessage>> roomObservers = new HashMap<>();
+  private Function<RoomMessage, RoomMessage> player = null;
   private Consumer<ResponsePacket> administrativeListener = null;
+  private final Map<String, Consumer<ObservableRoomMessage>> roomObservers = new HashMap<>();
 
   public LobbyClient(String host, int port) throws IOException {
     super(createTcpNetwork(host, port));
   }
 
+  /** Request authentication on server with a listener.
+   * @return an AdminClient to send authorised requests */
+  public AdminClient authenticate(String password, Consumer<ResponsePacket> consumer) {
+    start();
+    if(administrativeListener != null)
+      logger.warn("Re-authentication replaces {}", administrativeListener);
+    administrativeListener = consumer;
+    send(new AuthenticateRequest(password));
+    return new AdminClient(this);
+  }
+
+
+  /** Sets observer to observe messages in the given room.
+   * Whether administrative messages are received depends on authentication,
+   * which has to be done separately. */
+  public void observeRoom(String roomId, Consumer<ObservableRoomMessage> observer) {
+    roomObservers.put(roomId, observer);
+  }
+
+  /** Sets this client up to play a game utilizing the handler.
+   * @return a PlayerClient to join a room as Player. */
+  public IPlayerClient asPlayer(IGameHandler handler) {
+    start();
+    PlayerClient client = new PlayerClient(this, handler);
+    player = client;
+    return client;
+  }
+
   @Override
   protected final void onObject(ProtocolPacket message) {
     if(message instanceof ResponsePacket && administrativeListener != null)
@@ -47,6 +79,12 @@ protected final void onObject(ProtocolPacket message) {
       RoomPacket packet = (RoomPacket) message;
       String roomId = packet.getRoomId();
       RoomMessage data = packet.getData();
+     if(player != null) {
+        // TODO run this in a background thread
+        RoomMessage response = player.apply(data);
+        if(response != null)
+          sendMessageToRoom(roomId, response);
+      }
       if(data instanceof ObservableRoomMessage) {
         roomObservers.getOrDefault(roomId, (m) -> {}).accept((ObservableRoomMessage) data);
         if (data instanceof MementoMessage) {
@@ -86,6 +124,13 @@ protected final void onObject(ProtocolPacket message) {
     }
   }
 
+  public void sendMessageToRoom(String roomId, RoomMessage o) {
+    send(new RoomPacket(roomId, o));
+  }
+
+  // TODO The following functions are obsolete
+  //  and will be removed once all tests are migrated to the new style
+
   private void onGameOver(String roomId, GameResult data) {
     logger.info("Received game result: {}", data);
     for (IHistoryListener listener : this.historyListeners) {
@@ -127,15 +172,6 @@ public void authenticate(String password) {
     send(new AuthenticateRequest(password));
   }
 
-  public AdminClient authenticate(String password, Consumer<ResponsePacket> consumer) {
-    start();
-    if(administrativeListener != null)
-      logger.warn("Re-authentication replaces {}", administrativeListener);
-    administrativeListener = consumer;
-    send(new AuthenticateRequest(password));
-    return new AdminClient(this);
-  }
-
   protected void onCustomObject(Object o) {
     logger.warn("Couldn't process message {}.", o);
   }
@@ -155,10 +191,6 @@ protected void onRoomMessage(String roomId, RoomMessage data) {
     }
   }
 
-  public void sendMessageToRoom(String roomId, RoomMessage o) {
-    send(new RoomPacket(roomId, o));
-  }
-
   public void joinGameWithReservation(String reservation) {
     send(new JoinPreparedRoomRequest(reservation));
   }
@@ -190,13 +222,6 @@ public ObservingClient observe(String roomId, boolean isPaused) {
     return observer;
   }
 
-  /** Sets observer to observe messages in the given room.
-   * Whether administrative messages are received depends on authentication,
-   * which has to be done separately. */
-  public void observeRoom(String roomId, Consumer<ObservableRoomMessage> observer) {
-    roomObservers.put(roomId, observer);
-  }
-
   @Override
   public void addListener(IHistoryListener listener) {
     this.historyListeners.add(listener);