5 files changed, 428 insertions, 26 deletions

diff --git a/src/ch/epfl/xblast/Cell.java b/src/ch/epfl/xblast/Cell.java
index d31a889..06dfdbb 100644
--- a/src/ch/epfl/xblast/Cell.java
+++ b/src/ch/epfl/xblast/Cell.java
@@ -171,7 +171,17 @@ public final class Cell {
         if (that == null) return false;
         if (that == this) return true;
         if (!(that instanceof Cell)) return false;
-        return (((Cell) that).x == this.x && ((Cell) that).y == this.y);
+        return (((Cell) that).rowMajorIndex() == this.rowMajorIndex());
+    }
+
+    /**
+     * Returns the hash code for this Cell, given by its row-major index.
+     *
+     * @return the hash code
+     */
+    @Override
+    public int hashCode() {
+        return this.rowMajorIndex();
     }
 
     /**
diff --git a/src/ch/epfl/xblast/SubCell.java b/src/ch/epfl/xblast/SubCell.java
index a95e65e..27d5bcc 100644
--- a/src/ch/epfl/xblast/SubCell.java
+++ b/src/ch/epfl/xblast/SubCell.java
@@ -133,7 +133,17 @@ public final class SubCell {
         if (that == null) return false;
         if (that == this) return true;
         if (!(that instanceof SubCell)) return false;
-        return (((SubCell) that).x == this.x && ((SubCell) that).y == this.y);
+        return (((SubCell) that).rowMajorIndex() == this.rowMajorIndex());
+    }
+
+    /**
+     * Returns the hash code of this SubCell, given by its row-major index.
+     *
+     * @return the hash code
+     */
+    @Override
+    public int hashCode() {
+        return this.rowMajorIndex();
     }
 
     /**
@@ -146,4 +156,13 @@ public final class SubCell {
         return String.format("(%d,%d)", this.x, this.y);
     }
 
+    /**
+     * Returns the index of the SubCell (major ordered).
+     *
+     * @return the index of the SubCell
+     */
+    private int rowMajorIndex() {
+        return this.y * SUB_COLUMNS + this.x;
+    }
+
 }
diff --git a/src/ch/epfl/xblast/server/Board.java b/src/ch/epfl/xblast/server/Board.java
index 18ee532..f2a3c89 100644
--- a/src/ch/epfl/xblast/server/Board.java
+++ b/src/ch/epfl/xblast/server/Board.java
@@ -142,4 +142,12 @@ 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 ef792b6..1abe17a 100644
--- a/src/ch/epfl/xblast/server/GameState.java
+++ b/src/ch/epfl/xblast/server/GameState.java
@@ -1,14 +1,10 @@
 package ch.epfl.xblast.server;
 
 import ch.epfl.cs108.Sq;
-import ch.epfl.xblast.ArgumentChecker;
-import ch.epfl.xblast.Cell;
-import ch.epfl.xblast.PlayerID;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
+import ch.epfl.xblast.*;
+
+import java.util.*;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -20,33 +16,209 @@ import java.util.stream.Stream;
  */
 public final class GameState {
 
-    private final int ticks;
-    private final Board board;
-    private final List<Player> players;
-    private final List<Bomb> bombs;
-    private final List<Sq<Sq<Cell>>> explosions;
-    private final List<Sq<Cell>> blasts;
+    /**
+     * The list of player priority order permutations.
+     */
+    private static final List<List<PlayerID>> PLAYER_PRIORITY_ORDERS = GameState.buildPlayerPriorityOrderList();
+
+    /**
+     * The list of bonuses to choose randomly from.
+     */
+    private static final Block[] RANDOM_BONUSES = new Block[]{Block.BONUS_BOMB, Block.BONUS_RANGE, Block.FREE};
+
+    /**
+     * The seed used for random value generation.
+     * Constant between executions to make tests reproducible.
+     */
+    private static final int RANDOM_SEED = 2016;
+
+    /**
+     * Pseudo-random source for randomized behaviours.
+     */
+    private static final Random RANDOM_SOURCE = new Random(GameState.RANDOM_SEED);
 
     /**
-     * Compute the next state of a blast.
+     * Builds and returns the player priority order permutations.
      *
-     * @param blasts     existing particles
-     * @param board      the game's board
-     * @param explosions active explosions
+     * @return the list of player priority orders
+     */
+    private static List<List<PlayerID>> buildPlayerPriorityOrderList() {
+        return Lists.permutations(Arrays.asList(PlayerID.values()));
+    }
+
+    /**
+     * Returns a randomly chosen bonus Block with an equal probability distribution.
+     *
+     * @return a random bonus block
+     */
+    private static Block randomBonus() {
+        int randomIndex = RANDOM_SOURCE.nextInt(GameState.RANDOM_BONUSES.length);
+        return GameState.RANDOM_BONUSES[randomIndex];
+    }
+
+    /**
+     * Filters the given list of players and returns the lively ones.
+     *
+     * @param players a list of players
+     * @return the list of alive players
+     */
+    private static List<Player> alivePlayers(List<Player> players) {
+        return players.stream()
+                .filter(Player::isAlive)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Maps the given bombs to their position.
+     *
+     * @param bombs a list of bombs
+     * @return a map of positions and their bombs
+     */
+    private static Map<Cell, Bomb> bombedCells(List<Bomb> bombs) {
+        return bombs.stream()
+                .collect(Collectors.toMap(Bomb::position, Function.identity()));
+    }
+
+    /**
+     * Returns a set of cells that contains at least one blast in the given blasts sequences.
+     *
+     * @param blasts the list of blast sequences
+     * @return the set of blasted cells
+     */
+    private static Set<Cell> blastedCells(List<Sq<Cell>> blasts) {
+        return blasts.stream()
+                .map(Sq::head)
+                .collect(Collectors.toSet());
+    }
+
+    /**
+     * 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>> blasts, Board board, List<Sq<Sq<Cell>>> explosions) {
+    private static List<Sq<Cell>> nextBlasts(List<Sq<Cell>> blasts0, Board board0, List<Sq<Sq<Cell>>> explosions0) {
         return Stream.concat(
-                blasts.stream()
+                blasts0.stream()
                         .filter(blastSeq -> !blastSeq.tail().isEmpty())
-                        .filter(blastSeq -> board.blockAt(blastSeq.head()).isFree())
+                        .filter(blastSeq -> board0.blockAt(blastSeq.head()).isFree())
                         .map(Sq::tail),
-                explosions.stream()
+                explosions0.stream()
                         .map(Sq::head)
         ).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) {
+        List<Sq<Block>> blocks0 = board0.getBlocks();
+        List<Sq<Block>> blocks1 = new ArrayList<>();
+
+        int i = 0;
+        for (Sq<Block> blockSq : blocks0) {