path: root/src/ch/epfl/xblast/server/Server.java

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;

    /**
     * Print 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 {

        /**
         * Transform 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;
        }

        /**
         * Create the socket which will be listened.
         *
         * @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 a 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)));
        }

        /**
         * Close the channel.
         */
        void closeChannel() {
            try {
                this.channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        /**
         * Accept the registration of a new client.
         *
         * @param 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);
        }

        /**
         * Collect 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);
        }

        /**
         * Send data through the socket.
         *
         * @param content data to be send
         * @param dst recepient 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();
            }
        }

        /**
         * Receive a Byte from the socket.
         *
         * @param block
         * @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();
            }
        }

        /**
         * Receive a player action from the socket.
         *
         * @param block
         * @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();
            }
        }

        /**
         * Accept 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();
        }

        /**
         * Accept the registration of a player
         *
         * @return the address of the new player
         */
        private SocketAddress acceptRegistration() {
            Map.Entry<SocketAddress, PlayerAction> clientAction;

            do {
                clientAction = this.acceptAction();
            } while (clientAction.getValue() != PlayerAction.JOIN_GAME);
            return clientAction.getKey();
        }

    }

    /**
     * The communication channel.
     */
    private final Channel channel;

    /**
     * Required number of player to start a game (up to 4).
     */
    private final int expectedClients;

    /**
     * Maps of the players and their addresses.
     */
    private Map<SocketAddress, PlayerID> registeredClientsMap;
    private Map<PlayerID, SocketAddress> playersAddressMap;

    /**
     * Instantiates a new server.
     *
     * @param iface the interface to be listened
     * @param port the port to be listened
     * @param expectedClients required number of player to start a game
     */
    public Server(String iface, Integer port, Integer expectedClients) {
        this.channel = new Channel(iface, port);
        this.expectedClients = Optional.ofNullable(expectedClients).orElse(DEFAULT_EXPECTED_CLIENTS);
    }

    /**
     * Run the whole server.
     */
    public void run() {
        log("Starting the server...");
        this.acceptClientRegistrations();
        this.runGame();
        this.channel.closeChannel();
    }

    /**
     * Handle the registration of new clients.
     */
    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);
    }

    /**
     * Launch the Game.
     */
    private void runGame() {
        GameState gameState = GameState.DEFAULT_GAME_STATE;
        while (!gameState.isGameOver()) {
            long computationStartTime = System.nanoTime();
            gameState = updateGameState(gameState);
            broadcastGameState(gameState);
            Time.sleep(REFRESH_RATE - (computationStartTime - System.nanoTime()));
        }

        if (gameState.winner().isPresent())
            log("Winner : PLAYER_" + gameState.winner());
        else
            log("There is no winner.");
    }

    /**
     * Update the given GameState to the next tick.
     *
     * @param gs the given GameState
     * @return the updated GameState
     */
    private GameState updateGameState(GameState gs) {
        Map<PlayerID, PlayerAction> events = Lists.traverseMaps(this.playersAddressMap, this.channel.collectActions());
        return gs.next(events);
    }

    /**
     * Send the GameState to every player.
     *
     * @param gs the GameState to be send.
     */
    private void broadcastGameState(GameState gs) {
        List<Byte> serialized = GameStateSerializer.serialize(BoardPainter.DEFAULT_BOARD_PAINTER, gs);

        for (Map.Entry<SocketAddress, PlayerID> client : this.registeredClientsMap.entrySet()) {
            byte activePlayer = Objects.nonNull(client) ? client.getValue().toByte() : OBSERVER;
            this.channel.send(Lists.prepended(serialized, activePlayer), client.getKey());
        }
    }

}