1 files changed, 264 insertions, 89 deletions

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();
+
+        //Check possible collisions and update the Sequence if necessary (kinda ugly right now)
+        directedPositions1 = GameState.handleCollisions(players0, directedPositions1, board1, bombedCells1);
+
+        // Apply damages and generate a new LifeState Sequence
+        Sq<Player.LifeState> lifeStates1 = GameState.nextLifeState(players0, directedPositions1, blastedCells1);
+
+        // Create the new player given the new parameters
+        Player p1 = new Player(players0.id(), lifeStates1, directedPositions1, players0.maxBombs(), players0.bombRange());
+
+        // Update the capacities of the player given the possible bonus
+        if (playerBonus != null)
+            p1 = playerBonus.applyTo(p1);
+
+        return p1;
+    }
+
+    /**
+     * Generate the new Sequence of Directed Positions.
+     *
+     * @param player0
+     * @param requestedDirection
+     * @return
+     */
+    private static Sq<Player.DirectedPosition> nextPath(Player player0, Direction requestedDirection) {
+        if (!player0.lifeState().canMove())
+            return Player.DirectedPosition.stopped(player0.directedPositions().head());
+
+        if (requestedDirection == null)
+            requestedDirection = player0.direction();
+
+        if (player0.direction().isParallelTo(requestedDirection))
+            return Player.DirectedPosition.moving(new Player.DirectedPosition(player0.position(), requestedDirection));
+
+        if (player0.direction().isPerpendicularTo(requestedDirection)) {
+            Player.DirectedPosition nextCentralSubCell = GameState.projectedDirectedPosition(player0, player0.directedPositions());
+            Sq<Player.DirectedPosition> toNextCentralSubCell = player0.directedPositions().takeWhile(dp -> !dp.position().isCentral());
+            Player.DirectedPosition centralSubCellDirectedPosition = new Player.DirectedPosition(nextCentralSubCell.position(), requestedDirection);
+            Sq<Player.DirectedPosition> pastNextCentralSubCell = Player.DirectedPosition.moving(centralSubCellDirectedPosition);
+            return toNextCentralSubCell.concat(pastNextCentralSubCell);
+        }
+
+        return player0.directedPositions();
+    }
+
+    /**
+     * Check possible collisions and update the Sequence if necessary (kinda ugly right now)
+     *
+     * @param player0
+     * @param projectedPath
+     * @param board1
+     * @param bombedCells1
+     * @return
+     */
+    private static Sq<Player.DirectedPosition> handleCollisions(Player player0,
+                                                                Sq<Player.DirectedPosition> projectedPath,
+                                                                Board board1, Set<Cell> bombedCells1) {
+
+        Cell projectedCell = GameState.projectedDirectedPosition(player0, projectedPath).position().containingCell();
+        if (GameState.isColliding(player0, projectedCell, board1, bombedCells1))
+            return Sq.repeat(1, player0.directedPositions().head())
+                    .concat(projectedPath);
+
+        return projectedPath;
+    }
+
+    /**
+     * @param player0
+     * @param projectedPath
+     * @return
+     */
+
+    private static Player.DirectedPosition projectedDirectedPosition(Player player0, Sq<Player.DirectedPosition> projectedPath) {
+        if (!player0.lifeState().canMove())
+            return new Player.DirectedPosition(player0.position(), player0.direction());
+
+        return projectedPath.tail()
+                .findFirst(directedPos -> directedPos.position().isCentral());
+    }
+
+    /**
+     * @param player0
+     * @param projectedCell
+     * @param board1
+     * @param bombedCells1
+     * @return
+     */
+    private static boolean isColliding(Player player0, Cell projectedCell, Board board1, Set<Cell> bombedCells1) {
+        if (!board1.blockAt(projectedCell).canHostPlayer())
+            return true;
+
+        if (bombedCells1.contains(projectedCell) && projectedCell.equals(player0.position().containingCell()))
+            if (player0.position().distanceToCentral() <= Board.BOMB_BLOCKING_DISTANCE)
+                return true;