Refactor server class

1 files changed, 103 insertions, 74 deletions

diff --git a/src/ch/epfl/xblast/server/Server.java b/src/ch/epfl/xblast/server/Server.java
index 58f3c07..6d1d62f 100644
--- a/src/ch/epfl/xblast/server/Server.java
+++ b/src/ch/epfl/xblast/server/Server.java
@@ -22,119 +22,148 @@ public class Server {
     public static final int DEFAULT_PORT = 2016;
     private static final int DEFAULT_EXPECTED_CLIENTS = PlayerID.values().length;
 
-    private static InetSocketAddress listeningInterface(String host, int port) {
-        if (Objects.isNull(host))
-            return new InetSocketAddress(port);
-        else
-            return new InetSocketAddress(host, port);
-    }
+    private static class 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;
+        private static InetSocketAddress listeningInterface(String host, int port) {
+            if (Objects.isNull(host))
+                return new InetSocketAddress(port);
+            else
+                return new InetSocketAddress(host, port);
         }
-    }
 
-    private static Optional<Map.Entry<SocketAddress, Byte>> receiveByte(DatagramChannel chan, boolean block) {
-        try {
-            ByteBuffer buf = ByteBuffer.allocate(1);
-            chan.configureBlocking(block);
-            SocketAddress client = chan.receive(buf);
+        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;
+            }
+        }
 
-            if (Objects.isNull(client) || buf.position() == 0)
-                throw new IOException();
+        private final DatagramChannel channel;
 
-            return Optional.of(new AbstractMap.SimpleImmutableEntry<>(client, buf.get(0)));
-        } catch (IOException e) {
-            return Optional.empty();
+        Channel(InetSocketAddress iface) {
+            this.channel = openChannel(iface);
         }
-    }
 
-    private static Optional<Map.Entry<SocketAddress, PlayerAction>> receiveAction(DatagramChannel chan, boolean block) {
-        try {
-            Map.Entry<SocketAddress, Byte> actionByte = receiveByte(chan, block).get();
-            PlayerAction playerAction = PlayerAction.fromByte(actionByte.getValue());
-            return Optional.of(new AbstractMap.SimpleImmutableEntry<>(actionByte.getKey(), playerAction));
-        } catch (NoSuchElementException | IllegalArgumentException e) {
-            return Optional.empty();
+        Channel(String host, Integer port) {
+            this(listeningInterface(host, Optional.ofNullable(port).orElse(DEFAULT_PORT)));
+        }
+
+        void closeChannel() {
+            try {
+                this.channel.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
         }
-    }
 
-    private static Map.Entry<SocketAddress, PlayerAction> acceptAction(DatagramChannel chan) {
-        Optional<Map.Entry<SocketAddress, PlayerAction>> action;
+        List<SocketAddress> acceptRegistrations(int registrations) {
+            List<SocketAddress> clients = new ArrayList<>(registrations);
 
-        do {
-            action = receiveAction(chan, true);
-        } while (!action.isPresent());
+            while (clients.size() < registrations) {
+                SocketAddress client = this.acceptRegistration();
+                if (!clients.contains(client))
+                    clients.add(client);
+            }
 
-        return action.get();
-    }
+            return Collections.unmodifiableList(clients);
+        }
 
-    private static Map<SocketAddress, PlayerAction> collectActions(DatagramChannel chan) {
-        Map<SocketAddress, PlayerAction> actions = new HashMap<>();
-        Optional<Map.Entry<SocketAddress, PlayerAction>> action;
+        Map<SocketAddress, PlayerAction> collectActions() {
+            Map<SocketAddress, PlayerAction> actions = new HashMap<>();
+            Optional<Map.Entry<SocketAddress, PlayerAction>> action;
 
-        while (true) {
-            action = receiveAction(chan, false);
-            if (!action.isPresent()) break;
-            actions.put(action.get().getKey(), action.get().getValue());
+            while (true) {
+                action = this.receiveAction(false);
+                if (!action.isPresent()) break;
+                actions.put(action.get().getKey(), action.get().getValue());
+            }
+
+            return Collections.unmodifiableMap(actions);
         }
 
-        return Collections.unmodifiableMap(actions);
-    }
+        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);
 
-    private static SocketAddress acceptRegistration(DatagramChannel chan) {
-        Map.Entry<SocketAddress, PlayerAction> clientAction;
+                if (Objects.isNull(client) || buf.position() == 0)
+                    throw new IOException();
 
-        do {
-            clientAction = acceptAction(chan);
-        } while (clientAction.getValue() != PlayerAction.JOIN_GAME);
+                return Optional.of(new AbstractMap.SimpleImmutableEntry<>(client, buf.get(0)));
+            } catch (IOException e) {
+                return Optional.empty();
+            }
+        }
 
-        return clientAction.getKey();
-    }
+        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();
+            }
+        }
+
+        private Map.Entry<SocketAddress, PlayerAction> acceptAction() {
+            Optional<Map.Entry<SocketAddress, PlayerAction>> action;
 
-    private static List<SocketAddress> acceptRegistrations(DatagramChannel chan, int registrations) {
-        List<SocketAddress> clients = new ArrayList<>(registrations);
+            do {
+                action = this.receiveAction(true);
+            } while (!action.isPresent());
 
-        while (clients.size() < registrations) {
-            SocketAddress client = acceptRegistration(chan);
-            if (!clients.contains(client))
-                clients.add(client);
+            return action.get();
+        }
+
+        private SocketAddress acceptRegistration() {
+            Map.Entry<SocketAddress, PlayerAction> clientAction;
+
+            do {
+                clientAction = this.acceptAction();
+            } while (clientAction.getValue() != PlayerAction.JOIN_GAME);
+
+            return clientAction.getKey();
         }
 
-        return Collections.unmodifiableList(clients);
     }
 
-    private final InetSocketAddress iface;
+    private final Channel channel;
     private final int expectedClients;
-    private Map<SocketAddress, PlayerID> registeredClients;
+
+    private Map<SocketAddress, PlayerID> registeredClientsMap;
+    private Map<PlayerID, SocketAddress> playersAddressMap;
 
     public Server(String iface, Integer port, Integer expectedClients) {
-        this.iface = listeningInterface(iface, Optional.ofNullable(port).orElse(DEFAULT_PORT));
+        this.channel = new Channel(iface, port);
         this.expectedClients = Optional.ofNullable(expectedClients).orElse(DEFAULT_EXPECTED_CLIENTS);
     }
 
     public void run() {
-        DatagramChannel chan = openChannel(this.iface);
-        List<SocketAddress> clients = acceptRegistrations(chan, this.expectedClients);
-        this.registeredClients = Lists.linearAdjustedMap(clients, Arrays.asList(PlayerID.values()));
+        this.acceptClientRegistrations();
+        this.runGame();
+        this.channel.closeChannel();
+    }
 
-        System.out.println(this.registeredClients);
+    private void acceptClientRegistrations() {
+        List<SocketAddress> clients = this.channel.acceptRegistrations(this.expectedClients);
+        this.registeredClientsMap = Lists.linearAdjustedMap(clients, Arrays.asList(PlayerID.values()));
+        this.playersAddressMap = Lists.invertMap(this.registeredClientsMap);
+    }
 
+    private void runGame() {
         try {
             Thread.sleep(10000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }