5 files changed, 579 insertions, 0 deletions

diff --git a/src/ch/epfl/xblast/ArgumentChecker.java b/src/ch/epfl/xblast/ArgumentChecker.java
new file mode 100644
index 0000000..311807e
--- /dev/null
+++ b/src/ch/epfl/xblast/ArgumentChecker.java
@@ -0,0 +1,26 @@
+package ch.epfl.xblast;
+
+/**
+ * ArgumentChecker.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
+public final class ArgumentChecker {
+
+    /**
+     * Returns the given value if it is non-negative.
+     *
+     * @param value the tested value
+     * @return the given value if non-negative
+     * @throws IllegalArgumentException if the value is inferior to 0
+     */
+    public static int requireNonNegative(int value) {
+        if (value >= 0) {
+            return value;
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+
+}
diff --git a/src/ch/epfl/xblast/PlayerID.java b/src/ch/epfl/xblast/PlayerID.java
new file mode 100644
index 0000000..c2c5c58
--- /dev/null
+++ b/src/ch/epfl/xblast/PlayerID.java
@@ -0,0 +1,16 @@
+package ch.epfl.xblast;
+
+/**
+ * IDs the 4 different players.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
+public enum PlayerID {
+
+    PLAYER_1,
+    PLAYER_2,
+    PLAYER_3,
+    PLAYER_4
+
+}
diff --git a/src/ch/epfl/xblast/server/Bomb.java b/src/ch/epfl/xblast/server/Bomb.java
new file mode 100644
index 0000000..12e8888
--- /dev/null
+++ b/src/ch/epfl/xblast/server/Bomb.java
@@ -0,0 +1,116 @@
+package ch.epfl.xblast.server;
+
+import ch.epfl.cs108.Sq;
+import ch.epfl.xblast.ArgumentChecker;
+import ch.epfl.xblast.Cell;
+import ch.epfl.xblast.Direction;
+import ch.epfl.xblast.PlayerID;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * A Bomb.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
+public final class Bomb {
+
+    private PlayerID ownerId;
+    private Cell position;
+    private Sq<Integer> fuseLengths;
+    private int range;
+
+    /**
+     * Generates one arm of explosion.
+     */
+    private Sq<Sq<Cell>> explosionArmTowards(Direction dir) {
+        return Sq
+                .constant(Sq.iterate(position, position -> position.neighbor(dir)).limit(range))
+                .limit(Ticks.EXPLOSION_TICKS);
+    }
+
+    /**
+     * Instantiates a new Bomb.
+     *
+     * @param ownerId     id of the owner of the bomb
+     * @param position    position of the bomb
+     * @param fuseLengths length of the bomb's fuse
+     * @param range       range of the bomb
+     * @throws IllegalArgumentException if range is negative or fuseLenghts is empty
+     * @throws NullPointerException     if ownerId, position or fuseLengths is null
+     */
+    public Bomb(PlayerID ownerId, Cell position, Sq<Integer> fuseLengths, int range) {
+        this.ownerId = Objects.requireNonNull(ownerId);
+        this.position = Objects.requireNonNull(position);
+
+        this.fuseLengths = Objects.requireNonNull(fuseLengths);
+        if (this.fuseLengths.isEmpty())
+            throw new IllegalArgumentException();
+
+        this.range = ArgumentChecker.requireNonNegative(range);
+    }
+
+    /**
+     * Instantiates a new Bomb.
+     *
+     * @param ownerId    id of the owner of the bomb
+     * @param position   position of the bomb
+     * @param fuseLength length of the bomb's fuse
+     * @param range      range of the bomb
+     * @throws IllegalArgumentException if range or fuseLengths is negative
+     * @throws NullPointerException     if ownerId, position or fuseLengths is null
+     */
+    public Bomb(PlayerID ownerId, Cell position, int fuseLength, int range) {
+        this(ownerId, position, Sq.iterate(fuseLength, fl -> fl - 1), range);
+    }
+
+    /**
+     * @return the ID of the owner of the bomb
+     */
+    public PlayerID ownerId() {
+        return ownerId;
+    }
+
+    /**
+     * @return the position of the bomb
+     */
+    public Cell position() {
+        return position;
+    }
+
+    /**
+     * @return the length of the fuse
+     */
+    public Sq<Integer> fuseLengths() {
+        return fuseLengths;
+    }
+
+    /**
+     * @return the remaining time before the explosion
+     */
+    public int fuseLength() {
+        return fuseLengths.head();
+    }
+
+    /**
+     * @return the range of the Bomb
+     */
+    public int range() {
+        return range;
+    }
+
+    /**
+     * @return the explosion
+     */
+    public List<Sq<Sq<Cell>>> explosion() {
+        List<Sq<Sq<Cell>>> explosion = new ArrayList<>();
+        for (Direction dir : Direction.values()) {
+            explosion.add(explosionArmTowards(dir));
+        }
+        return explosion;
+    }
+
+}
diff --git a/src/ch/epfl/xblast/server/Player.java b/src/ch/epfl/xblast/server/Player.java
new file mode 100644
index 0000000..7b5ac26
--- /dev/null
+++ b/src/ch/epfl/xblast/server/Player.java
@@ -0,0 +1,332 @@
+package ch.epfl.xblast.server;
+
+import ch.epfl.cs108.Sq;
+import ch.epfl.xblast.*;
+
+import java.util.Objects;
+
+/**
+ * A Player.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
+public final class Player {
+
+    /**
+     * The life state of a player.
+     */
+    public static final class LifeState {
+
+        /**
+         * Enum containing all the possible life states.
+         */
+        public enum State {
+            INVULNERABLE,
+            VULNERABLE,
+            DYING,
+            DEAD
+        }
+
+        private final int lives;
+        private final State state;
+
+        /**
+         * Instantiates a new LifeSate.
+         *
+         * @param lives the number of lives
+         * @param state the state
+         * @throws IllegalArgumentException if lives is negative
+         */
+        public LifeState(int lives, State state) {
+            this.lives = ArgumentChecker.requireNonNegative(lives);
+            this.state = state;
+        }
+
+        /**
+         * @return the number of lives
+         */
+        public int lives() {
+            return lives;
+        }
+
+        /**
+         * @return the state
+         */
+        public State state() {
+            return state;
+        }
+
+        /**
+         * @return true if the actual state allow to move
+         */
+        public boolean canMove() {
+            return (state() == State.INVULNERABLE || state() == State.VULNERABLE);
+        }
+
+    }
+
+    /**
+     * The "directed" position of a player.
+     */
+    public static final class DirectedPosition {
+
+        private final SubCell position;
+        private final Direction direction;
+
+        /**
+         * @return an infinite sequence of directed positions corresponding to a stopped player.