path: root/src/ch/epfl/xblast/client/Client.java

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 {

    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 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 static PlayerID deserializePlayerID(byte b) {
        if (b == Server.OBSERVER)
            return null;

        try {
            return PlayerID.fromByte(b);
        } catch (IllegalArgumentException e) {
            return null;
        }
    }

    private static GameState deserializeGameState(List<Byte> b) {
        try {
            return GameStateDeserializer.deserialize(b);
        } catch (IllegalArgumentException e) {
            return null;
        }
    }

    private final Channel channel;
    private final GUI gui;

    public Client(String host, Integer port) {
        this.channel = new Channel(host, port);
        this.gui = new GUI(this.channel::sendAction);
    }

    public void run() {
        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 = deserializePlayerID(serializedGameState.get(0));
        GameState gameState = deserializeGameState(Lists.firstDropped(serializedGameState, 1));
        if (Objects.isNull(gameState)) return;

        this.gui.setGameState(gameState, player);
    }

    private void sendJoinRequest() {
        while (!Thread.currentThread().isInterrupted()) {
            this.channel.sendAction(PlayerAction.JOIN_GAME);
            Time.sleep(REGISTER_PING_INTERVAL);
        }
    }

}