9 files changed, 516 insertions, 126 deletions

diff --git a/src/ch/epfl/xblast/Direction.java b/src/ch/epfl/xblast/Direction.java
index 030038b..e2df042 100644
--- a/src/ch/epfl/xblast/Direction.java
+++ b/src/ch/epfl/xblast/Direction.java
@@ -68,6 +68,25 @@ public enum Direction {
     }
 
     /**
+     * T(the current and given Directions are perpendicular).
+     *
+     * @param that a Direction to compare
+     * @return T(the current and given Directions are perpendicular)
+     */
+    public boolean isPerpendicularTo(Direction that) {
+        switch (this) {
+            case N:
+            case S:
+                return that == E || that == W;
+            case E:
+            case W:
+                return that == N || that == S;
+            default:
+                return false;
+        }
+    }
+
+    /**
      * Returns the x-coordinate of the normed vector representation of the Direction.
      *
      * @return the x-coordinate
diff --git a/src/ch/epfl/xblast/server/Board.java b/src/ch/epfl/xblast/server/Board.java
index f2a3c89..79259b5 100644
--- a/src/ch/epfl/xblast/server/Board.java
+++ b/src/ch/epfl/xblast/server/Board.java
@@ -5,6 +5,7 @@ import ch.epfl.xblast.Cell;
 import ch.epfl.xblast.Lists;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -15,6 +16,11 @@ import java.util.List;
  */
 public final class Board {
 
+    /**
+     * Distance (in SubCells) from a bomb to block a player.
+     */
+    public static final int BOMB_BLOCKING_DISTANCE = 6;
+
     private static final int BLOCKS_LIST_SIZE = 195;
     private static final int BOARD_ROWS = 13;
     private static final int BOARD_COLUMNS = 15;
@@ -44,7 +50,6 @@ public final class Board {
      * List containing all the blocks of the board.
      */
     private List<Sq<Block>> blocks;
-
     /**
      * Instantiates a new Board with the given sequence of blocks.
      *
@@ -55,7 +60,7 @@ public final class Board {
         if (blocks == null || blocks.size() != BLOCKS_LIST_SIZE)
             throw new IllegalArgumentException();
 
-        this.blocks = blocks;
+        this.blocks = new ArrayList<>(blocks);
     }
 
     /**
@@ -142,12 +147,4 @@ public final class Board {
         return this.blocksAt(c).head();
     }
 
-    /**
-     * Return the blocks of the Board.
-     *
-     * @return a list of the Sequences of blocks of the board.
-     */
-    public List<Sq<Block>> getBlocks() {
-        return blocks;
-    }
 }
diff --git a/src/ch/epfl/xblast/server/GameState.java b/src/ch/epfl/xblast/server/GameState.java
index 1abe17a..0d381db 100644
--- a/src/ch/epfl/xblast/server/GameState.java
+++ b/src/ch/epfl/xblast/server/GameState.java
@@ -8,6 +8,7 @@ import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+
 /**
  * GameState representing the current game state.
  *
@@ -102,12 +103,14 @@ public final class GameState {
     private static List<Sq<Cell>> nextBlasts(List<Sq<Cell>> blasts0, Board board0, List<Sq<Sq<Cell>>> explosions0) {
         return Stream.concat(
                 blasts0.stream()
-                        .filter(blastSeq -> !blastSeq.tail().isEmpty())
-                        .filter(blastSeq -> board0.blockAt(blastSeq.head()).isFree())
+                        .filter(b -> !b.tail().isEmpty())
+                        .filter(b -> board0.blockAt(b.head()).isFree())
                         .map(Sq::tail),
                 explosions0.stream()
+                        .filter(e -> !e.isEmpty())
                         .map(Sq::head)
-        ).collect(Collectors.toList());
+                        .filter(b -> !b.isEmpty()))
+                .collect(Collectors.toList());
     }
 
     /**
@@ -119,29 +122,36 @@ public final class GameState {
      * @return the next board
      */
     private static Board nextBoard(Board board0, Set<Cell> consumedBonuses, Set<Cell> blastedCells1) {
-        List<Sq<Block>> blocks0 = board0.getBlocks();
-        List<Sq<Block>> blocks1 = new ArrayList<>();
-
-        int i = 0;
-        for (Sq<Block> blockSq : blocks0) {
-            int cellId = blocks0.get(i).hashCode();
-            Block block = blockSq.head();
-            if (((HashSet) consumedBonuses).contains(cellId) && block.isBonus()) {
-                blocks1.add(Sq.constant(Block.FREE));
-            } else if (((HashSet) blastedCells1).contains(cellId) && (block == Block.DESTRUCTIBLE_WALL || block.isBonus())) {
-                if (block == Block.DESTRUCTIBLE_WALL) {
-                    Block bonus = randomBonus();
-                    blocks1.add(Sq.repeat(Ticks.WALL_CRUMBLING_TICKS, Block.CRUMBLING_WALL).concat(Sq.constant(bonus)));
-                } else {
-                    blocks1.add(Sq.repeat(Ticks.BONUS_DISAPPEARING_TICKS, block).concat(Sq.constant(Block.FREE)));
-                }
-            } else {
-                blocks1.add(blockSq.tail());
-            }
-            i++;
-        }
+        return new Board(Cell.ROW_MAJOR_ORDER.stream()
+                .map(c -> GameState.nextBlockSeq(c, board0.blocksAt(c), consumedBonuses, blastedCells1))
+                .collect(Collectors.toList()));
+    }
 
-        return new Board(blocks1);
+    /**
+     * Returns the next Block sequence for the given cell according to the current state and given events.
+     *
+     * @param c               the Cell
+     * @param bs0             the previous Block sequence
+     * @param consumedBonuses the bonus consumption event
+     * @param blastedCells1   the new Cell blast events
+     * @return the new Block sequence
+     */
+    private static Sq<Block> nextBlockSeq(Cell c, Sq<Block> bs0, Set<Cell> consumedBonuses, Set<Cell> blastedCells1) {
+        Block b = bs0.head();
+
+        if (consumedBonuses.contains(c) && b.isBonus())
+            return Sq.constant(Block.FREE);
+
+        if (blastedCells1.contains(c))
+            if (b == Block.DESTRUCTIBLE_WALL)
+                return Sq.repeat(Ticks.WALL_CRUMBLING_TICKS, Block.CRUMBLING_WALL)
+                        .concat(Sq.constant(GameState.randomBonus()));
+
+            else if (b.isBonus())
+                return Sq.repeat(Ticks.BONUS_DISAPPEARING_TICKS, b)
+                        .concat(Sq.constant(Block.FREE));
+
+        return bs0.tail();
     }
 
     /**
@@ -155,15 +165,142 @@ public final class GameState {
      * @param speedChangeEvents the speed change events
      * @return the next player list
      */
-    private static List<Player> nextPlayers(
-            List<Player> players0,
-            Map<PlayerID, Bonus> playerBonuses,
-            Set<Cell> bombedCells1,
-            Board board1,
-            Set<Cell> blastedCells1,
-            Map<PlayerID, Optional<Direction>> speedChangeEvents) {
-        //ToDo
-        return players0;
+    private static List<Player> nextPlayers(List<Player> players0, Map<PlayerID, Bonus> playerBonuses,
+                                            Set<Cell> bombedCells1, Board board1, Set<Cell> blastedCells1,
+                                            Map<PlayerID, Optional<Direction>> speedChangeEvents) {
+
+        return players0.stream()
+                .map(p -> {
+                    Optional<Direction> speedChangeEvent = speedChangeEvents.get(p.id());
+                    Direction requestedDirection = speedChangeEvent != null ? speedChangeEvent.orElse(null) : null;
+                    return GameState.nextPlayer(p, playerBonuses.get(p.id()), bombedCells1, board1, blastedCells1, requestedDirection);
+                })
+                .collect(Collectors.toList());
+    }
+
+    private static Player nextPlayer(Player players0, Bonus playerBonus,
+                                     Set<Cell> bombedCells1, Board board1, Set<Cell> blastedCells1,
+                                     Direction requestedDirection) {
+
+        Sq<Player.DirectedPosition> directedPositions1 = GameState.nextPath(players0, requestedDirection);
+
+        // Advance of one SubCell on the player's path
+        directedPositions1 = directedPositions1.tail();