1 files changed, 51 insertions, 8 deletions

diff --git a/src/ch/epfl/xblast/client/GameStateDeserializer.java b/src/ch/epfl/xblast/client/GameStateDeserializer.java
index 20b44f9..8b203b1 100644
--- a/src/ch/epfl/xblast/client/GameStateDeserializer.java
+++ b/src/ch/epfl/xblast/client/GameStateDeserializer.java
@@ -1,15 +1,13 @@
 package ch.epfl.xblast.client;
 
-import ch.epfl.xblast.Lists;
-import ch.epfl.xblast.PlayerID;
-import ch.epfl.xblast.RunLengthEncoder;
-import ch.epfl.xblast.SubCell;
+import ch.epfl.xblast.*;
 import ch.epfl.xblast.client.GameState.Player;
 
 import java.awt.*;
 import java.util.*;
 import java.util.List;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 /**
  * The client game state deserializer.
@@ -110,10 +108,48 @@ public final class GameStateDeserializer {
      * @return a list of Images corresponding to the serialized element
      */
     private static List<Image> deserializeImageChunk(List<Byte> data, ImageCollection imageCollection) {
-        return RunLengthEncoder.decode(data).stream()
+        return Collections.unmodifiableList(RunLengthEncoder.decode(data).stream()
                 .map(Byte::toUnsignedInt)
                 .map(imageCollection::imageOrNull)
-                .collect(Collectors.toList());
+                .collect(Collectors.toList()));
+    }
+
+    /**
+     * Unserializes a spiral-ordered byte representation of a board.
+     *
+     * @param serializedBoard the run-length-compressed, serialized spiral ordered board
+     * @return the row-major-ordered board
+     * @throws IllegalArgumentException if the length of the serialized board is invalid
+     */
+    private static List<Image> deserializeBoard(List<Byte> serializedBoard) {
+        List<Image> spiralOrdered = deserializeImageChunk(serializedBoard, ImageCollection.BOARD_IMAGES);
+
+        if (spiralOrdered.size() != Cell.SPIRAL_ORDER.size())
+            throw new IllegalArgumentException();
+
+        Map<Cell, Image> imageMap = IntStream
+                .range(0, Cell.SPIRAL_ORDER.size()).mapToObj(i -> i)
+                .collect(Collectors.toMap(Cell.SPIRAL_ORDER::get, spiralOrdered::get));
+
+        return Collections.unmodifiableList(Cell.ROW_MAJOR_ORDER.stream()
+                .map(imageMap::get)
+                .collect(Collectors.toList()));
+    }
+
+    /**
+     * Unserializes a byte representation of explosions and bombs.
+     *
+     * @param serializedExplosions the run-length-compressed, serialized explosions
+     * @return the explosions
+     * @throws IllegalArgumentException if the length of the serialized explosions is invalid
+     */
+    private static List<Image> deserializeExplosions(List<Byte> serializedExplosions) {
+        List<Image> explosions = deserializeImageChunk(serializedExplosions, ImageCollection.EXPLOSIONS_IMAGES);
+
+        if (explosions.size() != Cell.ROW_MAJOR_ORDER.size())
+            throw new IllegalArgumentException();
+
+        return explosions;
     }
 
     /**
@@ -160,6 +196,13 @@ public final class GameStateDeserializer {
                 .collect(Collectors.toList()));
     }
 
+    /**
+     * Unserializes a byte representation of the ticks.
+     *
+     * @param serializedTicks the serialized ticks
+     * @return the ticks
+     * @throws IllegalArgumentException if the byte chunk is invalid.
+     */
     private static int deserializeTicks(List<Byte> serializedTicks) {
         if (Objects.isNull(serializedTicks) || serializedTicks.size() != SERIALIZED_TICKS_LENGTH)
             throw new IllegalArgumentException();
@@ -176,10 +219,10 @@ public final class GameStateDeserializer {
     public static GameState deserialize(List<Byte> serializedData) {
         VariableLengthChunk chunks = new VariableLengthChunk(serializedData);
 
-        List<Image> board = deserializeImageChunk(chunks.head(), ImageCollection.BOARD_IMAGES);
+        List<Image> board = deserializeBoard(chunks.head());
         chunks = chunks.tail();
 
-        List<Image> explosions = deserializeImageChunk(chunks.head(), ImageCollection.EXPLOSIONS_IMAGES);
+        List<Image> explosions = deserializeExplosions(chunks.head());
         chunks = chunks.tail();
 
         List<Player> players = deserializePlayers(chunks.head(SERIALIZED_PLAYERS_LENGTH));