3 files changed, 93 insertions, 30 deletions

diff --git a/src/ch/epfl/xblast/server/Bomb.java b/src/ch/epfl/xblast/server/Bomb.java
index f32960f..2eacf6c 100644
--- a/src/ch/epfl/xblast/server/Bomb.java
+++ b/src/ch/epfl/xblast/server/Bomb.java
@@ -69,6 +69,8 @@ public final class Bomb {
     }
 
     /**
+     * Returns the Bomb's owner ID.
+     *
      * @return the ID of the owner of the bomb
      */
     public PlayerID ownerId() {
@@ -76,6 +78,8 @@ public final class Bomb {
     }
 
     /**
+     * Returns the Bomb's position Cell.
+     *
      * @return the position of the bomb
      */
     public Cell position() {
@@ -83,6 +87,8 @@ public final class Bomb {
     }
 
     /**
+     * Returns the Bomb's fuse length sequence.
+     *
      * @return the length of the fuse
      */
     public Sq<Integer> fuseLengths() {
@@ -90,6 +96,8 @@ public final class Bomb {
     }
 
     /**
+     * Returns the Bomb's fuse length.
+     *
      * @return the remaining time before the explosion
      */
     public int fuseLength() {
@@ -97,6 +105,8 @@ public final class Bomb {
     }
 
     /**
+     * Returns the Bomb's range.
+     *
      * @return the range of the Bomb
      */
     public int range() {
@@ -104,6 +114,8 @@ public final class Bomb {
     }
 
     /**
+     * Builds and returns a new explosion sequence.
+     *
      * @return the explosion
      */
     public List<Sq<Sq<Cell>>> explosion() {
diff --git a/src/ch/epfl/xblast/server/GameState.java b/src/ch/epfl/xblast/server/GameState.java
index fefaf02..2797e41 100644
--- a/src/ch/epfl/xblast/server/GameState.java
+++ b/src/ch/epfl/xblast/server/GameState.java
@@ -206,9 +206,9 @@ public final class GameState {
     /**
      * Generate the new Sequence of Directed Positions.
      *
-     * @param player0
-     * @param requestedDirection
-     * @return
+     * @param player0            the Player
+     * @param requestedDirection the requested Direction
+     * @return the path
      */
     private static Sq<Player.DirectedPosition> nextPath(Player player0, Direction requestedDirection) {
         if (!player0.lifeState().canMove())
@@ -232,13 +232,13 @@ public final class GameState {
     }
 
     /**
-     * Check possible collisions and update the Sequence if necessary (kinda ugly right now)
+     * Checks for possible collisions and update the path if necessary.
      *
-     * @param player0
-     * @param projectedPath
-     * @param board1
-     * @param bombedCells1
-     * @return
+     * @param player0       the Player
+     * @param projectedPath the current path projection
+     * @param board1        the updated Board
+     * @param bombedCells1  the Set of bombed Cell-s
+     * @return the corrected path
      */
     private static Sq<Player.DirectedPosition> handleCollisions(Player player0,
                                                                 Sq<Player.DirectedPosition> projectedPath,
@@ -253,11 +253,12 @@ public final class GameState {
     }
 
     /**
-     * @param player0
-     * @param projectedPath
-     * @return
+     * Computes a projection of the next DirectedPosition.
+     *
+     * @param player0       the Player
+     * @param projectedPath the projected path
+     * @return the projected next DirectedPosition
      */
-
     private static Player.DirectedPosition projectedDirectedPosition(Player player0, Sq<Player.DirectedPosition> projectedPath) {
         if (!player0.lifeState().canMove())
             return new Player.DirectedPosition(player0.position(), player0.direction());
@@ -267,11 +268,13 @@ public final class GameState {
     }
 
     /**
-     * @param player0
-     * @param projectedCell
-     * @param board1
-     * @param bombedCells1
-     * @return
+     * Returns T(the player is colliding with an object).
+     *
+     * @param player0       the Player
+     * @param projectedCell the projected next Cell
+     * @param board1        the updated Board
+     * @param bombedCells1  the Set of bombed Cell-s
+     * @return T(the player is colliding with an object)
      */
     private static boolean isColliding(Player player0, Cell projectedCell, Board board1, Set<Cell> bombedCells1) {
         if (!board1.blockAt(projectedCell).canHostPlayer())
@@ -285,12 +288,12 @@ public final class GameState {
     }
 
     /**
-     * Apply damages and generate a new LifeState Sequence
+     * Applies damages and generate a new LifeState sequence.
      *
-     * @param player0
-     * @param directedPositions1
-     * @param blastedCells1
-     * @return
+     * @param player0            the Player
+     * @param directedPositions1 the DirectedPosition sequence
+     * @param blastedCells1      the Set of blasted Cell-s
+     * @return the next LifeState sequence
      */
     private static Sq<Player.LifeState> nextLifeState(Player player0, Sq<Player.DirectedPosition> directedPositions1,
                                                       Set<Cell> blastedCells1) {
diff --git a/src/ch/epfl/xblast/server/Player.java b/src/ch/epfl/xblast/server/Player.java
index fdc4715..f6f6c99 100644
--- a/src/ch/epfl/xblast/server/Player.java
+++ b/src/ch/epfl/xblast/server/Player.java
@@ -44,6 +44,8 @@ public final class Player {
         }
 
         /**
+         * Returns the number of lives.
+         *
          * @return the number of lives
          */
         public int lives() {
@@ -51,6 +53,8 @@ public final class Player {
         }
 
         /**
+         * Returns the State.
+         *
          * @return the state
          */
         public State state() {
@@ -58,7 +62,9 @@ public final class Player {
         }
 
         /**
-         * @return true if the actual state allow to move
+         * Returns T(this State allows the player to move).
+         *
+         * @return T(this State allows the player to move)
          */
         public boolean canMove() {
             return this.state() == State.INVULNERABLE || this.state() == State.VULNERABLE;
@@ -75,21 +81,25 @@ public final class Player {
         private final Direction direction;
 
         /**
-         * @return an infinite sequence of directed positions corresponding to a stopped player.
+         * Builds and returns an infinite sequence of directed positions corresponding to a stopped player.
+         *
+         * @return the sequence
          */
         public static Sq<DirectedPosition> stopped(DirectedPosition p) {
             return Sq.constant(p);
         }
 
         /**
-         * @return an infinite sequence of directed position corresponding to a moving player.
+         * Builds and returns an infinite sequence of directed position corresponding to a moving player.
+         *
+         * @return the sequence
          */
         public static Sq<DirectedPosition> moving(DirectedPosition p) {
             return Sq.iterate(p, x -> x.withPosition(x.position().neighbor(x.direction())));
         }
 
         /**