1 files changed, 360 insertions, 0 deletions

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;
+import java.net.StandardProtocolFamily;
+import java.nio.ByteBuffer;
+import java.nio.channels.DatagramChannel;
+import java.util.*;
+import java.util.List;
+import java.util.function.Consumer;
+
+/**
+ * The Client class.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ */
+public class Client {
+
+    /**
+     * Client's parameters.
+     */
+    private static final String DEFAULT_SERVER_HOST = "localhost";
+    private static final int DEFAULT_SERVER_PORT = Server.DEFAULT_PORT;
+    private static final int PACKET_MAX_SIZE = 1000;
+    private static final long REGISTER_PING_INTERVAL = 1 * Time.NS_PER_S; // ns
+
+    /**
+     * Communication channel.
+     */
+    private static class Channel {
+
+        /**
+         * Transforms a buffer to a list of bytes.
+         *
+         * @param buf given buffer
+         * @return the list of bytes built from the given buffer
+         */
+        private static List<Byte> bufferToList(ByteBuffer buf) {
+            List<Byte> l = new ArrayList<>(buf.remaining());
+
+            while (buf.hasRemaining())
+                l.add(buf.get());
+
+            return Collections.unmodifiableList(l);
+        }
+
+        /**
+         * Creates the UDP communication Channel.
+         *
+         * @return the UDP communication Channel
+         */
+        private static DatagramChannel openChannel() {
+            try {
+                return DatagramChannel.open(StandardProtocolFamily.INET);
+            } catch (IOException e) {
+                e.printStackTrace();
+                System.exit(1);
+                return null;
+            }
+        }
+
+        /**
+         * Parameters of the Channel.
+         */
+        private final SocketAddress serverAddr;
+        private final DatagramChannel channel;
+
+        /**
+         * Instantiates a new Channel.
+         *
+         * @param iface socket
+         */
+        Channel(InetSocketAddress iface) {
+            this.serverAddr = iface;
+            this.channel = openChannel();
+        }
+
+        /**
+         * Instantiates a new Channel.
+         *
+         * @param host hostname
+         * @param port port
+         */
+        Channel(String host, Integer port) {
+            this(new InetSocketAddress(
+                    Optional.ofNullable(host).orElse(DEFAULT_SERVER_HOST),
+                    Optional.ofNullable(port).orElse(DEFAULT_SERVER_PORT)));
+        }
+
+        /**
+         * Closes the Channel.
+         */
+        void closeChannel() {
+            try {
+                this.channel.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        /**
+         * Sends an action through the Channel.
+         *
+         * @param action action to send
+         */
+        void sendAction(PlayerAction action) {
+            this.sendByte(action.toByte());
+        }
+
+        /**
+         * Receives a GameState through the Channel.
+         *
+         * @param block wait for an incoming game state before returning
+         * @return the received GameState
+         */
+        List<Byte> receiveGameState(boolean block) {
+            Optional<List<Byte>> state;
+
+            do {
+                state = this.receive(block);
+            } while (!state.isPresent());
+
+            return state.get();
+        }
+
+        /**
+         * Sends a byte through the Channel.
+         *
+         * @param b byte to send
+         */
+        private void sendByte(byte b) {
+            this.send(ByteBuffer.wrap(new byte[]{b}));
+        }
+
+        /**
+         * Sends the content of a buffer.
+         *
+         * @param b buffer containing the bytes to send
+         */
+        private void send(ByteBuffer b) {
+            try {
+                this.channel.send(b, this.serverAddr);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        /**
+         * Receives data from the Channel.
+         *
+         * @param block wait for an incoming byte before returning
+         * @return the received data
+         */
+        private Optional<List<Byte>> receive(boolean block) {
+            try {
+                ByteBuffer buf = ByteBuffer.allocate(PACKET_MAX_SIZE);
+                this.channel.configureBlocking(block);
+                this.channel.receive(buf);
+                buf.flip();
+                return Optional.of(bufferToList(buf));
+            } catch (IOException e) {
+                e.printStackTrace();
+                return Optional.empty();
+            }
+        }
+
+    }
+
+    /**
+     * The Graphical User Interface.
+     */
+    private static class GUI {
+
+        /**
+         * Builds the window.
+         *
+         * @param content content of the window
+         * @return the frame
+         */
+        private static JFrame buildFrame(Container content) {
+            JFrame frame = new JFrame();
+            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+            frame.setVisible(true);
+
+            frame.setContentPane(content);
+            frame.pack();
+            return frame;
+        }
+
+        /**
+         * Attaches the keyboard event handler to the component.
+         *
+         * @param comp component
+         * @param actionConsumer actionConsumer corresponding to the keyboardEventHandler
+         */
+        private static void attachKeyboardHandler(Component comp, Consumer<PlayerAction> actionConsumer) {
+            comp.addKeyListener(new KeyboardEventHandler(actionConsumer));
+            comp.requestFocusInWindow();
+        }
+
+        /**
+         * GUI's parameters.
+         */
+        private final XBlastComponent gameComponent;
+        private final Consumer<PlayerAction> actionConsumer;
+
+        /**
+         * Instantiates a new GUI.
+         *
+         * @param actionConsumer actionConsumer corresponding to the keyboardEventHandler
+         */
+        GUI(Consumer<PlayerAction> actionConsumer) {
+            this.gameComponent = new XBlastComponent();
+            this.actionConsumer = actionConsumer;
+        }
+
+        /**
+         * Builds and display the GUI.
+         */
+        public void display() {
+            buildFrame(this.gameComponent);
+            attachKeyboardHandler(this.gameComponent, this.actionConsumer);
+        }
+
+        /**
+         * Updates the displayed GameState.
+         *
+         * @param gs new GameState to be displayed
+         * @param p Player ID corresponding to the client
+         */
+        public void setGameState(GameState gs, PlayerID p) {