5 files changed, 644 insertions, 0 deletions

diff --git a/src/ch/epfl/xblast/client/GameState.java b/src/ch/epfl/xblast/client/GameState.java
new file mode 100644
index 0000000..7652cd5
--- /dev/null
+++ b/src/ch/epfl/xblast/client/GameState.java
@@ -0,0 +1,147 @@
+package ch.epfl.xblast.client;
+
+import ch.epfl.xblast.ArgumentChecker;
+import ch.epfl.xblast.Lists;
+import ch.epfl.xblast.PlayerID;
+import ch.epfl.xblast.SubCell;
+import ch.epfl.xblast.client.painter.ScorePainter;
+import ch.epfl.xblast.client.painter.TimeLinePainter;
+
+import java.awt.*;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * The client representation of a game state.
+ *
+ * @author Timothée FLOURE (257420)
+ * @author Pacien TRAN-GIRARD (261948)
+ */
+public final class GameState {
+
+    /**
+     * A Player.
+     */
+    public static final class Player {
+
+        private final PlayerID id;
+        private final int lives;
+        private final SubCell position;
+        private final Image image;
+
+        /**
+         * Instantiates a new Player.
+         *
+         * @param id       id of the player
+         * @param lives    number of lives of the player
+         * @param position position of the player
+         * @param image    image related to the actual state of the player
+         */
+        public Player(PlayerID id, int lives, SubCell position, Image image) {
+            this.id = id;
+            this.lives = lives;
+            this.position = Objects.requireNonNull(position);
+            this.image = Objects.requireNonNull(image);
+        }
+
+        /**
+         * @return the player ID
+         */
+        public PlayerID id() {
+            return this.id;
+        }
+
+        /**
+         * @return the number of lives of the player
+         */
+        public int lives() {
+            return this.lives;
+        }
+
+        /**
+         * @return the position of the player
+         */
+        public SubCell position() {
+            return this.position;
+        }
+
+        /**
+         * @return the image related to the actual state of the player
+         */
+        public Image image() {
+            return this.image;
+        }
+
+    }
+
+    private final List<Player> players;
+    private final List<Image> board;
+    private final List<Image> explosions;
+    private final List<Image> scores;
+    private final List<Image> ticks;
+
+    /**
+     * Instantiates a new GameState.
+     *
+     * @param players    list containing the players
+     * @param board      list containing all the images composing the board
+     * @param explosions list containing all the images composing the blasts and the bombs
+     * @param scores     list containing all the images composing the actual score
+     * @param ticks      list containing all the images composing the time "line"
+     */
+    public GameState(List<Player> players, List<Image> board, List<Image> explosions, List<Image> scores, List<Image> ticks) {
+        this.players = Lists.immutableList(ArgumentChecker.requireNonEmpty(players));
+        this.board = Lists.immutableList(ArgumentChecker.requireNonEmpty(board));
+        this.explosions = Lists.immutableList(Objects.requireNonNull(explosions));
+        this.scores = Lists.immutableList(ArgumentChecker.requireNonEmpty(scores));
+        this.ticks = Lists.immutableList(ArgumentChecker.requireNonEmpty(ticks));
+    }
+
+    /**
+     * Instantiates a new GameState.
+     *
+     * @param players    list containing the players
+     * @param board      list containing all the images composing the board
+     * @param explosions list containing all the images composing the blasts and the bombs
+     * @param ticks      the ticks
+     */
+    public GameState(List<Player> players, List<Image> board, List<Image> explosions, int ticks) {
+        this(players, board, explosions, ScorePainter.buildScorePanel(players), TimeLinePainter.buildTimeLine(ticks));
+    }
+
+    /**
+     * @return list containing the players
+     */
+    public List<Player> players() {
+        return this.players;
+    }
+
+    /**
+     * @return list containing all the images composing the board
+     */
+    public List<Image> board() {
+        return this.board;
+    }
+
+    /**
+     * @return ist containing all the images composing the blasts and the bombs
+     */
+    public List<Image> explosions() {
+        return this.explosions;
+    }
+
+    /**
+     * @return list containing all the images composing the actual score
+     */
+    public List<Image> scores() {
+        return this.scores;
+    }
+
+    /**
+     * @return list containing all the images composing the time "line"
+     */
+    public List<Image> ticks() {
+        return this.ticks;
+    }
+
+}
diff --git a/src/ch/epfl/xblast/client/GameStateDeserializer.java b/src/ch/epfl/xblast/client/GameStateDeserializer.java
new file mode 100644
index 0000000..20b44f9
--- /dev/null
+++ b/src/ch/epfl/xblast/client/GameStateDeserializer.java
@@ -0,0 +1,193 @@
+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.client.GameState.Player;
+
+import java.awt.*;
+import java.util.*;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * The client game state deserializer.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
+public final class GameStateDeserializer {
+
+    private static final int SERIALIZED_PLAYER_LENGTH = 4;
+    private static final int SERIALIZED_PLAYERS_LENGTH = PlayerID.values().length * SERIALIZED_PLAYER_LENGTH;
+    private static final int SERIALIZED_TICKS_LENGTH = 1;
+
+    /**
+     * Represents a length-prefixed chunk of byte-encoded data.
+     */
+    private static class VariableLengthChunk {
+
+        private static final int PREFIX_SHIFT = 1;
+
+        private final List<Byte> bytes;
+
+        /**
+         * Instantiates a VariableLengthChunk from a byte sequence.
+         *
+         * @param l the byte sequence
+         */
+        public VariableLengthChunk(List<Byte> l) {
+            this.bytes = Lists.immutableList(l);
+        }
+
+        /**
+         * Returns the length of the chunk given by its prefix.
+         *
+         * @return the length of the chunk
+         */
+        public int length() {
+            if (this.bytes.isEmpty())
+                return 0;
+            else
+                return Byte.toUnsignedInt(this.bytes.get(0));
+        }
+
+        /**
+         * Returns the head of the desired length of the chunk.
+         *
+         * @param takeFirst the desired length
+         * @return the head
+         */
+        public List<Byte> head(int takeFirst) {
+            return this.bytes.subList(0, takeFirst);
+        }
+
+        /**
+         * Returns the head of the size-prefixed chunk.
+         *
+         * @return the head
+         */
+        public List<Byte> head() {
+            if (this.length() < 1)
+                return Collections.emptyList();
+            else
+                return this.bytes.subList(PREFIX_SHIFT, this.length() + PREFIX_SHIFT);
+        }
+
+        /**