18 files changed, 1102 insertions, 37 deletions

diff --git a/src/ch/epfl/xblast/ArgumentChecker.java b/src/ch/epfl/xblast/ArgumentChecker.java
index 7e77b61..56f8acd 100644
--- a/src/ch/epfl/xblast/ArgumentChecker.java
+++ b/src/ch/epfl/xblast/ArgumentChecker.java
@@ -59,4 +59,33 @@ public final class ArgumentChecker {
         return s;
     }
 
+    /**
+     * Returns the element from the array at the requested index, or null if it cannot be retrieved.
+     *
+     * @param array the array
+     * @param index the index
+     * @param <T>   the type of element
+     * @return the requested element, or null
+     */
+    public static <T> T getOrNull(T[] array, int index) {
+        if (Objects.isNull(array) || index < 0 || index >= array.length)
+            return null;
+        else
+            return array[index];
+    }
+
+    /**
+     * Parses and returns an integer, or return null on error.
+     *
+     * @param str the integer to parse
+     * @return the parsed integer, or null
+     */
+    public static Integer parseIntOrNull(String str) {
+        try {
+            return Integer.parseInt(str);
+        } catch (NumberFormatException | NullPointerException e) {
+            return null;
+        }
+    }
+
 }
diff --git a/src/ch/epfl/xblast/Lists.java b/src/ch/epfl/xblast/Lists.java
index 777fab2..9bd527b 100644
--- a/src/ch/epfl/xblast/Lists.java
+++ b/src/ch/epfl/xblast/Lists.java
@@ -2,7 +2,6 @@ package ch.epfl.xblast;
 
 import java.util.*;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 /**
@@ -207,10 +206,36 @@ public final class Lists {
         if (Objects.isNull(kl) || Objects.isNull(vl) || kl.size() != vl.size())
             throw new IllegalArgumentException();
 
-        return Collections.unmodifiableMap(IntStream
-                .range(0, kl.size()).mapToObj(i -> i)
-                .filter(i -> Objects.nonNull(vl.get(i)))
-                .collect(Collectors.toMap(kl::get, vl::get)));
+        Map<K, V> m = new HashMap<>();
+        Iterator<K> ki = kl.iterator();
+        Iterator<V> vi = vl.iterator();
+
+        while (ki.hasNext() && vi.hasNext())
+            m.put(ki.next(), vi.next());
+
+        return Collections.unmodifiableMap(m);
+    }
+
+    /**
+     * Maps linearly two lists, adjusting their respective size by truncating the key list or completing the value list
+     * with null values.
+     *
+     * @param kl  the keys list
+     * @param vl  the values list
+     * @param <K> the key type
+     * @param <V> the value type
+     * @return the map
+     */
+    public static <K, V> Map<K, V> linearAdjustedMap(List<K> kl, List<V> vl) {
+        if (Objects.isNull(kl) || Objects.isNull(vl))
+            throw new IllegalArgumentException();
+
+        if (kl.size() <= vl.size())
+            return Lists.linearMap(kl, vl.subList(0, kl.size()));
+        else
+            return Lists.linearMap(
+                    kl,
+                    concatenated(Arrays.asList(vl, Collections.nCopies(kl.size() - vl.size(), null))));
     }
 
     /**
@@ -225,6 +250,8 @@ public final class Lists {
      */
     public static <K, IK, V> Map<K, V> traverseMaps(Map<K, IK> m1, Map<IK, V> m2) {
         return Collections.unmodifiableMap(m1.entrySet().stream()
+                .filter(e -> Objects.nonNull(e.getValue()))
+                .filter(e -> Objects.nonNull(m2.get(e.getValue())))
                 .collect(Collectors.toMap(Map.Entry::getKey, e -> m2.get(e.getValue()))));
     }
 
@@ -238,6 +265,8 @@ public final class Lists {
      */
     public static <K, V> Map<K, V> invertMap(Map<V, K> m) {
         return Collections.unmodifiableMap(m.entrySet().stream()
+                .filter(e -> Objects.nonNull(e.getKey()))
+                .filter(e -> Objects.nonNull(e.getValue()))
                 .collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey)));
     }
 
diff --git a/src/ch/epfl/xblast/PlayerAction.java b/src/ch/epfl/xblast/PlayerAction.java
index 703bc9d..6ce12ba 100644
--- a/src/ch/epfl/xblast/PlayerAction.java
+++ b/src/ch/epfl/xblast/PlayerAction.java
@@ -1,5 +1,7 @@
 package ch.epfl.xblast;
 
+import java.util.Optional;
+
 /**
  * The player action enum.
  *
@@ -14,6 +16,34 @@ public enum PlayerAction {
     MOVE_S,
     MOVE_W,
     STOP,
-    DROP_BOMB
+    DROP_BOMB;
+
+    public static PlayerAction fromByte(byte b) {
+        if ((int) b < 0 || (int) b >= PlayerAction.values().length)
+            throw new IllegalArgumentException();
+
+        return PlayerAction.values()[(int) b];
+    }
+
+    public byte toByte() {
+        return (byte) this.ordinal();
+    }
+
+    public Optional<Direction> associatedSpeedChangeEvent() {
+        switch (this) {
+            case MOVE_N:
+                return Optional.of(Direction.N);
+            case MOVE_E:
+                return Optional.of(Direction.E);
+            case MOVE_S:
+                return Optional.of(Direction.S);
+            case MOVE_W:
+                return Optional.of(Direction.W);
+            case STOP:
+                return Optional.empty();
+            default:
+                return null;
+        }
+    }
 
 }
diff --git a/src/ch/epfl/xblast/PlayerID.java b/src/ch/epfl/xblast/PlayerID.java
index 9377fdf..72a48b9 100644
--- a/src/ch/epfl/xblast/PlayerID.java
+++ b/src/ch/epfl/xblast/PlayerID.java
@@ -28,4 +28,15 @@ public enum PlayerID {
         }
     }
 
+    public static PlayerID fromByte(byte b) {
+        if ((int) b < 0 || (int) b >= PlayerAction.values().length)
+            throw new IllegalArgumentException();
+
+        return PlayerID.values()[(int) b];
+    }
+
+    public byte toByte() {
+        return (byte) this.ordinal();
+    }
+
 }
diff --git a/src/ch/epfl/xblast/Time.java b/src/ch/epfl/xblast/Time.java
index 7c84257..c53f1ef 100644
--- a/src/ch/epfl/xblast/Time.java
+++ b/src/ch/epfl/xblast/Time.java
@@ -28,4 +28,17 @@ public interface Time {
      */
     int NS_PER_S = 1000 * US_PER_S;
 
+    /**
+     * Pauses the current thread for the given duration.
+     *
+     * @param ns the sleep duration (ns)
+     */
+    static void sleep(long ns) {
+        try {
+            Thread.sleep((long) (ns / 1E6), (int) (ns % 1E6));
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
 }
diff --git a/src/ch/epfl/xblast/client/Client.java b/src/ch/epfl/xblast/client/Client.java
new file mode 100644
index 0000000..24ca727
--- /dev/null
+++ b/src/ch/epfl/xblast/client/Client.java
@@ -0,0 +1,360 @@
+package ch.epfl.xblast.client;
+
+import ch.epfl.xblast.Lists;
+import ch.epfl.xblast.PlayerAction;
+import ch.epfl.xblast.PlayerID;
+import ch.epfl.xblast.Time;
+import ch.epfl.xblast.server.Server;
+
+import javax.swing.*;
+import java.awt.*;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;