fix(sdk): remove redundant Player generics

Author: anarchuser

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

@@ -11,6 +11,7 @@ import sc.plugin2021.util.GameRuleLogic
 import sc.plugin2021.util.WinReason
 import sc.protocol.responses.ProtocolMessage
 import sc.shared.*
+import java.lang.IndexOutOfBoundsException
 
 @XStreamAlias(value = "game")
 class Game(UUID: String = GamePlugin.PLUGIN_UUID): RoundBasedGameInstance() {
@@ -30,7 +31,7 @@ class Game(UUID: String = GamePlugin.PLUGIN_UUID): RoundBasedGameInstance() {
 
     override fun onPlayerJoined(): Player {
         val player = gameState.getPlayer(availableTeams.removeAt(0))
-                ?: throw NullPointerException("Too many players joined the game!")
+                ?: throw IndexOutOfBoundsException("Too many players joined the game!")
 
         players.add(player)
         playerMap[player.color as Team] = player

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

@@ -3,6 +3,7 @@ package sc.plugin2021
 import sc.api.plugins.IGameInstance
 import sc.api.plugins.IGamePlugin
 import sc.api.plugins.host.IGamePluginHost
+import sc.framework.plugins.Player
 import sc.plugin2021.util.Configuration.classesToRegister
 import sc.plugins.PluginDescriptor
 import sc.shared.ScoreDefinition

plugin/src/shared/sc/plugin2020/GameState.kt

@@ -18,7 +18,7 @@ class GameState @JvmOverloads constructor(
         private val undeployedRedPieces: MutableList<Piece> = parsePiecesString(Constants.STARTING_PIECES, Team.RED),
         private val undeployedBluePieces: MutableList<Piece> = parsePiecesString(Constants.STARTING_PIECES, Team.BLUE),
         override var lastMove: Move? = null
-): TwoPlayerGameState<Player>(Team.RED) {
+): TwoPlayerGameState(Team.RED) {
 
     override val round: Int
         get() = turn / 2

plugin/src/shared/sc/plugin2021/GameState.kt

@@ -19,7 +19,7 @@ class GameState @JvmOverloads constructor(
         startTurn: Int = 0,
         val startColor: Color = Color.BLUE,
         @XStreamAsAttribute val startPiece: PieceShape = GameRuleLogic.getRandomPentomino()
-): TwoPlayerGameState<Player>(Team.ONE) {
+): TwoPlayerGameState(Team.ONE) {
 
     companion object {
         val logger = LoggerFactory.getLogger(GameState::class.java)

server/test/sc/protocol/requests/RequestTest.kt

@@ -402,7 +402,7 @@ class RequestTest: RealServerTest() {
         p1Listener.playerEventReceived = false
         p2Listener.playerEventReceived = false
         player1.send(PauseGameRequest(room.id, false))
-        TestHelper.waitUntilEqual(false, { (room.game as RoundBasedGameInstance<*>).isPaused }, 2000)
+        TestHelper.waitUntilEqual(false, { (room.game as RoundBasedGameInstance).isPaused() }, 2000)
 
 
         TestHelper.waitMillis(500)

server/test/sc/server/plugins/TestGame.java

@@ -15,7 +15,7 @@
 import java.util.List;
 import java.util.Map;
 
-public class TestGame extends RoundBasedGameInstance<TestPlayer> {
+public class TestGame extends RoundBasedGameInstance {
   private static final Logger logger = LoggerFactory.getLogger(TestGame.class);
 
   private TestGameState state = new TestGameState();
@@ -32,7 +32,7 @@ protected void onRoundBasedAction(Player fromPlayer, ProtocolMessage data) {
 
       final TestMove move = (TestMove) data;
       move.perform(this.state);
-      next(this.state.getCurrentPlayer() == TestTeam.RED ? state.getRed() : state.getBlue());
+      next(this.state.getCurrentPlayer() == TestTeam.RED ? state.getRed() : state.getBlue(), false);
     }
   }
 
@@ -47,7 +47,8 @@ protected WinCondition checkWinCondition() {
 
   @Override
   public Player onPlayerJoined() throws TooManyPlayersException {
-    if (this.players.size() < 2) {
+    List<Player> players = getPlayers();
+    if (players.size() < 2) {
       if (players.size() == 0) {
         state.setRed(new TestPlayer(TestTeam.RED));
         players.add(state.getRed());
@@ -63,8 +64,8 @@ public Player onPlayerJoined() throws TooManyPlayersException {
 
   }
 
-  public List<TestPlayer> getTestPlayers() {
-    return this.players;
+  public List<Player> getTestPlayers() {
+    return getPlayers();
   }
 
   @Override
@@ -83,17 +84,12 @@ public void onPlayerLeft(Player player, ScoreCause cause) {
     logger.debug("Player left {}", player);
     Map<Player, PlayerScore> result = generateScoreMap();
     result.put(player, new PlayerScore(false, "Spieler hat das Spiel verlassen."));
-    result.get(player).setCause(cause);
+    result.get(player).setCause((cause != null) ? cause : ScoreCause.LEFT);
     notifyOnGameOver(result);
   }
 
   @Override
-  public void onPlayerLeft(Player player) {
-    onPlayerLeft(player, ScoreCause.LEFT);
-  }
-
-  @Override
-  public PlayerScore getScoreFor(TestPlayer p) {
+  public PlayerScore getScoreFor(Player p) {
     return new PlayerScore(true, "Spieler hat gewonnen.");
   }
 
@@ -122,16 +118,20 @@ public List<Player> getPlayers() {
   /** Sends welcomeMessage to all listeners and notify player on new gameStates or MoveRequests */
   @Override
   public void start() {
-    for (final TestPlayer p : this.players) {
+    for (final Player p : this.getPlayers()) {
       p.notifyListeners(new WelcomeMessage(p.getColor()));
     }
 
     super.start();
   }
 
   @Override
-  protected ActionTimeout getTimeoutFor(TestPlayer player) {
+  protected ActionTimeout getTimeoutFor(Player player) {
     return new ActionTimeout(false, 100000000L, 20000000L);
   }
 
+  @Override
+  public String getPluginUUID() {
+    return "test";
+  }
 }

server/test/sc/server/plugins/TestGameState.kt

@@ -4,8 +4,10 @@ import sc.api.plugins.IGameState
 import sc.api.plugins.ITeam
 import sc.server.helpers.TestTeam
 
-class TestGameState: IGameState {
+class TestGameState(): IGameState {
     override var turn = 0
+    override var round = 1
+        get() = turn / 2
     var state = 0
     var lastPlayerIndex = 0
     var currentPlayer: TestTeam

socha-sdk/src/server-api/sc/api/plugins/TwoPlayerGameState.kt

@@ -5,38 +5,38 @@ import com.thoughtworks.xstream.annotations.XStreamOmitField
 import org.slf4j.LoggerFactory
 import sc.framework.plugins.Player
 
-abstract class TwoPlayerGameState<P : Player>(
+abstract class TwoPlayerGameState(
         @XStreamAsAttribute val startTeam: ITeam<*>
 ) : IGameState {
 
     @XStreamOmitField
     private val logger = LoggerFactory.getLogger(TwoPlayerGameState::class.java)
 
-    abstract val first: P
-    abstract val second: P
+    abstract val first: Player
+    abstract val second: Player
     abstract val board: IBoard
 
     /** List of all teams. */
-    val players: List<P>
+    val players: List<Player>
         get() = listOf(first, second)
 
     /** The Team active in the current turn. */
     abstract val currentTeam: ITeam<*>
 
     /** The Player whose team's turn it is. */
-    open val currentPlayer: P
+    open val currentPlayer: Player
         get() = getPlayer(currentTeam)!!
 
     /** The player opposite to the currently active one. */
-    val otherPlayer: P
+    val otherPlayer: Player
         get() = getPlayer(otherTeam)!!
 
     /** The Team opposite to the currently active one. */
     val otherTeam: ITeam<*>
         get() = currentTeam.opponent()
 
     /** Der Spieler, der das Spiel begonnen hat. */
-    val startPlayer: P
+    val startPlayer: Player
         get() = getPlayer(startTeam)!!
 
     /** Die Namen der beiden Spieler. */
@@ -46,10 +46,10 @@ abstract class TwoPlayerGameState<P : Player>(
     /** Letzter getaetigter Zug. */
     abstract val lastMove: IMove?
 
-    fun getOpponent(player: P) =
+    fun getOpponent(player: Player) =
             getPlayer(player.color.opponent())
 
-    fun getPlayer(team: ITeam<*>): P? = when(team.index) {
+    fun getPlayer(team: ITeam<*>): Player? = when(team.index) {
         0 -> first
         1 -> second
         else -> null

socha-sdk/src/server-api/sc/framework/plugins/RoundBasedGameInstance.kt

@@ -142,18 +142,17 @@ abstract class RoundBasedGameInstance : IGameInstance {
                 else ActionTimeout(false)
 
         val logger = logger
-        val playerToTimeout = player
-        
+    
         // Signal the JVM to do a GC run now and lower the probability that the GC
         // runs when the players sends back its move, resulting in disqualification
         // because of soft timeout
         System.gc()
 
         requestTimeout = timeout
         timeout.start {
-            logger.warn("Player $playerToTimeout reached the timeout of ${timeout.hardTimeout}ms")
-            playerToTimeout.hardTimeout = true
-            onPlayerLeft(playerToTimeout, ScoreCause.HARD_TIMEOUT)
+            logger.warn("Player $player reached the timeout of ${timeout.hardTimeout}ms")
+            player.hardTimeout = true
+            onPlayerLeft(player, ScoreCause.HARD_TIMEOUT)
         }
         player.requestMove()
     }