refactor(player): convert starter and logic from kotlin to java

player/src/sc/player2021/Starter.java

@@ -0,0 +1,80 @@
+package sc.player2021;
+
+import jargs.gnu.CmdLineParser;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sc.player2021.logic.Logic;
+import sc.plugin2021.AbstractClient;
+import sc.plugin2021.IGameHandler;
+import sc.shared.SharedConfiguration;
+
+import java.io.File;
+
+/**
+ * Hauptklasse des Clients, die über Konsolenargumente gesteuert werden kann.
+ * Sie veranlasst eine Verbindung zum Spielserver.
+ */
+public class Starter extends AbstractClient {
+  private static final Logger logger = LoggerFactory.getLogger(Starter.class);
+
+  public Starter(String host, int port, String reservation) throws Exception {
+    // client starten
+    super(host, port);
+
+    // Strategie zuweisen
+    IGameHandler logic = new Logic(this);
+    setHandler(logic);
+
+    // einem Spiel beitreten
+    if (reservation == null || reservation.isEmpty()) {
+      joinAnyGame();
+    } else {
+      joinPreparedGame(reservation);
+    }
+  }
+
+  public static void main(String[] args) {
+    System.setProperty("file.encoding", "UTF-8");
+
+    // parameter definieren
+    CmdLineParser parser = new CmdLineParser();
+    CmdLineParser.Option hostOption = parser.addStringOption('h', "host");
+    CmdLineParser.Option portOption = parser.addIntegerOption('p', "port");
+    CmdLineParser.Option reservationOption = parser.addStringOption('r', "reservation");
+
+    try {
+      // parameter auslesen
+      parser.parse(args);
+    } catch (CmdLineParser.OptionException e) {
+      // bei Fehler die Hilfe anzeigen
+      showHelp(e.getMessage());
+      System.exit(2);
+    }
+
+    // parameter laden
+    String host = (String) parser.getOptionValue(hostOption, "localhost");
+    int port = (Integer) parser.getOptionValue(portOption, SharedConfiguration.DEFAULT_PORT);
+    String reservation = (String) parser.getOptionValue(reservationOption, "");
+
+    // einen neuen client erzeugen
+    try {
+      new Starter(host, port, reservation);
+    } catch (Exception e) {
+      logger.error("Beim Starten den Clients ist ein Fehler aufgetreten:", e);
+      e.printStackTrace();
+    }
+
+  }
+
+  private static void showHelp(String errorMsg) {
+    String jarName = new File(Starter.class.getProtectionDomain().getCodeSource().getLocation().getFile()).getName();
+    System.out.println("\n" + errorMsg);
+    System.out.println("\nBitte das Programm mit folgenden Parametern (optional) aufrufen: \n"
+            + "java -jar " + jarName + " [{-h,--host} hostname]\n"
+            + "                               [{-p,--port} port]\n"
+            + "                               [{-r,--reservation} reservierung]");
+    System.out.println("\nBeispiel: \n"
+            + "java -jar " + jarName + " --host 127.0.0.1 --port 10500 --reservation 1234\n");
+  }
+
+}

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

@@ -0,0 +1,85 @@
+package sc.player2021.logic;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sc.framework.plugins.Player;
+import sc.player2021.Starter;
+import sc.plugin2021.GameState;
+import sc.plugin2021.IGameHandler;
+import sc.plugin2021.Move;
+import sc.plugin2021.Team;
+import sc.plugin2021.util.GameRuleLogic;
+import sc.shared.GameResult;
+import sc.api.plugins.ITeam;
+
+import java.util.List;
+import java.util.ArrayList;
+
+/**
+ * Das Herz des Clients:
+ * Eine sehr simple Logik, die ihre Zuege zufaellig waehlt,
+ * aber gueltige Zuege macht.
+ * Ausserdem werden zum Spielverlauf Konsolenausgaben gemacht.
+ */
+public class Logic implements IGameHandler {
+  private static final Logger log = LoggerFactory.getLogger(Logic.class);
+
+  private Starter client;
+  private GameState gameState;
+  private Player currentPlayer;
+
+  /**
+   * Erzeugt ein neues Strategieobjekt, das zufaellige Zuege taetigt.
+   *
+   * @param client Der zugrundeliegende Client, der mit dem Spielserver kommuniziert.
+   */
+  public Logic(Starter 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() {
+    long startTime = System.currentTimeMillis();
+    log.info("Es wurde ein Zug angefordert.");
+    List possibleMoves = new ArrayList<>(GameRuleLogic.getPossibleMoves(gameState));
+    sendAction((Move) possibleMoves.get((int) (Math.random() * possibleMoves.size())));
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public void onUpdate(Player player, Player otherPlayer) {
+    currentPlayer = player;
+    log.info("Spielerwechsel: " + player.getColor());
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public void onUpdate(GameState gameState) {
+    this.gameState = gameState;
+    currentPlayer = gameState.getCurrentPlayer();
+    log.info("Zug: {} Spieler: {}", gameState.getTurn(), currentPlayer.getColor());
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public void sendAction(Move move) {
+    client.sendMove(move);
+  }
+
+}

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

@@ -23,9 +23,11 @@ import kotlin.system.exitProcess
 abstract class AbstractClient @Throws(IOException::class) constructor(
         host: String,
         port: Int,
-        private val type: PlayerType = PlayerType.PLAYER_ONE
+        private val type: PlayerType
 ): ILobbyClientListener {
 
+    constructor(host: String, port: Int): this(host, port, PlayerType.PLAYER_ONE) {}
+
     companion object {
         private val logger = LoggerFactory.getLogger(AbstractClient::class.java);
         private val gameType = GamePlugin.PLUGIN_UUID