5 files changed, 228 insertions, 14 deletions

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
index dc08f1b..5b331f2 100644
--- a/src/ch/epfl/xblast/client/Client.java
+++ b/src/ch/epfl/xblast/client/Client.java
@@ -1,9 +1,25 @@
 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.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import java.util.Optional;
+import java.util.function.Consumer;
 
 /**
  * The Client class.
@@ -14,17 +30,179 @@ public class Client {
 
     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
 
-    private final InetSocketAddress serverAddr;
+    private static class Channel {
+
+        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);
+        }
+
+        private static DatagramChannel openChannel() {
+            try {
+                return DatagramChannel.open(StandardProtocolFamily.INET);
+            } catch (IOException e) {
+                e.printStackTrace();
+                System.exit(1);
+                return null;
+            }
+        }
+
+        private final SocketAddress serverAddr;
+        private final DatagramChannel channel;
+
+        Channel(InetSocketAddress iface) {
+            this.serverAddr = iface;
+            this.channel = openChannel();
+        }
+
+        Channel(String host, Integer port) {
+            this(new InetSocketAddress(
+                    Optional.ofNullable(host).orElse(DEFAULT_SERVER_HOST),
+                    Optional.ofNullable(port).orElse(DEFAULT_SERVER_PORT)));
+        }
+
+        void closeChannel() {
+            try {
+                this.channel.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        void sendAction(PlayerAction action) {
+            this.sendByte(action.toByte());
+        }
+
+        List<Byte> receiveGameState(boolean block) {
+            Optional<List<Byte>> state;
+
+            do {
+                state = this.receive(block);
+            } while (!state.isPresent());
+
+            return state.get();
+        }
+
+        private void sendByte(byte b) {
+            this.send(ByteBuffer.wrap(new byte[]{b}));
+        }
+
+        private void send(ByteBuffer b) {
+            try {
+                this.channel.send(b, this.serverAddr);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        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();
+            }
+        }
+
+    }
+
+    private static class GUI {
+
+        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;
+        }
+
+        private static void attachKeyboardHandler(Component comp, Consumer<PlayerAction> actionConsumer) {
+            comp.addKeyListener(new KeyboardEventHandler(actionConsumer));
+            comp.requestFocusInWindow();
+        }
+
+        private final XBlastComponent gameComponent;
+        private final Consumer<PlayerAction> actionConsumer;
+
+        GUI(Consumer<PlayerAction> actionConsumer) {
+            this.gameComponent = new XBlastComponent();
+            this.actionConsumer = actionConsumer;
+        }
+
+        public void display() {
+            buildFrame(this.gameComponent);
+            attachKeyboardHandler(this.gameComponent, this.actionConsumer);
+        }
+
+        public void setGameState(GameState gs, PlayerID p) {
+            this.gameComponent.setGameState(gs, p);
+        }
+
+    }
+
+    private final Channel channel;
+    private final GUI gui;
 
     public Client(String host, Integer port) {
-        this.serverAddr = new InetSocketAddress(
-                Optional.ofNullable(host).orElse(DEFAULT_SERVER_HOST),
-                Optional.ofNullable(port).orElse(DEFAULT_SERVER_PORT));
+        this.channel = new Channel(host, port);
+        this.gui = new GUI(this.channel::sendAction);
     }
 
     public void run() {
-        // TODO
+        this.displayGUI();
+        this.establishConnection();
+        this.runGame();
+        this.channel.closeChannel();
+    }
+
+    private void displayGUI() {
+        try {
+            SwingUtilities.invokeAndWait(this.gui::display);
+        } catch (InterruptedException | InvocationTargetException e) {
+            e.printStackTrace();
+            System.exit(1);
+        }
+    }
+
+    private void runGame() {
+        while (true)
+            updateGameState();
+    }
+
+    private void establishConnection() {
+        Thread joinThread = new Thread(this::sendJoinRequest);
+        joinThread.start();
+        updateGameState();
+        joinThread.interrupt();
+    }
+
+    private void updateGameState() {
+        List<Byte> serializedGameState = this.channel.receiveGameState(true);
+        if (serializedGameState.size() < 1) return;
+        PlayerID player = PlayerID.fromByte(serializedGameState.get(0));
+        GameState gameState = GameStateDeserializer.deserialize(Lists.firstDropped(serializedGameState, 1));
+        this.gui.setGameState(gameState, player);