Merge branch '02_board' into 'master' 02_board

02 board



See merge request !1

5 files changed, 292 insertions, 1 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
new file mode 100644
index 0000000..51e76b0
--- /dev/null
+++ b/src/ch/epfl/xblast/Lists.java
@@ -0,0 +1,47 @@
+package ch.epfl.xblast;
+
+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 {
+
+    /**
+     * Returns a reversed copy of the given list, leaving the original one unmodified.
+     *
+     * @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
+     */
+    public static <T> List<T> mirrored(List<T> l) {
+        if (l == null || l.size() == 0) throw new IllegalArgumentException();
+
+        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
new file mode 100644
index 0000000..409f68e
--- /dev/null
+++ b/src/ch/epfl/xblast/server/Block.java
@@ -0,0 +1,58 @@
+package ch.epfl.xblast.server;
+
+/**
+ * A Block.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
+public enum Block {
+
+    /**
+     * 'Free' block, no wall.
+     */
+    FREE,
+
+    /**
+     * Indestructible block.
+     */
+    INDESTRUCTIBLE_WALL,
+
+    /**
+     * Destructible block.
+     */
+    DESTRUCTIBLE_WALL,
+
+    /**
+     * Crumbling Wall.
+     */
+    CRUMBLING_WALL;
+
+    /**
+     * Returns T(this block is free).
+     *
+     * @return T(this block is free)
+     */
+    public boolean isFree() {
+        return this == FREE;
+    }
+
+    /**
+     * Returns T(this block can host a player).
+     *
+     * @return T(this block can host a player)
+     */
+    public boolean canHostPlayer() {
+        return this.isFree();
+    }
+
+    /**
+     * 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
new file mode 100644
index 0000000..5e03671
--- /dev/null
+++ b/src/ch/epfl/xblast/server/Board.java
@@ -0,0 +1,145 @@
+package ch.epfl.xblast.server;
+
+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;
+
+    /**
+     * Instantiates a new Board with the given sequence of blocks.
+     *
+     * @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 == null || blocks.size() != BLOCKS_LIST_SIZE)
+            throw new IllegalArgumentException();
+
+        this.blocks = blocks;
+    }
+
+    /**
+     * Build a new Board with the given Matrix.
+     *
+     * @param rows list containing all the rows
+     * @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) {
+        checkBlockMatrix(rows, BOARD_ROWS, BOARD_COLUMNS);
+        List<Sq<Block>> blocksSequence = new ArrayList<>();
+
+        for (List<Block> row : rows)
+            for (Block aRow : row)
+                blocksSequence.add(Sq.constant(aRow));
+
+        return new Board(blocksSequence);
+    }
+
+    /**
+     * Build a walled board filled with the given inner rows
+     *
+     * @param innerBlocks lists of the internal rows
+     * @return a new walled board filled with the given rows
+     * @throws IllegalArgumentException if innerBlocks is not INNER_BOARD_ROWS * INNER_BOARD_COLUMNS
+     */
+    public static Board ofInnerBlocksWalled(List<List<Block>> innerBlocks) {
+        checkBlockMatrix(innerBlocks, INNER_BOARD_ROWS, INNER_BOARD_COLUMNS);
+        List<List<Block>> rowsList = new ArrayList<>();
+        List<Block> wallLine = new ArrayList<>();
+
+        for (int i = 0; i < BOARD_COLUMNS; i++)
+            wallLine.add(Block.INDESTRUCTIBLE_WALL);
+
+        for (List<Block> row : innerBlocks) {
+            row.add(0, Block.INDESTRUCTIBLE_WALL);
+            row.add(Block.INDESTRUCTIBLE_WALL);
+
+            rowsList.add(row);
+        }
+
+        rowsList.add(0, wallLine);
+        rowsList.add(wallLine);
+
+        return ofRows(rowsList);
+    }