Merge branch '04_bonus_and_game_state' into 'master'

04 bonus and game state



See merge request !4

10 files changed, 519 insertions, 7 deletions

diff --git a/src/ch/epfl/xblast/ArgumentChecker.java b/src/ch/epfl/xblast/ArgumentChecker.java
index 311807e..589c197 100644
--- a/src/ch/epfl/xblast/ArgumentChecker.java
+++ b/src/ch/epfl/xblast/ArgumentChecker.java
@@ -16,11 +16,10 @@ public final class ArgumentChecker {
      * @throws IllegalArgumentException if the value is inferior to 0
      */
     public static int requireNonNegative(int value) {
-        if (value >= 0) {
+        if (value >= 0)
             return value;
-        } else {
+        else
             throw new IllegalArgumentException();
-        }
     }
 
 }
diff --git a/src/ch/epfl/xblast/Lists.java b/src/ch/epfl/xblast/Lists.java
index 51e76b0..4ea45c2 100644
--- a/src/ch/epfl/xblast/Lists.java
+++ b/src/ch/epfl/xblast/Lists.java
@@ -1,8 +1,6 @@
 package ch.epfl.xblast;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -44,4 +42,40 @@ public final class Lists {
                 .collect(Collectors.toList());
     }
 
+    /**
+     * Returns a copy of the given list with element e inserted at index i.
+     *
+     * @param l   the list
+     * @param i   the insertion index
+     * @param e   the element to insert
+     * @param <T> the type of the list's elements
+     * @return a copy of the list with the element inserted
+     */
+    public static <T> List<T> inserted(List<T> l, int i, T e) {
+        List<T> r = new LinkedList<>(l);
+        r.add(i, e);
+        return r;
+    }
+
+    /**
+     * Returns all the permutations of the elements of the given list
+     *
+     * @param l   given list
+     * @param <T> the type of the list's elements
+     * @return a list of all the permutations of the list
+     * @throws IllegalArgumentException if the given list is null
+     */
+    public static <T> List<List<T>> permutations(List<T> l) {
+        if (l == null) throw new IllegalArgumentException();
+        if (l.size() <= 1) return Collections.singletonList(l);
+        if (l.size() == 2) return Arrays.asList(l, Lists.reversed(l));
+
+        List<List<T>> p = new LinkedList<>();
+        for (List<T> sp : Lists.permutations(l.subList(1, l.size())))
+            for (int i = 0; i <= sp.size(); ++i)
+                p.add(Lists.inserted(sp, i, l.get(0)));
+
+        return p;
+    }
+
 }
diff --git a/src/ch/epfl/xblast/Time.java b/src/ch/epfl/xblast/Time.java
new file mode 100644
index 0000000..7c84257
--- /dev/null
+++ b/src/ch/epfl/xblast/Time.java
@@ -0,0 +1,31 @@
+package ch.epfl.xblast;
+
+/**
+ * Time unit constants.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
+public interface Time {
+
+    /**
+     * Number of seconds per minute.
+     */
+    int S_PER_MIN = 60;
+
+    /**
+     * Number of milliseconds per second.
+     */
+    int MS_PER_S = 1000;
+
+    /**
+     * Number of microseconds per second.
+     */
+    int US_PER_S = 1000 * MS_PER_S;
+
+    /**
+     * Number of nanoseconds per second.
+     */
+    int NS_PER_S = 1000 * US_PER_S;
+
+}
diff --git a/src/ch/epfl/xblast/server/Block.java b/src/ch/epfl/xblast/server/Block.java
index 409f68e..5a139ff 100644
--- a/src/ch/epfl/xblast/server/Block.java
+++ b/src/ch/epfl/xblast/server/Block.java
@@ -1,5 +1,7 @@
 package ch.epfl.xblast.server;
 
+import java.util.NoSuchElementException;
+
 /**
  * A Block.
  *
@@ -26,7 +28,36 @@ public enum Block {
     /**
      * Crumbling Wall.
      */
-    CRUMBLING_WALL;
+    CRUMBLING_WALL,
+
+    /**
+     * Bonus increasing the maximum number of bombs.
+     */
+    BONUS_BOMB(Bonus.INC_BOMB),
+
+    /**
+     * Bonus increasing the range of the bombs.
+     */
+    BONUS_RANGE(Bonus.INC_RANGE);
+
+    /**
+     * Corresponding bonus, or null
+     */
+    private Bonus maybeAssociatedBonus;
+
+    /**
+     * Main builder, used by the bonus blocks
+     */
+    Block(Bonus maybeAssociatedBonus) {
+        this.maybeAssociatedBonus = maybeAssociatedBonus;
+    }
+
+    /**
+     * Default builder, used by the non-bonus blocks
+     */
+    Block() {
+        this.maybeAssociatedBonus = null;
+    }
 
     /**
      * Returns T(this block is free).
@@ -55,4 +86,24 @@ public enum Block {
         return this == INDESTRUCTIBLE_WALL || this == DESTRUCTIBLE_WALL || this == CRUMBLING_WALL;
     }
 
+    /**
+     * Returns T(this block is a bonus).
+     *
+     * @return T(this block is a bonus)
+     */
+    public boolean isBonus() {
+        return this == BONUS_BOMB || this == BONUS_RANGE;
+    }
+
+    /**
+     * Returns the bonus associated with the block.
+     *
+     * @return the bonus associated with the block.
+     * @throws NoSuchElementException if there is no such bonus.
+     */
+    public Bonus associatedBonus() {
+        if (this.maybeAssociatedBonus == null) throw new NoSuchElementException();
+        return this.maybeAssociatedBonus;
+    }
+
 }
diff --git a/src/ch/epfl/xblast/server/Bonus.java b/src/ch/epfl/xblast/server/Bonus.java
new file mode 100644
index 0000000..80ca8a9
--- /dev/null
+++ b/src/ch/epfl/xblast/server/Bonus.java
@@ -0,0 +1,55 @@
+package ch.epfl.xblast.server;
+
+/**
+ * Bonuses.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
+public enum Bonus {
+
+    /**
+     * Increases the maximum number of bombs used simultaneously.
+     */
+    INC_BOMB {
+        @Override
+        public Player applyTo(Player player) {
+            if (player.maxBombs() < BOMBS_LIMIT)
+                return player.withMaxBombs(player.maxBombs() + 1);
+            else
+                return player.withMaxBombs(BOMBS_LIMIT);
+        }
+    },
+
+    /**
+     * Increases the range of the bombs.
+     */
+    INC_RANGE {
+        @Override
+        public Player applyTo(Player player) {
+            if (player.bombRange() < RANGE_LIMIT)
+                return player.withBombRange(player.bombRange() + 1);
+            else
+                return player.withBombRange(RANGE_LIMIT);
+        }
+    };
+
+    /**