1 files changed, 341 insertions, 0 deletions

diff --git a/src/ch/epfl/xblast/server/Server.java b/src/ch/epfl/xblast/server/Server.java
new file mode 100644
index 0000000..074b2a7
--- /dev/null
+++ b/src/ch/epfl/xblast/server/Server.java
@@ -0,0 +1,341 @@
+package ch.epfl.xblast.server;
+
+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.painter.BoardPainter;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.StandardProtocolFamily;
+import java.nio.ByteBuffer;
+import java.nio.channels.DatagramChannel;
+import java.util.*;
+
+/**
+ * The Server class.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ */
+public class Server {
+
+    /**
+     * Default parameters of the server.
+     */
+    private static final long REFRESH_RATE = (long) (50 * 1E6); // nanosecond
+    private static final int DEFAULT_EXPECTED_CLIENTS = PlayerID.values().length;
+    public static final int DEFAULT_PORT = 2016;
+
+    /**
+     * ID of an observer.
+     */
+    public static final byte OBSERVER = -1;
+
+    /**
+     * Prints a log message on the console.
+     *
+     * @param message message to be printed
+     */
+    private static void log(String message) {
+        System.out.println("[LOG] " + message);
+    }
+
+    /**
+     * A Channel.
+     */
+    private static class Channel {
+
+        /**
+         * Transforms a list of bytes to an array of bytes.
+         *
+         * @param l the given list of bytes
+         * @return the array built from the given list
+         */
+        private static byte[] toByteArray(List<Byte> l) {
+            byte[] arr = new byte[l.size()];
+
+            for (int i = 0; i < l.size(); ++i)
+                arr[i] = l.get(i);
+
+            return arr;
+        }
+
+        /**
+         * Creates the socket which will be listened to.
+         *
+         * @param host hostname
+         * @param port port to be listened
+         * @return the socket build from the given params
+         */
+        private static InetSocketAddress listeningInterface(String host, int port) {
+            if (Objects.isNull(host))
+                return new InetSocketAddress(port);
+            else
+                return new InetSocketAddress(host, port);
+        }
+
+        /**
+         * Open an UDP channel.
+         *
+         * @param iface listened socket
+         * @return a UDP channel
+         */
+        private static DatagramChannel openChannel(InetSocketAddress iface) {
+            try {
+                DatagramChannel chan = DatagramChannel.open(StandardProtocolFamily.INET);
+                chan.bind(iface);
+                return chan;
+            } catch (IOException e) {
+                e.printStackTrace();
+                System.exit(1);
+                return null;
+            }
+        }
+
+        /**
+         * The UDP communication channel.
+         */
+        private final DatagramChannel channel;
+
+        /**
+         * Instantiates a new Channel.
+         *
+         * @param iface listened socket
+         */
+        Channel(InetSocketAddress iface) {
+            this.channel = openChannel(iface);
+        }
+
+        /**
+         * Instantiates a new Channel.
+         *
+         * @param host hostname
+         * @param port port to be listened
+         */
+        Channel(String host, Integer port) {
+            this(listeningInterface(host, Optional.ofNullable(port).orElse(DEFAULT_PORT)));
+        }
+
+        /**
+         * Closes the channel.
+         */
+        void closeChannel() {
+            try {
+                this.channel.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        /**
+         * Accepts the registration of a new client.
+         *
+         * @param registrations number of expected registrations
+         * @return a list of the clients.
+         */
+        List<SocketAddress> acceptRegistrations(int registrations) {
+            List<SocketAddress> clients = new ArrayList<>(registrations);
+
+            while (clients.size() < registrations) {
+                SocketAddress client = this.acceptRegistration();
+                if (!clients.contains(client))
+                    clients.add(client);
+            }
+
+            return Collections.unmodifiableList(clients);
+        }
+
+        /**
+         * Collects actions from the players.
+         *
+         * @return a list map containing the actions related to each player
+         */
+        Map<SocketAddress, PlayerAction> collectActions() {
+            Map<SocketAddress, PlayerAction> actions = new HashMap<>();
+            Optional<Map.Entry<SocketAddress, PlayerAction>> action;
+
+            while (true) {
+                action = this.receiveAction(false);
+                if (!action.isPresent()) break;
+                actions.put(action.get().getKey(), action.get().getValue());
+            }
+
+            return Collections.unmodifiableMap(actions);
+        }
+
+        /**
+         * Sends data through the socket.
+         *
+         * @param content data to be send
+         * @param dst recipient of the data
+         */
+        void send(List<Byte> content, SocketAddress dst) {
+            try {
+                ByteBuffer buf = ByteBuffer.wrap(toByteArray(content));
+                this.channel.send(buf, dst);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        /**
+         * Receives a Byte from the socket.
+         *
+         * @param block wait for an incoming byte before returning
+         * @return an Optional containing the received data
+         */
+        private Optional<Map.Entry<SocketAddress, Byte>> receiveByte(boolean block) {
+            try {
+                ByteBuffer buf = ByteBuffer.allocate(1);
+                this.channel.configureBlocking(block);
+                SocketAddress client = this.channel.receive(buf);
+
+                if (Objects.isNull(client) || buf.position() == 0)
+                    throw new IOException();
+
+                return Optional.of(new AbstractMap.SimpleImmutableEntry<>(client, buf.get(0)));
+            } catch (IOException e) {
+                return Optional.empty();
+            }
+        }
+
+        /**
+         * Receives a player action from the socket.
+         *
+         * @param block wait for an incoming action before returning
+         * @return an Optional containing the received player action
+         */
+        private Optional<Map.Entry<SocketAddress, PlayerAction>> receiveAction(boolean block) {
+            try {
+                Map.Entry<SocketAddress, Byte> actionByte = this.receiveByte(block).get();
+                PlayerAction playerAction = PlayerAction.fromByte(actionByte.getValue());
+                return Optional.of(new AbstractMap.SimpleImmutableEntry<>(actionByte.getKey(), playerAction));
+            } catch (NoSuchElementException | IllegalArgumentException e) {
+                return Optional.empty();
+            }
+        }
+
+        /**
+         * Accepts an action from the socket.
+         *
+         * @return the accepted action
+         */
+        private Map.Entry<SocketAddress, PlayerAction> acceptAction() {
+            Optional<Map.Entry<SocketAddress, PlayerAction>> action;
+
+            do {
+                action = this.receiveAction(true);
+            } while (!action.isPresent());
+
+            return action.get();
+        }
+
+        /**
+         * Accepts the registration of a player.
+         *
+         * @return the address of the new player
+         */
+        private SocketAddress acceptRegistration() {