refactor(plugin): convert more interfaces / abstract classes to kt

Author: anarchuser

plugin/src/server/sc/plugin2020/Game.java

@@ -2,6 +2,7 @@
 
 import com.thoughtworks.xstream.annotations.XStreamAlias;
 import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sc.api.plugins.IGameState;
@@ -22,9 +23,12 @@
 
 /** Minimales Spiel als Basis für neue Plugins. */
 @XStreamAlias(value = "game")
-public class Game extends RoundBasedGameInstance<Player> {
+public class Game extends RoundBasedGameInstance {
   private static final Logger logger = LoggerFactory.getLogger(Game.class);
 
+  @XStreamOmitField
+  private String pluginUUID;
+
   @XStreamOmitField
   private List<Team> availableColors = new ArrayList<>();
 
@@ -51,7 +55,7 @@ protected IGameState getCurrentState() {
 
   /** Jemand hat etwas gesendet -> testen was es war (wenn es ein Zug war, dann validieren) */
   @Override
-  protected void onRoundBasedAction(Player fromPlayer, ProtocolMessage data) throws InvalidGameStateException, InvalidMoveException {
+  protected void onRoundBasedAction(Player fromPlayer, ProtocolMessage data) throws InvalidGameStateException {
     // NOTE: Checking if right player sent move was already done by onAction(Player, ProtocolMove)}.
     // There is no need to do it here again.
     try {
@@ -61,7 +65,7 @@ protected void onRoundBasedAction(Player fromPlayer, ProtocolMessage data) throw
       logger.debug("Performing Move " + move.toString());
       logger.debug("Current Board: " + this.gameState.getBoard().toString());
       GameRuleLogic.performMove(this.gameState, move);
-      next(this.gameState.getCurrentPlayer());
+      next(this.gameState.getCurrentPlayer(), false);
     } catch(InvalidMoveException e) {
       super.catchInvalidMove(e, fromPlayer);
     }
@@ -80,7 +84,7 @@ public Player onPlayerJoined() {
       player = new Player(team);
     }
 
-    this.players.add(player);
+    addPlayer(player);
     this.gameState.addPlayer(player);
 
     return player;
@@ -89,7 +93,7 @@ public Player onPlayerJoined() {
   /** Sends welcomeMessage to all listeners and notify player on new gameStates or MoveRequests */
   @Override
   public void start() {
-    for(final Player p : this.players) {
+    for(final Player p : getPlayers()) {
       p.notifyListeners(new WelcomeMessage(p.getColor()));
     }
     super.start();
@@ -263,7 +267,7 @@ public List<Player> getWinners() {
     WinCondition winCondition = checkWinCondition();
     List<Player> winners = new ArrayList<>();
     if(winCondition != null) {
-      for(Player player : this.players) {
+      for(Player player : getPlayers()) {
         if(player.getColor() == winCondition.getWinner()) {
           winners.add(player);
           break;
@@ -274,7 +278,7 @@ public List<Player> getWinners() {
       // determined by matchpoints ("Siegpunkte"). The winning player has 2
       // matchpoints. Find this player. If no player has 2 matchpoints, it is a
       // draw.
-      for(Player player : this.players) {
+      for(Player player : getPlayers()) {
         if(getScoreFor(player).getValues().get(0).intValueExact() == Constants.WIN_SCORE) {
           winners.add(player);
           break;
@@ -284,10 +288,11 @@ public List<Player> getWinners() {
     return winners;
   }
 
-  /** Liste der Spieler. Reihenfolge: RED, BLUE */
+  /** Liste der Spieler. Reihenfolge: RED, BLUE
+   * @return*/
   @Override
-  public List<Player> getPlayers() {
-    return gameState.getPlayers();
+  public ArrayList<Player> getPlayers() {
+    return new ArrayList<Player>(gameState.getPlayers());
   }
 
   /** Liste der playerScores für jeden Spieler. Reihenfolge: RED, BLUE */
@@ -298,4 +303,9 @@ public List<PlayerScore> getPlayerScores() {
     return playerScores;
   }
 
+  @NotNull
+  @Override
+  public String getPluginUUID() {
+    return pluginUUID;
+  }
 }

plugin/src/server/sc/plugin2021/Game.kt

@@ -15,17 +15,15 @@ import kotlin.math.log
 
 
 @XStreamAlias(value = "game")
-class Game(UUID: String = GamePlugin.PLUGIN_UUID): RoundBasedGameInstance<Player>() {
+class Game(UUID: String = GamePlugin.PLUGIN_UUID): RoundBasedGameInstance() {
     companion object {
         val logger = LoggerFactory.getLogger(Game::class.java)
     }
 
     private val availableTeams = mutableListOf(Team.ONE, Team.TWO)
     val gameState = GameState()
 
-    init {
-        pluginUUID = UUID
-    }
+    override val pluginUUID: String = UUID
 
     override fun start() {
         players.forEach {it.notifyListeners(WelcomeMessage(it.color)) }
@@ -42,21 +40,20 @@ class Game(UUID: String = GamePlugin.PLUGIN_UUID): RoundBasedGameInstance<Player
         return player
     }
 
-    override fun getWinners(): MutableList<Player> {
-        val winCondition = checkWinCondition()
-        if (winCondition != null)
-            return winCondition.winner.let{players}
-        
-        // If no win condition is met, the player with highest score wins.
-        return listOfNotNull(players.maxBy {
-            gameState.getPointsForPlayer(it.color)
-        }).toMutableList()
-    }
-    
-    override fun getPlayerScores(): MutableList<PlayerScore> =
-            getPlayers().map { getScoreFor(it) }.toMutableList()
+    override val winners: List<Player>
+        get() {
+            val winCondition = checkWinCondition()
+            if (winCondition != null)
+                return winCondition.winner.let{players}
+            
+            // If no win condition is met, the player with highest score wins.
+            return listOfNotNull(players.maxBy {
+                gameState.getPointsForPlayer(it.color)
+            }).toMutableList()
+        }
 
-    override fun getPlayers(): MutableList<Player> = players
+    override val playerScores: List<PlayerScore>
+        get() = players.map { getScoreFor(it) }.toMutableList()
 
     private val playerMap = mutableMapOf<Team, Player>()
 
@@ -80,15 +77,15 @@ class Game(UUID: String = GamePlugin.PLUGIN_UUID): RoundBasedGameInstance<Player
         return WinCondition(null, WinReason.EQUAL_SCORE)
     }
 
-    override fun loadGameInfo(gameInfo: Any?) {
+    override fun loadGameInfo(gameInfo: Any) {
         TODO("Not yet implemented")
     }
 
-    override fun loadFromFile(file: String?) {
+    override fun loadFromFile(file: String) {
         TODO("Not yet implemented")
     }
 
-    override fun loadFromFile(file: String?, turn: Int) {
+    override fun loadFromFile(file: String, turn: Int) {
         TODO("Not yet implemented")
     }
 
@@ -145,7 +142,7 @@ class Game(UUID: String = GamePlugin.PLUGIN_UUID): RoundBasedGameInstance<Player
             ActionTimeout(true, Constants.HARD_TIMEOUT, Constants.SOFT_TIMEOUT)
 
     @Throws(InvalidMoveException::class, InvalidGameStateException::class)
-    override fun onRoundBasedAction(fromPlayer: Player, data: ProtocolMessage?) {
+    override fun onRoundBasedAction(fromPlayer: Player, data: ProtocolMessage) {
         // This check is already done by super.onAction()
         assert(fromPlayer == activePlayer)
 

plugin/src/test/sc/plugin2021/ManualGameTest.kts

@@ -42,7 +42,7 @@ fun loop() {
             println("$input -> $move")
 
             try {
-                game.onAction(game.gameState.getPlayer(move.color.team), move)
+                game.onAction(game.gameState.getPlayer(move.color.team)!!, move)
                 current = game.gameState.getOpponent(current)!!
             } catch (e: Exception) {
                 println(e)

socha-sdk/src/server-api/sc/api/plugins/IGameInstance.java

@@ -0,0 +1,94 @@
+package sc.api.plugins
+
+import sc.api.plugins.exceptions.GameLogicException
+import sc.api.plugins.exceptions.TooManyPlayersException
+import sc.api.plugins.host.IGameListener
+import sc.framework.plugins.Player
+import sc.protocol.responses.ProtocolMessage
+import sc.shared.InvalidGameStateException
+import sc.shared.InvalidMoveException
+import sc.shared.PlayerScore
+import sc.shared.ScoreCause
+
+interface IGameInstance {
+    /**
+     * @return the player that joined
+     *
+     * @throws TooManyPlayersException thrown when a player can't join
+     */
+    @Throws(TooManyPlayersException::class)
+    fun onPlayerJoined(): Player
+    fun onPlayerLeft(player: Player, cause: ScoreCause? = null)
+    
+    /**
+     * Called by the Server once an action was received.
+     *
+     * @param fromPlayer The player who invoked this action.
+     * @param data       The plugin-secific data.
+     *
+     * @throws GameLogicException   if any invalid action is done
+     * @throws InvalidMoveException if the received move violates the rules
+     */
+    @Throws(GameLogicException::class, InvalidGameStateException::class, InvalidMoveException::class)
+    fun onAction(fromPlayer: Player, data: ProtocolMessage)
+    
+    /**
+     * Extends the set of listeners.
+     *
+     * @param listener GameListener to be added
+     */
+    fun addGameListener(listener: IGameListener)
+    fun removeGameListener(listener: IGameListener)
+    
+    /** Server or an administrator requests the game to start now.  */
+    fun start()
+    
+    /**
+     * Destroys the Game.
+     * Might be invoked by the server at any time. Any open handles should be removed.
+     * No events should be sent out (GameOver etc) after this method has been called.
+     */
+    fun destroy()
+    
+    /**
+     * The game is requested to load itself from a file (the board i.e.). This is
+     * like a replay but with actual clients.
+     *
+     * @param file File where the game should be loaded from
+     */
+    fun loadFromFile(file: String)
+    
+    /**
+     * The game is requested to load itself from a file (the board i.e.). This is
+     * like a replay but with actual clients. Turn is used to specify the turn to
+     * load from replay (e.g. if more than one gameState in replay)
+     *
+     * @param file File where the game should be loaded from
+     * @param turn The turn to load
+     */
+    fun loadFromFile(file: String, turn: Int)
+    
+    /**
+     * The game is requested to load itself from a given game information object (could be a board instance for example)
+     *
+     * @param gameInfo the stored gameInformation
+     */
+    fun loadGameInfo(gameInfo: Any)
+    
+    /**
+     * Returns the players that have won the game, empty if the game has no winners,
+     * or null if the game has not finished.
+     */
+    val winners: List<Player>
+    
+    /** Used for generating replay name.  */
+    val pluginUUID: String
+    
+    /** @return the two players, the startplayer will be first in the List
+     */
+    val players: MutableList<Player>
+    
+    /** @return the PlayerScores for both players
+     */
+    val playerScores: List<PlayerScore>
+}