Modularize next game state transition

2 files changed, 372 insertions, 350 deletions

diff --git a/src/ch/epfl/xblast/server/GameState.java b/src/ch/epfl/xblast/server/GameState.java
index b304a4d..564ef38 100644
--- a/src/ch/epfl/xblast/server/GameState.java
+++ b/src/ch/epfl/xblast/server/GameState.java
@@ -6,7 +6,6 @@ import ch.epfl.xblast.*;
 import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 
 /**
@@ -59,329 +58,26 @@ public final class GameState {
     }
 
     /**
-     * Maps bombs to their owning player ID.
-     *
-     * @param b the list of bombs
-     * @return the mapping
-     */
-    private static Map<PlayerID, List<Bomb>> mapBombsToPlayers(List<Bomb> b) {
-        return b.stream().collect(Collectors.groupingBy(Bomb::ownerId));
-    }
-
-    /**
-     * Computes the next state of a blast.
-     *
-     * @param blasts0     existing particles
-     * @param board0      the game's board
-     * @param explosions0 active explosions
-     * @return the position of the explosion's particles for the next state.
-     */
-    private static List<Sq<Cell>> nextBlasts(List<Sq<Cell>> blasts0, Board board0, List<Sq<Sq<Cell>>> explosions0) {
-        return Stream.concat(
-                blasts0.stream()
-                        .filter(b -> board0.blockAt(b.head()).isFree())
-                        .map(Sq::tail),
-                explosions0.stream()
-                        .filter(e -> !e.isEmpty())
-                        .map(Sq::head))
-                .filter(b -> !b.isEmpty())
-                .collect(Collectors.toList());
-    }
-
-    /**
-     * Computes and returns the next board state of the given board according to the given events.
-     *
-     * @param board0          the previous board
-     * @param consumedBonuses the set of consumed bonuses
-     * @param blastedCells1   the set of newly blasted cells
-     * @return the next board
-     */
-    private static Board nextBoard(Board board0, Set<Cell> consumedBonuses, Set<Cell> blastedCells1) {
-        return new Board(Cell.ROW_MAJOR_ORDER.stream()
-                .map(c -> GameState.nextBlockSeq(c, board0.blocksAt(c), consumedBonuses, blastedCells1))
-                .collect(Collectors.toList()));
-    }
-
-    /**
-     * 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(Block.getRandomBonusBlock()));
-
-            else if (b.isBonus())
-                return Sq.repeat(Ticks.BONUS_DISAPPEARING_TICKS, b)
-                        .concat(Sq.constant(Block.FREE));
-
-        return bs0.tail();
-    }
-
-    /**
-     * Computes and returns the next player list given the current one and the given events and states.
-     *
-     * @param players0          the previous player list
-     * @param playerBonuses     the map of player bonuses
-     * @param bombedCells1      the set of newly bombed cells
-     * @param board1            the newly updated board
-     * @param blastedCells1     the set of newly blasted cells
-     * @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) {
-
-        return players0.stream()
-                .map(p -> GameState.nextPlayer(
-                        p, playerBonuses.get(p.id()),
-                        bombedCells1, board1, blastedCells1,
-                        speedChangeEvents.get(p.id())))
-                .collect(Collectors.toList());
-    }
-
-    /**
-     * Computes and returns the next State of a Player from the given events.
-     *
-     * @param player0            the Player
-     * @param playerBonus        the optional Bonus to apply to the Player
-     * @param bombedCells1       the Set of bombed Cells
-     * @param board1             the updated Board
-     * @param blastedCells1      the Set of blasted Cells
-     * @param requestedDirection the Player's new requested Direction
-     * @return the next state of the Player
-     */
-    private static Player nextPlayer(Player player0, Bonus playerBonus,
-                                     Set<Cell> bombedCells1, Board board1, Set<Cell> blastedCells1,
-                                     Optional<Direction> requestedDirection) {
-
-        // 1. Compute the new path to follow
-        Sq<Player.DirectedPosition> updatedPath = GameState.nextPath(player0.directedPositions(), requestedDirection);
-
-        // 2. Follow the path if the Player can (moving life state and no collision)
-        Sq<Player.DirectedPosition> directedPos1 = GameState.moveAhead(player0, updatedPath, board1, bombedCells1);
-
-        // 3. Apply damages and generate a new LifeState Sequence
-        Sq<Player.LifeState> lifeStates1 = GameState.nextLifeState(player0, directedPos1, blastedCells1);
-
-        // 4. Create the new player given the new parameters
-        Player p1 = new Player(player0.id(), lifeStates1, directedPos1, player0.maxBombs(), player0.bombRange());
-
-        // 5. Update the capacities of the player given the possible bonus
-        if (!Objects.isNull(playerBonus))
-            p1 = playerBonus.applyTo(p1);
-
-        return p1;
-    }
-
-    /**
-     * Computes the new path to follow according to the Player's wishes and the Board constraints.
-     *
-     * @param p0     the current path
-     * @param newDir the new requested Direction
-     * @return the new path
-     */
-    private static Sq<Player.DirectedPosition> nextPath(Sq<Player.DirectedPosition> p0, Optional<Direction> newDir) {
-        if (Objects.isNull(newDir))
-            return p0;
-
-        if (!newDir.isPresent())
-            return GameState.stopPath(p0);
-
-        if (p0.head().direction().isPerpendicularTo(newDir.get()))
-            return GameState.pivotPath(Player.DirectedPosition.moving(p0.head()), newDir.get());
-
-        return Player.DirectedPosition.moving(new Player.DirectedPosition(p0.head().position(), newDir.get()));
-    }
-
-    /**
-     * Builds and returns a path stopping at the next central SubCell.
-     *
-     * @param p0 the current path
-     * @return the stop path
-     */
-    private static Sq<Player.DirectedPosition> stopPath(Sq<Player.DirectedPosition> p0) {
-        return GameState
-                .pathToNextCentralPosition(p0)
-                .concat(Player.DirectedPosition.stopped(GameState.nextCentral(p0)));
-    }
-
-    /**
-     * Builds and returns a pivot path reaching the next pivot SubCell and then rotating to the given Direction.
-     *
-     * @param p0     the initial path
-     * @param newDir the new Direction to follow when possible
-     * @return the pivot path
-     */
-    private static Sq<Player.DirectedPosition> pivotPath(Sq<Player.DirectedPosition> p0, Direction newDir) {
-        SubCell nextCentralPos = GameState.nextCentral(p0).position();
-
-        return GameState
-                .pathToNextCentralPosition(p0)
-                .concat(Player.DirectedPosition.moving(new Player.DirectedPosition(nextCentralPos, newDir)));
-    }
-
-    /**
-     * Returns the path to the next central SubCell.
-     *
-     * @param p the path to follow
-     * @return the truncated path
-     */
-    private static Sq<Player.DirectedPosition> pathToNextCentralPosition(Sq<Player.DirectedPosition> p) {
-        return p.takeWhile(dp -> !dp.position().isCentral());
-    }
-
-    /**
-     * Searches for and returns the next central SubCell reachable following the given path.
-     *
-     * @param p the path to follow
-     * @return the next central SubCell
-     */
-    private static Player.DirectedPosition nextCentral(Sq<Player.DirectedPosition> p) {
-        return p.findFirst(dp -> dp.position().isCentral());
-    }
-
-    /**
-     * Checks for possible collisions and update the path if necessary.
-     *
-     * @param path         the current path projection
-     * @param board1       the updated Board
+     * Maps the given bombs to their position.