refactor(server): delegate replay saving to ReplayListener

Author: xeruf

sdk/src/server-api/sc/framework/ReplayListener.kt

@@ -0,0 +1,25 @@
+package sc.framework
+
+import sc.networking.XStreamProvider.Companion.loadPluginXStream
+import java.io.IOException
+import java.io.Writer
+
+class ReplayListener<T>(private val history: MutableList<T> = ArrayList()) {
+    
+    fun addMessage(message: T) =
+            history.add(message)
+    
+    /** Write replay of game to a writer.  */
+    @Throws(IOException::class)
+    fun saveReplay(writer: Writer) {
+        val xStream = loadPluginXStream()
+        writer.write("<protocol>\n")
+        for (element in history) {
+            // TODO do we need to save RoomPackets?
+            writer.write("${xStream.toXML(element)}\n")
+            writer.flush()
+        }
+        writer.write("</protocol>")
+        writer.close()
+    }
+}

sdk/src/server-api/sc/protocol/room/MementoMessage.kt

@@ -10,6 +10,7 @@ import sc.framework.plugins.IPerspectiveProvider
 data class MementoMessage(
         val state: IGameState,
         @XStreamOmitField private val perspective: Any?
-): ObservableRoomMessage, IPerspectiveProvider {
+): ObservableRoomMessage, IPerspectiveProvider, Cloneable {
     override fun getPerspective() = perspective
-}
+    public override fun clone() = MementoMessage(state.clone(), perspective)
+}

server/src/sc/server/Configuration.java

@@ -81,6 +81,10 @@ public static void set(final String key, final String value) {
     properties.setProperty(key, value);
   }
 
+  public static void set(final String key, final boolean value) {
+    properties.setProperty(key, String.valueOf(value));
+  }
+
   public static void setIfNotNull(final String key, final String value) {
     if (value != null) {
       set(key, value);

server/src/sc/server/gaming/GameRoom.java

@@ -1,6 +1,5 @@
 package sc.server.gaming;
 
-import com.thoughtworks.xstream.XStream;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sc.api.plugins.IGameInstance;
@@ -12,9 +11,9 @@
 import sc.api.plugins.exceptions.TooManyPlayersException;
 import sc.api.plugins.host.IGameListener;
 import sc.framework.HelperMethods;
+import sc.framework.ReplayListener;
 import sc.framework.plugins.AbstractGame;
 import sc.framework.plugins.Player;
-import sc.networking.XStreamProvider;
 import sc.networking.clients.IClient;
 import sc.networking.clients.XStreamClient;
 import sc.protocol.ProtocolPacket;
@@ -42,9 +41,9 @@ public class GameRoom implements IGameListener {
   private final ScoreDefinition scoreDefinition;
   private final List<PlayerSlot> playerSlots = new ArrayList<>(getMaximumPlayerCount());
   private GameStatus status = GameStatus.CREATED;
-  private GameResult result = null;
+  private GameResult result;
   private boolean pauseRequested = false;
-  private List<RoomMessage> history = new ArrayList<>();
+  private final ReplayListener<RoomPacket> replayListener = Boolean.parseBoolean(Configuration.get(Configuration.SAVE_REPLAY)) ? new ReplayListener<>() : null;
 
   public final IGameInstance game; // TODO make inaccessible
   public final List<IClient> observers = new ArrayList<>();
@@ -74,6 +73,7 @@ public synchronized void onGameOver(Map<Player, PlayerScore> results) {
     try {
       result = generateGameResult(results);
       logger.info("{} is over (regular={})", game, result.isRegular());
+      saveReplayMessage(result);
       // save playerScore if test mode enabled
       if (Boolean.parseBoolean(Configuration.get(Configuration.TEST_MODE))) {
         List<Player> players = game.getPlayers();
@@ -84,22 +84,38 @@ public synchronized void onGameOver(Map<Player, PlayerScore> results) {
       logger.error("Failed to generate GameResult from " + results, t);
     }
 
-    if (Boolean.parseBoolean(Configuration.get(Configuration.SAVE_REPLAY))) {
+    saveReplay();
+    destroy();
+  }
+
+  private void saveReplayMessage(ObservableRoomMessage message) {
+    if (replayListener != null)
+      replayListener.addMessage(createRoomPacket(message instanceof MementoMessage ? ((MementoMessage) message).clone() : message));
+  }
+
+  /** If enabled, save the recorded replay to the default file. */
+  public void saveReplay() {
+    if (replayListener != null) {
       try {
-        saveReplay(new BufferedWriter(new FileWriter(createReplayFile())));
+        File file = createReplayFile();
+        logger.debug("Saving replay to {}", file);
+        saveReplay(new BufferedWriter(new FileWriter(file)));
       } catch (IOException e) {
         logger.error("Failed to save replay", e);
       }
     }
+  }
 
-    destroy();
+  /** Saves a replay to the writer, assuming replays have been enabled. */
+  public void saveReplay(Writer writer) throws IOException, NullPointerException {
+    replayListener.saveReplay(writer);
   }
 
   public File createReplayFile() throws IOException {
     String fileName = HelperMethods.getReplayFilename(this.game.getPluginUUID(),
         playerSlots.stream().map(it -> it.getPlayer().getDisplayName()).collect(Collectors.toList()));
 
-    File file = new File(fileName);
+    File file = new File(fileName).getAbsoluteFile();
     if(file.getParentFile().mkdirs())
       if(file.createNewFile())
         return file;
@@ -130,26 +146,6 @@ private GameResult generateGameResult(Map<Player, PlayerScore> results) {
     return new GameResult(scoreDefinition, scores, this.game.getWinners());
   }
 
-  /** Write replay of game to a writer. */
-  public void saveReplay(Writer writer) throws IOException {
-    XStream xStream = XStreamProvider.loadPluginXStream();
-
-    writer.write("<protocol>\n");
-    for (RoomMessage element : history) {
-      if (!(element instanceof IGameState))
-        continue;
-      IGameState state = (IGameState) element;
-      // TODO do we need to save RoomPackets?
-      RoomPacket roomPacket = createRoomPacket(new MementoMessage(state, null));
-      writer.write(xStream.toXML(roomPacket) + "\n");
-      writer.flush();
-    }
-
-    writer.write(xStream.toXML(createRoomPacket(this.result)) + "\n");
-    writer.write("</protocol>");
-    writer.close();
-  }
-
   /** Send the given message to all Players and Observers in this room. */
   private void broadcast(ObservableRoomMessage message) {
     broadcast(createRoomPacket(message));
@@ -175,10 +171,12 @@ private void kickAllClients() {
   /** Send updated GameState to all players and observers. */
   @Override
   public void onStateChanged(IGameState data, boolean observersOnly) {
-    history.add(data);
-    observerBroadcast(new MementoMessage(data, null));
-    if (!observersOnly)
+    MementoMessage memento = new MementoMessage(data, null);
+    observerBroadcast(memento);
+    if (!observersOnly) {
       sendStateToPlayers(data);
+      saveReplayMessage(memento);
+    }
   }
 
   /**
@@ -321,7 +319,7 @@ public synchronized void onEvent(Client source, IMove move) throws GameRoomExcep
       ErrorMessage errorMessage = new ErrorMessage(move, error);
       player.notifyListeners(errorMessage);
       observerBroadcast(errorMessage);
-      history.add(errorMessage);
+      saveReplayMessage(errorMessage);
       cancel();
       throw new GameLogicException(e.toString(), e);
     } catch (GameLogicException e) {

server/test/sc/server/gaming/GameRoomTest.kt

@@ -7,6 +7,7 @@ import io.kotest.matchers.collections.shouldHaveSize
 import io.kotest.matchers.shouldBe
 import org.junit.jupiter.api.assertThrows
 import sc.protocol.requests.PrepareGameRequest
+import sc.server.Configuration
 import sc.server.helpers.StringNetworkInterface
 import sc.server.network.Client
 import sc.server.plugins.TestPlugin
@@ -20,6 +21,7 @@ class GameRoomTest: WordSpec({
     val client = Client(StringNetworkInterface("")).apply { start() }
     "A GameRoomManager" should {
         val manager = GameRoomManager().apply { pluginManager.loadPlugin(TestPlugin::class.java) }
+        Configuration.set(Configuration.SAVE_REPLAY, true)
         "create a game when a player joins" {
             manager.joinOrCreateGame(client, TestPlugin.TEST_PLUGIN_UUID).playerCount shouldBe 1
             manager.games shouldHaveSize 1
@@ -43,16 +45,16 @@ class GameRoomTest: WordSpec({
                 <room roomId="${room.id}">
                   <data class="memento">
                     <state class="sc.server.plugins.TestGameState">
+                      <turn>0</turn>
+                      <state>0</state>
+                      <currentPlayer>RED</currentPlayer>
+                      <startPlayer>RED</startPlayer>
                       <red displayName="">
                         <color class="sc.server.helpers.TestTeam">RED</color>
                       </red>
                       <blue displayName="">
                         <color class="sc.server.helpers.TestTeam">BLUE</color>
                       </blue>
-                      <turn>0</turn>
-                      <state>0</state>
-                      <currentPlayer>RED</currentPlayer>
-                      <startPlayer>RED</startPlayer>
                     </state>
                   </data>
                 </room>

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

@@ -8,16 +8,16 @@ data class TestGameState(
         override var turn: Int = 0,
         var state: Int = 0,
         var currentPlayer: TestTeam = TestTeam.RED,
-        val startPlayer: TestTeam = TestTeam.RED
+        val startPlayer: TestTeam = TestTeam.RED,
+        val red: Player = Player(TestTeam.RED),
+        val blue: Player = Player(TestTeam.BLUE),
 ): IGameState {
     override val round get() = turn / 2
-    val red = Player(TestTeam.RED)
-    val blue = Player(TestTeam.BLUE)
 
     /** wechselt den Spieler, der aktuell an der Reihe ist anhand von `turn`  */
     fun switchCurrentPlayer() {
         currentPlayer = TestTeam.values()[(turn + startPlayer.index) % 2]
     }
 
-    override fun clone() = throw NotImplementedError()
+    override fun clone() = TestGameState(turn, state, currentPlayer, startPlayer, red, blue)
 }