5 files changed, 137 insertions, 90 deletions

diff --git a/src/ch/epfl/xblast/Direction.java b/src/ch/epfl/xblast/Direction.java
index 700f9be..030038b 100644
--- a/src/ch/epfl/xblast/Direction.java
+++ b/src/ch/epfl/xblast/Direction.java
@@ -2,7 +2,7 @@ package ch.epfl.xblast;
 
 /**
  * A Direction.
- * 
+ *
  * @author Pacien TRAN-GIRARD (261948)
  * @author Timothée FLOURE (257420)
  */
diff --git a/src/ch/epfl/xblast/Lists.java b/src/ch/epfl/xblast/Lists.java
index 096ceba..51e76b0 100644
--- a/src/ch/epfl/xblast/Lists.java
+++ b/src/ch/epfl/xblast/Lists.java
@@ -1,38 +1,47 @@
 package ch.epfl.xblast;
 
-import java.util.List;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
+ * Lists utility class providing common operations on lists.
+ *
  * @author Pacien TRAN-GIRARD (261948)
  * @author Timothée FLOURE (257420)
  */
 public final class Lists {
+
     /**
-     * Return a sysmetric version of the list.
+     * Returns a reversed copy of the given list, leaving the original one unmodified.
      *
-     * @param l the input list
+     * @param l   the list to reverse
+     * @param <T> the type of the list's elements
+     * @return a reversed copy of the list.
+     */
+    public static <T> List<T> reversed(List<T> l) {
+        List<T> r = new ArrayList<>(l);
+        Collections.reverse(r);
+        return r;
+    }
+
+    /**
+     * Returns a symmetric version of the list, without repeating the last element of the input list.
+     * For instance, mirrored([kay]) will return [kayak].
+     *
+     * @param l   the input list
+     * @param <T> the type of the list's elements
+     * @return the mirrored list
      * @throws IllegalArgumentException if the given list is empty
-     * @return mirroredList the mirrored ilist
      */
     public static <T> List<T> mirrored(List<T> l) {
-        if (l.size() == 0) {
-            throw new IllegalArgumentException();
-        }
-
-        List<T> mirroredList = new ArrayList<T>();
-        List<T> rightSide = new ArrayList<T>();
-
-        for (int i=0;i < l.size()-1;i++) {
-            rightSide.add(l.get(i));
-        }
+        if (l == null || l.size() == 0) throw new IllegalArgumentException();
 
-        Collections.reverse(rightSide);
-
-        mirroredList.addAll(l);
-        mirroredList.addAll(rightSide);
-
-        return mirroredList;
+        return Stream
+                .concat(l.stream(), Lists.reversed(l).stream().skip(1))
+                .collect(Collectors.toList());
     }
+
 }
diff --git a/src/ch/epfl/xblast/server/Block.java b/src/ch/epfl/xblast/server/Block.java
index 8268f33..409f68e 100644
--- a/src/ch/epfl/xblast/server/Block.java
+++ b/src/ch/epfl/xblast/server/Block.java
@@ -1,5 +1,11 @@
 package ch.epfl.xblast.server;
 
+/**
+ * A Block.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
 public enum Block {
 
     /**
@@ -41,11 +47,12 @@ public enum Block {
     }
 
     /**
-     * Returns T(this block cast a shadow)
+     * Returns T(this block cast a shadow).
      *
-     * @returns T(this block cast a shadow)
+     * @return T(this block cast a shadow)
      */
     public boolean castsShadow() {
         return this == INDESTRUCTIBLE_WALL || this == DESTRUCTIBLE_WALL || this == CRUMBLING_WALL;
     }
+
 }
diff --git a/src/ch/epfl/xblast/server/Board.java b/src/ch/epfl/xblast/server/Board.java
index fa91587..5e03671 100644
--- a/src/ch/epfl/xblast/server/Board.java
+++ b/src/ch/epfl/xblast/server/Board.java
@@ -1,31 +1,60 @@
 package ch.epfl.xblast.server;
 
-import java.util.List;
-import java.util.ArrayList;
 import ch.epfl.cs108.Sq;
+import ch.epfl.xblast.Cell;
 import ch.epfl.xblast.Lists;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
+ * A two-dimensional Board in which the game takes place.
+ *
  * @author Pacien TRAN-GIRARD (261948)
  * @author Timothée FLOURE (257420)
  */
-
 public final class Board {
+
+    private static final int BLOCKS_LIST_SIZE = 195;
+    private static final int BOARD_ROWS = 13;
+    private static final int BOARD_COLUMNS = 15;
+    private static final int INNER_BOARD_ROWS = BOARD_ROWS - 2;
+    private static final int INNER_BOARD_COLUMNS = BOARD_COLUMNS - 2;
+    private static final int QUADRANT_ROWS = 6;
+    private static final int QUADRANT_COLUMNS = 7;
+
+    /**
+     * Throw an exception if the matrix does not have the given number of rows/columns.
+     *
+     * @param matrix  the tested matrix
+     * @param rows    the expected number of rows
+     * @param columns the expected number of columns
+     * @throws IllegalArgumentException if the matrix does not comply with the given sizes.
+     */
+    private static void checkBlockMatrix(List<List<Block>> matrix, int rows, int columns) {
+        if (matrix == null || matrix.size() != rows)
+            throw new IllegalArgumentException();
+
+        for (int i = 0; i < rows; i++)
+            if (matrix.get(i).size() != columns)
+                throw new IllegalArgumentException();
+    }
+
     /**
      * List containing all the blocks of the board.
      */
     private List<Sq<Block>> blocks;
 
     /**
-     * Instanciates a new Board with the given sequence of blocks.
+     * Instantiates a new Board with the given sequence of blocks.
      *
-     * @throws IllegalArgumentEception if the blocks is not composed of 195 elements
-     * @param blocks sequence conataining all the blocks of the Boards
+     * @param blocks sequence containing all the blocks of the Boards
+     * @throws IllegalArgumentException if the blocks is not composed of BLOC_LIST_SIZE elements
      */
-    public Board (List<Sq<Block>> blocks) {
-        if (blocks.size() != 195) {
+    public Board(List<Sq<Block>> blocks) {
+        if (blocks == null || blocks.size() != BLOCKS_LIST_SIZE)
             throw new IllegalArgumentException();
-        }
+
         this.blocks = blocks;
     }
 
@@ -33,90 +62,84 @@ public final class Board {
      * Build a new Board with the given Matrix.
      *
      * @param rows list containing all the rows
-     * @throws IllegalArgumentException if rows is not 13*15
      * @return a new Board built with given rows
+     * @throws IllegalArgumentException if rows is not BOARD_ROWS * BOARD_COLUMNS
      */
     public static Board ofRows(List<List<Block>> rows) {
-        if (rows.size() != 13) {
-            throw new IllegalArgumentException();
-        }
-
+        checkBlockMatrix(rows, BOARD_ROWS, BOARD_COLUMNS);
         List<Sq<Block>> blocksSequence = new ArrayList<>();
 
-        for (int i = 0; i < rows.size(); i++) {
-
+        for (List<Block> row : rows)
+            for (Block aRow : row)