Changed arrow colour.

#fix

pom.xml

@@ -109,6 +109,12 @@
             <version>3.4.2</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.fxyz3d</groupId>
+            <artifactId>fxyz3d</artifactId>
+            <version>0.1.1</version>
+        </dependency>
+
     </dependencies>
 
     <build>

src/main/java/seng302/App.java

@@ -10,11 +10,13 @@ import org.apache.commons.cli.Options;
 import org.apache.commons.cli.ParseException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import seng302.discoveryServer.DiscoveryServer;
 import seng302.visualiser.controllers.ViewManager;
 
 public class App extends Application {
 
     private static Logger logger = LoggerFactory.getLogger(App.class);
+    private static boolean isRunningAsCache = false;
 
     public static void parseArgs(String[] args) throws ParseException {
         Options options = new Options();
@@ -25,56 +27,83 @@ public class App extends Application {
             .getLogger(Logger.ROOT_LOGGER_NAME);
 
         options.addOption("debugLevel", true, "Set the application debug level");
+        options.addOption("runAsDiscoveryServer", false, "Run as a discovery server");
+        options.addOption("discoveryDevMode", false, "Use a local discovery server");
 
         cmd = parser.parse(options, args);
 
+        if (cmd.hasOption("runAsDiscoveryServer")){
+            isRunningAsCache = true;
+            rootLogger.setLevel(Level.ALL);
+            return;
+        }
+
+        if (cmd.hasOption("discoveryDevMode")) {
+            DiscoveryServer.DISCOVERY_SERVER = "localhost";
+        }
+
         if (cmd.hasOption("debugLevel")) {
 
-            switch (cmd.getOptionValue("debugLevel")) {
-                case "DEBUG":
-                    rootLogger.setLevel(Level.DEBUG);
-                    break;
+        switch (cmd.getOptionValue("debugLevel")) {
+            case "DEBUG":
+                rootLogger.setLevel(Level.DEBUG);
+                break;
 
-                case "ALL":
-                    rootLogger.setLevel(Level.ALL);
-                    break;
+            case "ALL":
+                rootLogger.setLevel(Level.ALL);
+                break;
 
-                case "WARNING":
-                    rootLogger.setLevel(Level.WARN);
-                    break;
+            case "WARNING":
+                rootLogger.setLevel(Level.WARN);
+                break;
 
-                case "ERROR":
-                    rootLogger.setLevel(Level.ERROR);
-                    break;
+            case "ERROR":
+                rootLogger.setLevel(Level.ERROR);
+                break;
 
-                case "INFO":
-                    rootLogger.setLevel(Level.INFO);
+            case "INFO":
+                rootLogger.setLevel(Level.INFO);
 
-                case "TRACE":
-                    rootLogger.setLevel(Level.TRACE);
+            case "TRACE":
+                rootLogger.setLevel(Level.TRACE);
 
-                default:
-                    rootLogger.setLevel(Level.ALL);
-            }
-        } else {
-            rootLogger.setLevel(Level.WARN);
+            default:
+                rootLogger.setLevel(Level.ALL);
         }
+    } else {
+        rootLogger.setLevel(Level.WARN);
+    }
     }
 
     @Override
     public void start(Stage primaryStage) throws Exception {
-        ViewManager.getInstance().initialStartView(primaryStage);
+        ViewManager.getInstance().initialiseSplashScreen(primaryStage);
     }
 
+    private static void runDiscoveryServer() throws Exception {
+        while (true){
+            try {
+                new DiscoveryServer();
+            }
+            catch (Exception ignored){
+                ;
+            }
+        }
+    }
 
-    public static void main(String[] args) {
+    public static void main(String[] args) throws Exception {
         try {
             parseArgs(args);
         } catch (ParseException e) {
             logger.error("Could not parse command line arguments");
         }
 
-        launch(args);
+        if (!isRunningAsCache){
+            launch(args);
+        }
+        else{
+            runDiscoveryServer();
+        }
     }
 }
 

src/main/java/seng302/discoveryServer/DiscoveryServer.java

@@ -0,0 +1,170 @@
+package seng302.discoveryServer;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import seng302.gameServer.messages.Message;
+import seng302.gameServer.messages.RoomCodeRequest;
+import seng302.gameServer.messages.ServerRegistrationMessage;
+import seng302.model.stream.packets.PacketType;
+import seng302.discoveryServer.util.ServerListing;
+import seng302.discoveryServer.util.ServerRepoStreamParser;
+import seng302.discoveryServer.util.ServerTable;
+import seng302.visualiser.ServerListener;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.Timer;
+
+public class DiscoveryServer {
+    public static final String ANSI_GREEN = "\u001B[32m";
+    public static final String ANSI_YELLOW = "\u001B[33m";
+    public static final String ANSI_BLUE = "\u001B[34m";
+    public static final String ANSI_RESET = "\u001B[0m";
+    private static final int MAX_SERVER_TRIES = 10;
+    public static String DISCOVERY_SERVER = "party.sydney.srv.michaelrausch.nz";
+
+    private ServerTable serverTable;
+    public static final Integer PORT_NUMBER = 9969;
+    private ServerSocket serverSocket;
+
+    private final Logger logger = LoggerFactory.getLogger(DiscoveryServer.class);
+
+    private void displayHeader(){
+        String selectedColor = Arrays.asList(ANSI_BLUE, ANSI_GREEN, ANSI_YELLOW).get(new Random().nextInt(2));
+        System.out.println(selectedColor);
+        System.out.println("                              .ccccc.             \n" +
+                "                         .cc;'coooxkl;.           \n" +
+                "                     .:c:::c:,,,,,;c;;,.'.        \n" +
+                "                   .clc,',:,..:xxocc;'..c;        \n" +
+                "                  .c:,';:ox:..:c,,,,,,...cd,      \n" +
+                "                .c:'.,oxxxxl::l:.,loll;..;ol.     \n" +
+                "                ;Oc..:xxxxxxxxx:.,llll,....oc     \n" +
+                "             .,;,',:loxxxxxxxxx:.,llll;.,,.'ld,   \n" +
+                "            .lo;..:xxxxxxxxxxxx:.'cllc,.:l:'cO;   \n" +
+                "           .:;...'cxxxxxxxxxxxxoc;,::,..cdl;;l'   \n" +
+                "         .cl;':,'';oxxxxxxdxxxxxx:....,cooc,cO;   \n" +
+                "     .,,,::;,lxoc:,,:lxxxxxxxxxxxo:,,;lxxl;'oNc   \n" +
+                "   .cdxo;':lxxxxxxc'';cccccoxxxxxxxxxxxxo,.;lc.  " + ANSI_YELLOW + "Party-Parrots-At-Sea Discovery Server v0.1 " + selectedColor +"\n" +
+                "  .loc'.'lxxxxxxxxocc;''''';ccoxxxxxxxxx:..oc     \n" +
+                "olc,..',:cccccccccccc:;;;;;;;;:ccccccccc,.'c,     \n" +
+                "Ol;......................................;l'  ");
+        System.out.println(ANSI_RESET);
+    }
+
+    public DiscoveryServer() throws Exception {
+        displayHeader();
+        serverTable = new ServerTable();
+
+        try{
+            serverSocket = new ServerSocket(PORT_NUMBER);
+        }
+        catch(java.net.BindException e){
+            logger.error("FATAL - Could not bind socket, are you sure there isn't already an instance running?");
+            System.exit(1);
+            return;
+        }
+
+        logger.info("Started successfully - Now accepting connections");
+
+        try{
+            while (true){
+                Socket clientSocket = serverSocket.accept();
+
+                parseRequest(clientSocket);
+
+                clientSocket.close();
+            }
+        }
+        catch (Exception e){
+            close();
+        }
+    }
+
+
+    private void parseRequest(Socket clientSocket) throws Exception {
+        ServerRepoStreamParser parser = new ServerRepoStreamParser(clientSocket.getInputStream());
+
+        if (clientSocket.isConnected() && !clientSocket.isClosed()){
+            PacketType parsePacketResult = parser.parse();
+
+            switch (parsePacketResult){
+                case SERVER_REGISTRATION:
+                    ServerListing listing = parser.getServerListing();
+
+                    if (!serverTable.getAllServers().contains(listing)){
+                        listing.setRoomCode(serverTable.getNextRoomCode().toString());
+                    }
+
+                    serverTable.addServer(listing);
+
+                    Message serverRegMessage = new RoomCodeRequest(listing.getRoomCode());
+                    clientSocket.getOutputStream().write(serverRegMessage.getBuffer());
+                    break;
+
+                case ROOM_CODE_REQUEST:
+                    String desiredRoomCode = parser.getRoomCode();
+                    ServerListing serverListing;
+
+                    if (desiredRoomCode.equals("0000")){
+                        serverListing = getRandomFreeServer();
+                    }
+                    else {
+                        serverListing = serverTable.getServerByRoomCode(desiredRoomCode);
+                    }
+
+                    Message response;
+
+                    if (serverListing != null){
+                        response = new ServerRegistrationMessage(serverListing.getServerName(), serverListing.getMapName(), serverListing.getAddress(), serverListing.getPortNumber(), 0, 0, desiredRoomCode);
+                    }
+                    else{
+                        response = ServerRegistrationMessage.getEmptyRegistration();
+                    }
+
+                    clientSocket.getOutputStream().write(response.getBuffer());
+                    break;
+            }
+        }
+    }
+
+    public ServerListing getRandomFreeServer() {
+        ServerListing serverToJoin;
+
+        List<ServerListing> servers = serverTable.getAllServers();
+
+        if (servers.size() <= 0){
+            return null;
+        }
+
+        if (servers.size() == 1){
+            return servers.get(0);
+        }
+
+        serverToJoin = servers.get(new Random().nextInt(servers.size()));
+
+        int tries = 0;
+
+        while (serverToJoin != null && serverToJoin.isMaxPlayersReached() && tries < MAX_SERVER_TRIES){
+            serverToJoin = servers.get(new Random().nextInt(servers.size()));
+            tries++;
+        }
+
+        if (serverToJoin != null && serverToJoin.isMaxPlayersReached()){
+            return null;
+        }
+
+        return serverToJoin;
+    }
+
+    public void close(){
+        try {
+            serverSocket.close();
+        } catch (IOException ignored) {
+            ;
+        }
+    }
+}

src/main/java/seng302/discoveryServer/DiscoveryServerClient.java

@@ -0,0 +1,195 @@
+package seng302.discoveryServer;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import seng302.discoveryServer.util.ServerListing;
+import seng302.discoveryServer.util.ServerRepoStreamParser;
+import seng302.gameServer.messages.Message;
+import seng302.gameServer.messages.RoomCodeRequest;
+import seng302.gameServer.messages.ServerRegistrationMessage;
+import seng302.model.stream.packets.PacketType;
+import seng302.visualiser.controllers.ViewManager;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.Socket;
+import java.net.URL;
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class DiscoveryServerClient {
+    private final Integer UPDATE_INTERVAL_MS = 5000;
+
+    private static String roomCode = null;
+    private Timer serverListingUpdateTimer;
+    private Logger logger = LoggerFactory.getLogger(DiscoveryServerClient.class);
+    private String ip = "";
+    private Boolean isInInvalidState = false;
+
+    public DiscoveryServerClient() {
+        try {
+            ip = getInetIpAddr();
+        } catch (Exception e) {
+            failError();
+        }
+    }
+
+    public String getInetIp(){
+        return ip;
+    }
+
+    private void failError() {
+        isInInvalidState = true;
+        ViewManager.getInstance().showErrorSnackBar("You do not appear to be able to connect to the internet. Matchmaking will be unavailable.");
+    }
+
+    public boolean didFail(){
+        return isInInvalidState;
+    }
+
+    /**
+     * Register the server with the discovery server
+     * @param serverListing The listing to register
+     */
+    public void register(ServerListing serverListing){
+        if (isInInvalidState) return;
+
+        if (serverListingUpdateTimer != null){
+            serverListingUpdateTimer.cancel();
+            serverListingUpdateTimer = null;
+        }
+
+        serverListingUpdateTimer = new Timer();
+
+        serverListingUpdateTimer.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                try {
+                    sendRegistrationUpdate(serverListing);
+                } catch (Exception e) {
+                    logger.debug("Could not update server listing");
+                }
+            }
+        }, 0, UPDATE_INTERVAL_MS);
+    }
+
+    /**
+     * Stop updating the server registration updates
+     */
+    public void unregister(){
+        if (serverListingUpdateTimer != null)
+            serverListingUpdateTimer.cancel();
+    }
+
+    /**
+     * Gets the connection information for a server given a room code
+     *
+     * @param roomCode The room code to search for
+     * @return The ServerListing, or null if there was an error
+     * @throws Exception .
+     */
+    public ServerListing getServerForRoomCode(String roomCode) throws Exception {
+        Socket socket = new Socket(DiscoveryServer.DISCOVERY_SERVER, DiscoveryServer.PORT_NUMBER);
+        ServerRepoStreamParser parser = new ServerRepoStreamParser(socket.getInputStream());
+
+        Message request = new RoomCodeRequest(roomCode); //roomCode);
+        socket.getOutputStream().write(request.getBuffer());
+
+        PacketType packetType = parser.parse();
+
+        if (packetType != PacketType.SERVER_REGISTRATION){
+            logger.debug("Wrong packet received in response to a room code request");
+            return null;
+        }
+
+        socket.close();
+
+        return parser.getServerListing();
+    }
+
+    public ServerListing getRandomServer() throws Exception {
+        Socket socket = new Socket(DiscoveryServer.DISCOVERY_SERVER, DiscoveryServer.PORT_NUMBER);
+        ServerRepoStreamParser parser = new ServerRepoStreamParser(socket.getInputStream());
+
+        Message request = new RoomCodeRequest("0000");
+        socket.getOutputStream().write(request.getBuffer());
+
+        PacketType packetType = parser.parse();
+
+        if (packetType != PacketType.SERVER_REGISTRATION){
+            logger.error("Incorrect packet type received");
+            return null;
+        }
+
+        socket.close();
+
+        ServerListing serverListing = parser.getServerListing();
+
+        if (serverListing == null || serverListing.equals(ServerRegistrationMessage.getEmptyRegistration())){
+            return null;
+        }
+
+        return serverListing;
+    }
+
+    /**
+     * Sends a registration update to the discovery server.
+     *
+     * @param serverListing The server listing to send
+     * @throws Exception IF there was an error sending the update
+     */
+    private void sendRegistrationUpdate(ServerListing serverListing) throws Exception {
+        Socket socket = new Socket(DiscoveryServer.DISCOVERY_SERVER, DiscoveryServer.PORT_NUMBER);
+        ServerRepoStreamParser parser = new ServerRepoStreamParser(socket.getInputStream());
+
+        Message req = new ServerRegistrationMessage(serverListing);
+
+        socket.getOutputStream().write(req.getBuffer());
+
+        PacketType packetType = parser.parse();
+
+        if (packetType != PacketType.ROOM_CODE_REQUEST){
+            socket.close();
+            return;
+        }
+
+        String roomCode = parser.getRoomCode();
+
+        if (roomCode.length() != 0){
+            DiscoveryServerClient.roomCode = roomCode;
+        }
+
+        socket.close();
+    }
+
+    /**
+     * @return The last room code received by the client
+     */
+    public static String getRoomCode(){
+        return roomCode;
+    }
+
+    public static String getInetIpAddr() throws Exception {
+        URL myIp = new URL("http://checkip.amazonaws.com");
+        BufferedReader in = null;
+        try {
+            in = new BufferedReader(new InputStreamReader(
+                    myIp.openStream()));
+            String ip = in.readLine();
+            return ip;
+        } finally {
+            if (in != null) {
+                try {
+                    in.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+
+
+}
+

src/main/java/seng302/discoveryServer/util/ReadableByteInputStream.java

@@ -0,0 +1,50 @@
+package seng302.discoveryServer.util;
+
+import java.io.InputStream;
+
+public class ReadableByteInputStream {
+    private InputStream is;
+
+    public ReadableByteInputStream(InputStream is){
+        this.is = is;
+    }
+
+    /**
+     * Get n bytes from the input stream
+     * @param n number of bytes
+     * @return the bytes read
+     * @throws Exception .
+     */
+    public byte[] getBytes(int n) throws Exception {
+        byte[] bytes = new byte[n];
+        for (int i = 0; i < n; i++) {
+            bytes[i] = (byte) readByte();
+        }
+        return bytes;
+    }
+
+    /**
+     * Skip n bytes
+     * @param n number of bytes to skip
+     * @throws Exception
+     */
+    public void skipBytes(long n) throws Exception {
+        for (int i = 0; i < n; i++) {
+            readByte();
+        }
+    }
+
+    /**
+     * Read the next byte from the stream
+     * @return The byte that was read
+     * @throws Exception .
+     */
+    public int readByte() throws Exception {
+        int currentByte = is.read();
+
+        if (currentByte == -1) {
+            throw new Exception();
+        }
+        return currentByte;
+    }
+}

src/main/java/seng302/discoveryServer/util/ServerListing.java

@@ -0,0 +1,117 @@
+package seng302.discoveryServer.util;
+
+public class ServerListing {
+    public final static int SERVER_TTL_DEFAULT = 10;
+
+    private String serverName = "";
+    private String mapName = "";
+    private String address = "";
+    private int portNumber = 0;
+    private int capacity = 0;
+    private int players = 0;
+    private String roomCode = "";
+    private int ttl = SERVER_TTL_DEFAULT;
+
+
+    public ServerListing(String serverName, String mapName, String address, int portNumber, int capacity){
+        this.serverName = serverName;
+        this.mapName = mapName;
+        this.address = address;
+        this.portNumber = portNumber;
+        this.capacity = capacity;
+    }
+
+    public ServerListing setNumberOfPlayers(int players){
+        this.players = players;
+        return this;
+    }
+
+    public ServerListing setRoomCode(String roomCode){
+        this.roomCode = roomCode;
+        return this;
+    }
+
+    public void refreshTtl(){
+        ttl = SERVER_TTL_DEFAULT;
+    }
+
+    public void decrementTtl(){
+        ttl--;
+    }
+
+    public boolean hasTtlExpired(){
+        return ttl < 0;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (!ServerListing.class.isAssignableFrom(obj.getClass())) {
+            return false;
+        }
+
+        final ServerListing other = (ServerListing) obj;
+
+        if (this.getPortNumber() != other.getPortNumber()){
+            return false;
+        }
+
+        if (!this.getMapName().equals(other.getMapName())){
+            return false;
+        }
+
+        if (!this.getServerName().equals(other.getServerName())){
+            return false;
+        }
+
+        if (this.getCapacity() != other.getCapacity()){
+            return false;
+        }
+
+        if (!this.getAddress().equals(other.getAddress())){
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return this.getServerName().hashCode() +
+                this.getAddress().hashCode() + this.getMapName().hashCode();
+    }
+
+    public String getRoomCode() {
+        return roomCode;
+    }
+
+    public int getPortNumber() {
+        return portNumber;
+    }
+
+    public String getMapName() {
+        return mapName;
+    }
+
+    public String getServerName() {
+        return serverName;
+    }
+
+    public int getCapacity() {
+        return capacity;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setTtl(Integer ttl){
+        this.ttl = ttl;
+    }
+
+    public boolean isMaxPlayersReached() {
+        return players >= capacity;
+    }
+}

src/main/java/seng302/discoveryServer/util/ServerRepoStreamParser.java

@@ -0,0 +1,109 @@
+package seng302.discoveryServer.util;
+
+
+import seng302.gameServer.messages.Message;
+import seng302.model.stream.packets.PacketType;
+
+import java.io.InputStream;
+import java.util.Arrays;
+
+public class ServerRepoStreamParser {
+    private ReadableByteInputStream inputStream;
+
+    private String roomCode;
+    private String mapName;
+    private ServerListing serverListing;
+
+    public ServerRepoStreamParser(InputStream is){
+        inputStream = new ReadableByteInputStream(is);
+    }
+
+    public PacketType parse() throws Exception {
+        int sync1 = inputStream.readByte();
+        int sync2 = inputStream.readByte();
+
+        PacketType packetType = null;
+
+        if (sync1 == 0x47 && sync2 == 0x83) {
+            int type = inputStream.readByte();
+            inputStream.skipBytes(10);
+            long payloadLength = Message.bytesToLong(inputStream.getBytes(2));
+            byte[] payload = inputStream.getBytes((int) payloadLength);
+            inputStream.skipBytes(4);
+
+            packetType = PacketType.assignPacketType(type, payload);
+
+            switch (packetType) {
+                case ROOM_CODE_REQUEST:
+                    roomCode = parseRoomCodeRequest(payload);
+                    break;
+
+                case LOBBY_REQUEST:
+                    mapName = parseLobbyRequest(payload);
+
+                case SERVER_REGISTRATION:
+                    serverListing = parseServerRegistration(payload);
+                    break;
+            }
+
+        }
+
+        return packetType;
+    }
+    private String parseLobbyRequest(byte[] payload) {
+        int mapNameLength = (int) Message.bytesToLong(Arrays.copyOfRange(payload, 0 ,4));
+
+        return new String(Arrays.copyOfRange(payload, 4, 4+mapNameLength));
+    }
+
+    private String parseRoomCodeRequest(byte[] payload) {
+        int roomCodeLength = (int) Message.bytesToLong(Arrays.copyOfRange(payload, 0 ,6));
+
+        return new String(Arrays.copyOfRange(payload, 6, 6+roomCodeLength));
+    }
+
+    public static ServerListing parseServerRegistration(byte[] payload) {
+        int nameLength = (int) Message.bytesToLong(Arrays.copyOfRange(payload, 0, 6));
+        int mapNameLength = (int) Message.bytesToLong(Arrays.copyOfRange(payload, 6, 12));
+        int addressLength = (int) Message.bytesToLong(Arrays.copyOfRange(payload, 12, 18));
+        int roomCodeLength = (int) Message.bytesToLong(Arrays.copyOfRange(payload, 18, 24));
+
+        int portNumber = (int) Message.bytesToLong(Arrays.copyOfRange(payload, 24, 28));
+        int players = (int) Message.bytesToLong(Arrays.copyOfRange(payload, 28, 32));
+        int capacity = (int) Message.bytesToLong(Arrays.copyOfRange(payload, 32, 36));
+
+        int currentPos = 36;
+        int nextPos = currentPos + nameLength;
+        String serverName = new String(Arrays.copyOfRange(payload, currentPos, nextPos));
+
+        currentPos = nextPos;
+        nextPos = currentPos + mapNameLength;
+        String mapName = new String(Arrays.copyOfRange(payload, currentPos, nextPos));
+
+        currentPos = nextPos;
+        nextPos = currentPos + addressLength;
+        String address = new String(Arrays.copyOfRange(payload, currentPos, nextPos));
+
+        currentPos = nextPos;
+        nextPos = currentPos + roomCodeLength;
+        String roomCode = new String(Arrays.copyOfRange(payload, currentPos, nextPos));
+
+        ServerListing serverListing = new ServerListing(serverName, mapName, address, portNumber, capacity);
+        serverListing.setNumberOfPlayers(players);
+        serverListing.setRoomCode(roomCode);
+
+        return serverListing;
+    }
+
+    public String getRoomCode() {
+        return roomCode;
+    }
+
+    public String getMapName() {
+        return mapName;
+    }
+
+    public ServerListing getServerListing() {
+        return serverListing;
+    }
+}

src/main/java/seng302/discoveryServer/util/ServerTable.java

@@ -0,0 +1,97 @@
+package seng302.discoveryServer.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+
+public class ServerTable {
+    private List<ServerListing> servers;
+    private int lastRoomCode = 4020;
+    private Logger logger = LoggerFactory.getLogger(ServerTable.class);
+
+    public ServerTable(){
+        servers = new ArrayList<>();
+
+        new Timer().schedule(new TimerTask() {
+            @Override
+            public void run() {
+                updateServers();
+            }
+        }, 0, 1000);
+    }
+
+    /**
+     * Update the servers TTL values, and then remove expired servers
+     */
+    private void updateServers() {
+        List<ServerListing> serversToRemove = new ArrayList<>();
+
+        for (ServerListing server : servers){
+            server.decrementTtl();
+
+            if (server.hasTtlExpired()){
+                logger.debug("Removed expired server - " + server.getServerName());
+                serversToRemove.add(server);
+            }
+        }
+
+        servers.removeAll(serversToRemove);
+    }
+
+    /**
+     * Add a server to the table
+     * @param server The server to add
+     */
+    public void addServer(ServerListing server){
+        if (servers.contains(server)){
+           updateTtlForServer(server);
+           return;
+        }
+        logger.debug("Added new server - " + server.getServerName() + " at address: " + server.getAddress() + ":" + server.getPortNumber());
+        servers.add(server);
+    }
+
+    /**
+     * Update the TTL for a given server to the default TTL value
+     * @param server The server to update
+     */
+    private void updateTtlForServer(ServerListing server) {
+        for (ServerListing serverListing : servers){
+            if (server.equals(serverListing)){
+                serverListing.refreshTtl();
+            }
+        }
+    }
+
+    /**
+     * @return All the servers in the table
+     */
+    public List<ServerListing> getAllServers(){
+        return Collections.unmodifiableList(servers);
+    }
+
+    /**
+     * Get a server from the table given its room code
+     * @param roomCode The room code to search for
+     * @return The ServerListing of the found server, or null
+     *         the server wasn't found
+     */
+    public ServerListing getServerByRoomCode(String roomCode){
+        for (ServerListing serverListing : servers){
+            if (serverListing.getRoomCode().equals(roomCode)){
+                return serverListing;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * @return The next available room code
+     */
+    public Integer getNextRoomCode(){
+        lastRoomCode += 1;
+        return lastRoomCode;
+    }
+}

src/main/java/seng302/gameServer/GameState.java

@@ -1,20 +1,19 @@
 package seng302.gameServer;
 
+import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Random;
 import java.util.Set;
+import java.util.Timer;
+import java.util.TimerTask;
 import javafx.scene.paint.Color;
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.w3c.dom.Document;
-import org.xml.sax.InputSource;
 import seng302.gameServer.messages.BoatAction;
 import seng302.gameServer.messages.BoatStatus;
 import seng302.gameServer.messages.ChatterMessage;
@@ -23,8 +22,6 @@ import seng302.gameServer.messages.MarkRoundingMessage;
 import seng302.gameServer.messages.MarkType;
 import seng302.gameServer.messages.Message;
 import seng302.gameServer.messages.RoundingBoatStatus;
-import seng302.gameServer.messages.YachtEventCodeMessage;
-import seng302.gameServer.messages.YachtEventType;
 import seng302.model.GeoPoint;
 import seng302.model.Limit;
 import seng302.model.Player;
@@ -33,10 +30,11 @@ import seng302.model.ServerYacht;
 import seng302.model.mark.CompoundMark;
 import seng302.model.mark.Mark;
 import seng302.model.mark.MarkOrder;
+import seng302.model.stream.xml.parser.RaceXMLData;
 import seng302.model.token.Token;
 import seng302.model.token.TokenType;
 import seng302.utilities.GeoUtility;
-import seng302.utilities.XMLParser;
+import seng302.utilities.RandomSpawn;
 import seng302.visualiser.fxObjects.assets_3D.BoatMeshType;
 
 /**
@@ -54,24 +52,38 @@ public class GameState implements Runnable {
     private static Logger logger = LoggerFactory.getLogger(GameState.class);
 
 
+    private static final Integer STATE_UPDATES_PER_SECOND = 60;
+
+    //Scheduling constants
     static final int WARNING_TIME = 10 * -1000;
     static final int PREPATORY_TIME = 5 * -1000;
     private static final int TIME_TILL_START = 10 * 1000;
 
-    private static final Long POWERUP_TIMEOUT_MS = 10_000L;
+    //Wind Constants
+    private static final int MAX_WIND_SPEED = 12000;
+    private static final int MIN_WIND_SPEED = 8000;
 
-    private static final Integer STATE_UPDATES_PER_SECOND = 60;
-    private static Double ROUNDING_DISTANCE = 50d; // TODO: 14/08/17 wmu16 - Look into this value further
+    //Rounding Constants
+    private static final Double ROUNDING_DISTANCE = 50d; // TODO: 14/08/17 wmu16 - Look into this value further
+
+    //Collision constants
     private static final Double MARK_COLLISION_DISTANCE = 15d;
     public static final Double YACHT_COLLISION_DISTANCE = 25.0;
     private static final Double BOUNCE_DISTANCE_MARK = 20.0;
     public static final Double BOUNCE_DISTANCE_YACHT = 30.0;
     private static final Double COLLISION_VELOCITY_PENALTY = 0.3;
 
+    //Powerup Constants
+    public static final Double VELOCITY_BOOST_MULTIPLIER = 2d;
+    public static final Integer HANDLING_BOOST_MULTIPLIER = 2;
+    private static final Double BAD_RANDOM_SPEED_PENALTY = 0.3;
+    public static final Long BUMPER_DISABLE_TIME = 5_000L;
+    private static final Long TOKEN_SPAWN_TIME = 30_000L;
+
     private static Long previousUpdateTime;
     public static Double windDirection;
     private static Double windSpeed;
-    private static Double speedMultiplier = 1d;
+    private static Double serverSpeedMultiplier;
 
     private static Boolean customizationFlag; // dirty flag to tell if a player has customized their boat.
     private static Boolean playerHasLeftFlag;
@@ -79,85 +91,46 @@ public class GameState implements Runnable {
     private static String hostIpAddress;
     private static List<Player> players;
     private static Map<Integer, ServerYacht> yachts;
-    private static Boolean isRaceStarted;
     private static GameStages currentStage;
     private static MarkOrder markOrder;
     private static long startTime;
-    private static Set<Mark> marks;
-    private static List<Limit> courseLimit;
+    private static Set<Mark> marks = new HashSet<>();
+    private static List<Limit> courseLimit = new ArrayList<>();
     private static Integer maxPlayers = 8;
 
-
-    private static List<Token> allTokens;
     private static List<Token> tokensInPlay;
+    private static RandomSpawn randomSpawn;
 
     private static List<NewMessageListener> newMessageListeners;
 
     private static Map<Player, String> playerStringMap = new HashMap<>();
+    private static boolean tokensEnabled = false;
 
-    public GameState(String hostIpAddress) {
+    public GameState() {
         windDirection = 180d;
         windSpeed = 10000d;
         yachts = new HashMap<>();
         tokensInPlay = new ArrayList<>();
-
         players = new ArrayList<>();
-        GameState.hostIpAddress = hostIpAddress;
         customizationFlag = false;
         playerHasLeftFlag = false;
-        speedMultiplier = 1.0;
+        serverSpeedMultiplier = 1.0;
         currentStage = GameStages.LOBBYING;
-        isRaceStarted = false;
-        //set this when game stage changes to prerace
         previousUpdateTime = System.currentTimeMillis();
-        markOrder = new MarkOrder(); //This could be instantiated at some point with a select map?
         newMessageListeners = new ArrayList<>();
-        allTokens = makeTokens();
 
         resetStartTime();
-
+        //setCourseLimit("/server_config/race.xml");
         new Thread(this, "GameState").start();   //Run the auto updates on the game state
-
-        marks = new MarkOrder().getAllMarks();
-        setCourseLimit("/server_config/race.xml");
     }
 
-    private void setCourseLimit(String url) {
-        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
-        documentBuilderFactory.setNamespaceAware(true);
-        DocumentBuilder documentBuilder;
-        Document document = null;
-        try {
-            documentBuilder = documentBuilderFactory.newDocumentBuilder();
-            document = documentBuilder.parse(new InputSource(getClass().getResourceAsStream(url)));
-        } catch (Exception e) {
-            // sorry, we have to catch general one, otherwise we have to catch five different exceptions.
-            logger.trace("Failed to load course limit for boundary collision detection.", e);
+    public static void setRace(RaceXMLData raceXMLData) {
+        markOrder = new MarkOrder(raceXMLData);
+        for (CompoundMark compoundMark : raceXMLData.getCompoundMarks().values()){
+            marks.addAll(compoundMark.getMarks());
         }
-        courseLimit = XMLParser.parseRace(document).getCourseLimit();
-    }
-
-
-    /**
-     * Make a pre defined set of tokensInPlay. //TODO wmu16 - Should read from some file for each
-     * race ideally
-     *
-     * @return A list of possible tokensInPlay for this race
-     */
-    private ArrayList<Token> makeTokens() {
-        Token token1 = new Token(TokenType.BOOST, 57.66946, 11.83154);
-        Token token2 = new Token(TokenType.BOOST, 57.66877, 11.83382);
-        Token token3 = new Token(TokenType.BOOST, 57.66914, 11.83965);
-        Token token4 = new Token(TokenType.BOOST, 57.66684, 11.83214);
-        return new ArrayList<>(Arrays.asList(token1, token2, token3, token4));
-    }
-
-    public static String getHostIpAddress() {
-        return hostIpAddress;
-    }
-
-    public static Set<Mark> getMarks() {
-        return Collections.unmodifiableSet(marks);
+        randomSpawn = new RandomSpawn(markOrder.getOrderedUniqueCompoundMarks());
+        courseLimit = raceXMLData.getCourseLimit();
     }
 
     public static List<Player> getPlayers() {
@@ -168,6 +141,10 @@ public class GameState implements Runnable {
         return tokensInPlay;
     }
 
+    public static Set<Mark> getMarks() {
+        return Collections.unmodifiableSet(marks);
+    }
+
     public static void addPlayer(Player player) {
         players.add(player);
         String playerText = player.getYacht().getSourceId() + " " + player.getYacht().getBoatName()
@@ -188,10 +165,6 @@ public class GameState implements Runnable {
         yachts.remove(yachtId);
     }
 
-    public static Boolean getIsRaceStarted() {
-        return isRaceStarted;
-    }
-
     public static GameStages getCurrentStage() {
         return currentStage;
     }
@@ -260,16 +233,77 @@ public class GameState implements Runnable {
             } catch (InterruptedException e) {
                 System.out.println("[GameState] interrupted exception");
             }
-            if (currentStage == GameStages.PRE_RACE || currentStage == GameStages.RACING) {
+            if (currentStage == GameStages.PRE_RACE) {
                 update();
+                if (System.currentTimeMillis() > startTime) {
+                    startSpawningTokens();
+                    startUpdatingWind();
+                    GameState.setCurrentStage(GameStages.RACING);
+                }
             }
-
             if (currentStage == GameStages.RACING) {
                 update();
             }
         }
     }
 
+    /**
+     * Start spawning coins every 60s after the first minute
+     */
+    private void startSpawningTokens() {
+        Timer timer = new Timer("Token Spawning Timer");
+        timer.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                if (tokensEnabled) {
+                    spawnNewToken();
+                    notifyMessageListeners(MessageFactory.getRaceXML());
+                }
+            }
+        }, 0, TOKEN_SPAWN_TIME);
+    }
+
+    // TODO: 29/08/17 wmu16 - This sort of update should be in game state
+    private static void startUpdatingWind() {
+        Timer timer = new Timer("Wind Updating Timer");
+        timer.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                updateWind();
+            }
+        }, 0, 500);
+    }
+
+
+    private static void updateWind() {
+        Integer direction = GameState.getWindDirection().intValue();
+        Integer windSpeed = GameState.getWindSpeedMMS().intValue();
+
+        Random random = new Random();
+
+        if (Math.floorMod(random.nextInt(), 2) == 0) {
+            direction += random.nextInt(4);
+            windSpeed += random.nextInt(20) + 459;
+        } else {
+            direction -= random.nextInt(4);
+            windSpeed -= random.nextInt(20) + 459;
+        }
+
+        direction = Math.floorMod(direction, 360);
+
+        if (windSpeed > MAX_WIND_SPEED) {
+            windSpeed -= random.nextInt(500);
+        }
+
+        if (windSpeed <= MIN_WIND_SPEED) {
+            windSpeed += random.nextInt(500);
+        }
+
+        GameState.setWindSpeed(Double.valueOf(windSpeed));
+        GameState.setWindDirection(direction.doubleValue());
+    }
+
+
     public static void updateBoat(Integer sourceId, BoatAction actionType) {
         ServerYacht playerYacht = yachts.get(sourceId);
         switch (actionType) {
@@ -304,10 +338,13 @@ public class GameState implements Runnable {
      * Randomly select a subset of tokensInPlay from a pre defined superset
      * Broadasts a new race status message to show this update
      */
-    public static void spawnNewToken() {
-        Random random = new Random();
+    private void spawnNewToken() {
         tokensInPlay.clear();
-        tokensInPlay.add(allTokens.get(random.nextInt(allTokens.size())));
+        Token token = randomSpawn.getRandomToken();
+//        token.assignType(TokenType.WIND_WALKER);
+        logger.debug("Spawned token of type " + token.getTokenType());
+        tokensInPlay.add(token);
+        MessageFactory.updateTokens(tokensInPlay);
     }
 
     /**
@@ -324,14 +361,12 @@ public class GameState implements Runnable {
 
         Double timeInterval = (System.currentTimeMillis() - previousUpdateTime) / 1000000.0;
         previousUpdateTime = System.currentTimeMillis();
-        if (System.currentTimeMillis() > startTime) {
-            GameState.setCurrentStage(GameStages.RACING);
-        }
+
         for (ServerYacht yacht : yachts.values()) {
             updateVelocity(yacht);
-            checkPowerUpTimeout(yacht);
             yacht.runAutoPilot();
             yacht.updateLocation(timeInterval);
+            preformTokenUpdates(yacht); //This update must be done before collision. Sorta hacky
             checkCollision(yacht);
             if (yacht.getBoatStatus() != BoatStatus.FINISHED) {
                 checkForLegProgression(yacht);
@@ -345,17 +380,138 @@ public class GameState implements Runnable {
     }
 
 
-    private void checkPowerUpTimeout(ServerYacht yacht) {
-        if (yacht.getPowerUp() != null) {
-            if (System.currentTimeMillis() - yacht.getPowerUpStartTime() > POWERUP_TIMEOUT_MS) {
-                yacht.powerDown();
-                sendServerMessage(yacht.getSourceId(), yacht.getBoatName() + "'s power-up token expired");
-                logger.debug("Yacht: " + yacht.getShortName() + " powered down!");
+    /**
+     * All token functionality entry points is taken care of here. So can be disabled and enabled
+     * easily
+     *
+     * @param yacht The yacht to perform token checks on
+     */
+    private void preformTokenUpdates(ServerYacht yacht) {
+        Token collidedToken = checkTokenPickUp(yacht);
+        if (collidedToken != null) {
+            tokensInPlay.remove(collidedToken);
+            powerUpYacht(yacht, collidedToken);
+            MessageFactory.updateTokens(tokensInPlay);
+            notifyMessageListeners(MessageFactory.getRaceXML());
+        }
+
+        checkPowerUpTimeout(yacht);
+        TokenType powerUp = yacht.getPowerUp();
+
+        if (powerUp != null) {
+            switch (powerUp) {
+                case WIND_WALKER:
+                    windWalk(yacht);
+                    break;
+                case BUMPER:
+                    ServerYacht collidedYacht = checkYachtCollision(yacht, true);
+                    if (collidedYacht != null) {
+                        yacht.powerDown();
+                        boatTempShutDown(collidedYacht);
+                        notifyMessageListeners(MessageFactory.makePowerDownMessage(yacht));
+                        notifyMessageListeners(
+                            MessageFactory.makeStatusEffectMessage(collidedYacht, powerUp));
+                    }
+                    break;
+                case RANDOM:
+                    yacht.setPowerUpSpeedMultiplier(BAD_RANDOM_SPEED_PENALTY);
             }
         }
     }
 
 
+    /**
+     * Powers up a thisYacht with the given token type.
+     *
+     * @param thisYacht The yacht to be powered up
+     * @param collidedToken The token which this thisYacht collided with
+     */
+    private void powerUpYacht(ServerYacht thisYacht, Token collidedToken) {
+        //The random token has a 50% chance of becoming another token else becoming a speed detriment!
+        if (collidedToken.getTokenType() == TokenType.RANDOM && new Random().nextBoolean()) {
+            collidedToken.realiseRandom();
+        }
+
+        //If another yacht has the wind walker token, They should be powered down. Only one allowed!
+        else if (collidedToken.getTokenType() == TokenType.WIND_WALKER) {
+            for (ServerYacht otherYacht : yachts.values()) {
+                if (otherYacht != thisYacht && otherYacht.getPowerUp() == TokenType.WIND_WALKER) {
+                    powerDownYacht(otherYacht);
+                }
+            }
+        }
+
+        thisYacht.powerUp(collidedToken.getTokenType());
+        String logMessage =
+            thisYacht.getBoatName() + " has picked up a " + collidedToken.getTokenType().getName()
+                + " token";
+        notifyMessageListeners(
+            MessageFactory.makeChatterMessage(thisYacht.getSourceId(), logMessage));
+        notifyMessageListeners(MessageFactory.getRaceXML());
+        notifyMessageListeners(MessageFactory.makePickupMessage(thisYacht, collidedToken));
+        logger.debug(
+            "Yacht: " + thisYacht.getShortName() + " got powerup " + collidedToken.getTokenType());
+    }
+
+    private void powerDownYacht(ServerYacht yacht) {
+        String logMessage =
+            yacht.getBoatName() + "'s " + yacht.getPowerUp().getName() + "  expired";
+        notifyMessageListeners(
+            MessageFactory.makeChatterMessage(yacht.getSourceId(), logMessage));
+        notifyMessageListeners(MessageFactory.makePowerDownMessage(yacht));
+        logger.debug("Yacht: " + yacht.getShortName() + " powered down!");
+
+        yacht.powerDown();
+    }
+
+    // TODO: 23/09/17 wmu16 - This is a hacky way to have the boat power down. Need some sort of separation between token and status effect :/
+
+    /**
+     * Disables the given boat for BUMPER_DISABLE_TIME ms.
+     *
+     * @param yacht The yacht to disable
+     */
+    private void boatTempShutDown(ServerYacht yacht) {
+        yacht.setPowerUpSpeedMultiplier(0d);
+        Timer shutDownTimer = new Timer("Shutdown Timer");
+        shutDownTimer.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                yacht.powerDown();  //Note this actually resets the boat to normal.
+            }
+        }, BUMPER_DISABLE_TIME);
+    }
+
+
+    /**
+     * Checks how long a powerup has been active for. If it has exceeded its timeout, it powers the
+     * yacht down.
+     *
+     * @param yacht The yacht to check to power down
+     */
+    private void checkPowerUpTimeout(ServerYacht yacht) {
+        if (yacht.getPowerUp() != null) {
+            if (System.currentTimeMillis() - yacht.getPowerUpStartTime() > yacht.getPowerUp()
+                .getTimeout()) {
+                powerDownYacht(yacht);
+            }
+        }
+    }
+
+
+    /**
+     * This function changes the wind to be at an angle that causes the yacht in question to be at
+     * its fastest velocity
+     *
+     * @param yacht The yacht to fix the wind for
+     */
+    private void windWalk(ServerYacht yacht) {
+        Double optimalAngle = PolarTable.getOptimalAngle();
+        Double heading = yacht.getHeading();
+        windDirection = (double) Math.floorMod(Math.round(heading + optimalAngle), 360L);
+    }
+
+
     /**
      * Check if the yacht has crossed the course limit
      *
@@ -369,6 +525,7 @@ public class GameState implements Runnable {
                 return true;
             }
         }
+
         if (GeoUtility.checkCrossedLine(courseLimit.get(courseLimit.size() - 1), courseLimit.get(0),
             yacht.getLastLocation(), yacht.getLocation()) != 0) {
             return true;
@@ -377,13 +534,15 @@ public class GameState implements Runnable {
     }
 
     /**
-     * Checks all tokensInPlay to see if a yacht has picked one up
-     * @return Token which was collided with
-     * @param serverYacht The yacht to check for collision with a token
+     * Checks all tokensInPlay to see if a yacht has picked one up. If so, the yacht is powered up
+     * in the appropriate way
+     * @param yacht The yacht to check for collision with a token
+     *
+     * @return The token collided with
      */
-    private static Token checkTokenPickUp(ServerYacht serverYacht) {
+    private Token checkTokenPickUp(ServerYacht yacht) {
         for (Token token : tokensInPlay) {
-            Double distance = GeoUtility.getDistance(token, serverYacht.getLocation());
+            Double distance = GeoUtility.getDistance(token, yacht.getLocation());
             if (distance < YACHT_COLLISION_DISTANCE) {
                 return token;
             }
@@ -406,7 +565,7 @@ public class GameState implements Runnable {
      */
     public static void checkCollision(ServerYacht serverYacht) {
         //Yacht Collision
-        ServerYacht collidedYacht = checkYachtCollision(serverYacht);
+        ServerYacht collidedYacht = checkYachtCollision(serverYacht, false);
         Mark collidedMark = checkMarkCollision(serverYacht);
 
         if (collidedYacht != null) {
@@ -423,9 +582,7 @@ public class GameState implements Runnable {
             collidedYacht.setCurrentVelocity(
                 collidedYacht.getCurrentVelocity() * COLLISION_VELOCITY_PENALTY
             );
-            notifyMessageListeners(
-                new YachtEventCodeMessage(serverYacht.getSourceId(), YachtEventType.COLLISION)
-            );
+            notifyMessageListeners(MessageFactory.makeCollisionMessage(serverYacht));
         }
 
         //Mark Collision
@@ -437,9 +594,7 @@ public class GameState implements Runnable {
             serverYacht.setCurrentVelocity(
                 serverYacht.getCurrentVelocity() * COLLISION_VELOCITY_PENALTY
             );
-            notifyMessageListeners(
-                new YachtEventCodeMessage(serverYacht.getSourceId(), YachtEventType.COLLISION)
-            );
+            notifyMessageListeners(MessageFactory.makeCollisionMessage(serverYacht));
         }
 
         //Boundary Collision
@@ -452,22 +607,7 @@ public class GameState implements Runnable {
             serverYacht.setCurrentVelocity(
                 serverYacht.getCurrentVelocity() * COLLISION_VELOCITY_PENALTY
             );
-            notifyMessageListeners(
-                new YachtEventCodeMessage(serverYacht.getSourceId(), YachtEventType.COLLISION)
-            );
-        }
-
-        //Token Collision
-        Token collidedToken = checkTokenPickUp(serverYacht);
-        if (collidedToken != null) {
-            sendServerMessage(serverYacht.getSourceId(), serverYacht.getBoatName() + " has picked speed-up token");
-            tokensInPlay.remove(collidedToken);
-            serverYacht.powerUp(collidedToken.getTokenType());
-            logger.debug("Yacht: " + serverYacht.getShortName() + " got powerup " + collidedToken
-                .getTokenType());
-            notifyMessageListeners(MessageFactory.getRaceXML());
-            notifyMessageListeners(
-                new YachtEventCodeMessage(serverYacht.getSourceId(), YachtEventType.TOKEN));
+            notifyMessageListeners(MessageFactory.makeCollisionMessage(serverYacht));
         }
     }
 
@@ -475,29 +615,30 @@ public class GameState implements Runnable {
     private void updateVelocity(ServerYacht yacht) {
         Double trueWindAngle = Math.abs(windDirection - yacht.getHeading());
         Double boatSpeedInKnots = PolarTable.getBoatSpeed(getWindSpeedKnots(), trueWindAngle);
-        Double maxBoatSpeed = GeoUtility.knotsToMMS(boatSpeedInKnots) * speedMultiplier * yacht.getMaxSpeedMultiplier();
-        if (yacht.getPowerUp() != null) {
-            if (yacht.getPowerUp().equals(TokenType.BOOST)) {
-                // TODO: 11/09/17 wmu16 CHANGE THIS TO MAGIC NUMBER
-                maxBoatSpeed *= 2;
-            }
-        }
+        Double maxBoatSpeed =
+            GeoUtility.knotsToMMS(boatSpeedInKnots) * serverSpeedMultiplier * yacht
+                .getPowerUpSpeedMultiplier() * yacht.getBoatTypeSpeedMultiplier();
 
         Double currentVelocity = yacht.getCurrentVelocity();
         // TODO: 15/08/17 remove magic numbers from these equations.
         if (yacht.getSailIn()) {
             if (currentVelocity < maxBoatSpeed - 500) {
-                yacht.changeVelocity((maxBoatSpeed / 100) * yacht.getAccelerationMultiplier());
+                yacht.changeVelocity(
+                    (maxBoatSpeed / 100) * yacht.getBoatTypeAccelerationMultiplier());
             } else if (currentVelocity > maxBoatSpeed + 500) {
-                yacht.changeVelocity((-currentVelocity / 200) * yacht.getAccelerationMultiplier());
+                yacht.changeVelocity(
+                    (-currentVelocity / 200) * yacht.getBoatTypeAccelerationMultiplier());
             } else {
-                yacht.setCurrentVelocity((maxBoatSpeed) * yacht.getAccelerationMultiplier());
+                yacht
+                    .setCurrentVelocity((maxBoatSpeed) * yacht.getBoatTypeAccelerationMultiplier());
             }
         } else {
             if (currentVelocity > 3000) {
-                yacht.changeVelocity((-currentVelocity / 200) * yacht.getAccelerationMultiplier());
+                yacht.changeVelocity(
+                    (-currentVelocity / 200) * yacht.getBoatTypeAccelerationMultiplier());
             } else if (currentVelocity > 100) {
-                yacht.changeVelocity((-currentVelocity / 50) * yacht.getAccelerationMultiplier());
+                yacht.changeVelocity(
+                    (-currentVelocity / 50) * yacht.getBoatTypeAccelerationMultiplier());
             } else if (currentVelocity <= 100) {
                 yacht.setCurrentVelocity(0d);
             }
@@ -560,7 +701,10 @@ public class GameState implements Runnable {
 
         if (hasProgressed) {
             if (currentMarkSeqID != 0 && !markOrder.isLastMark(currentMarkSeqID)) {
-                sendServerMessage(yacht.getSourceId(), yacht.getBoatName() + " passed leg " + yacht.getLegNumber());
+
+                String logMessage = yacht.getBoatName() + " passed leg " + yacht.getLegNumber();
+                notifyMessageListeners(
+                    MessageFactory.makeChatterMessage(yacht.getSourceId(), logMessage));
             }
             yacht.incrementLegNumber();
             sendMarkRoundingMessage(yacht);
@@ -581,6 +725,10 @@ public class GameState implements Runnable {
      * @param yacht The current yacht to check for
      */
     private Boolean checkStartLineCrossing(ServerYacht yacht) {
+        long timeTillStart = System.currentTimeMillis() - this.getStartTime();
+        if (timeTillStart < 0){
+            return false;
+        }
         Integer currentMarkSeqID = yacht.getCurrentMarkSeqID();
         CompoundMark currentMark = markOrder.getCurrentMark(currentMarkSeqID);
         GeoPoint lastLocation = yacht.getLastLocation();
@@ -596,7 +744,9 @@ public class GameState implements Runnable {
             if (crossedLine == 2 && isClockwiseCross || crossedLine == 1 && !isClockwiseCross) {
                 yacht.setClosestCurrentMark(mark1);
                 yacht.setBoatStatus(BoatStatus.RACING);
-                sendServerMessage(yacht.getSourceId(), yacht.getBoatName() + " passed start line");
+                String logMessage = yacht.getBoatName() + " passed start line";
+                notifyMessageListeners(
+                    MessageFactory.makeChatterMessage(yacht.getSourceId(), logMessage));
                 return true;
             }
         }
@@ -700,7 +850,10 @@ public class GameState implements Runnable {
             if (crossedLine == 1 && isClockwiseCross || crossedLine == 2 && !isClockwiseCross) {
                 yacht.setClosestCurrentMark(mark1);
                 yacht.setBoatStatus(BoatStatus.FINISHED);
-                sendServerMessage(yacht.getSourceId(), yacht.getBoatName() + " passed finish line");
+
+                String logMessage = yacht.getBoatName() + " passed finish line";
+                notifyMessageListeners(
+                    MessageFactory.makeChatterMessage(yacht.getSourceId(), logMessage));
                 return true;
             }
         }
@@ -723,6 +876,7 @@ public class GameState implements Runnable {
             String name = new String(customizeData);
             playerYacht.setBoatName(name);
         } else if (requestType.equals(CustomizeRequestType.COLOR)) {
+            //This low level stuff shouldnt be here alistair! In fact no logic LIKE THIS should! - wmu16
             int red = customizeData[0] & 0xFF;
             int green = customizeData[1] & 0xFF;
             int blue = customizeData[2] & 0xFF;
@@ -735,7 +889,7 @@ public class GameState implements Runnable {
     }
 
     private static Mark checkMarkCollision(ServerYacht yacht) {
-        Set<Mark> marksInRace = GameState.getMarks();
+        Set<Mark> marksInRace = new HashSet<>(marks);
         for (Mark mark : marksInRace) {
             if (GeoUtility.getDistance(yacht.getLocation(), mark)
                 <= MARK_COLLISION_DISTANCE) {
@@ -764,15 +918,22 @@ public class GameState implements Runnable {
      * Collision detection which iterates through all the yachts and check if any yacht collided
      * with this yacht. Return collided yacht or null if no collision.
      *
+     * UPDATE: HACK!!! wmu16 - forBumperCollision is (the goddamn dirtiest) dirty flag to fix a
+     * weird bug where the bumper collision would not be registerd but the knock back collision would.
+     * In other words, only set the 'forBumperCollision' flag true if used for the bumper power up.
+     *
      * @return yacht to compare to all other yachts.
      */
-    private static ServerYacht checkYachtCollision(ServerYacht yacht) {
+    private static ServerYacht checkYachtCollision(ServerYacht yacht, Boolean forBumperCollision) {
+        Double collisionDistance =
+            (forBumperCollision) ? YACHT_COLLISION_DISTANCE + 2.5 : YACHT_COLLISION_DISTANCE;
 
         for (ServerYacht otherYacht : GameState.getYachts().values()) {
             if (otherYacht != yacht) {
                 Double distance = GeoUtility
                     .getDistance(otherYacht.getLocation(), yacht.getLocation());
-                if (distance < YACHT_COLLISION_DISTANCE) {
+                ;
+                if (distance < collisionDistance) {
                     return otherYacht;
                 }
             }
@@ -808,13 +969,6 @@ public class GameState implements Runnable {
                 roundingMark.getSourceID()));
     }
 
-
-    public static void sendServerMessage(Integer messageType, String message) {
-        notifyMessageListeners(new ChatterMessage(
-            messageType, "SERVER: " + message
-        ));
-    }
-
     public static void processChatter(ChatterMessage chatterMessage, boolean isHost) {
         String chatterText = chatterMessage.getMessage();
         String[] words = chatterText.split("\\s+");
@@ -822,17 +976,19 @@ public class GameState implements Runnable {
             switch (words[2].trim()) {
                 case "/speed":
                     try {
-                        setSpeedMultiplier(Double.valueOf(words[3]));
-                        sendServerMessage(chatterMessage.getMessage_type(),
-                                "Speed modifier set to x" + words[3]);
+                        serverSpeedMultiplier = Double.valueOf(words[3]);
+                        String logMessage = "Speed modifier set to x" + words[3];
+                        notifyMessageListeners(MessageFactory
+                            .makeChatterMessage(chatterMessage.getMessageType(), logMessage));
                     } catch (Exception e) {
                         Logger logger = LoggerFactory.getLogger(GameState.class);
                         logger.error("cannot parse >speed value");
                     }
                     return;
                 case "/finish":
-                    sendServerMessage(chatterMessage.getMessage_type(),
-                            "Game will now finish");
+                    String logMessage = "Game will now finish";
+                    notifyMessageListeners(MessageFactory
+                        .makeChatterMessage(chatterMessage.getMessageType(), logMessage));
                     endRace();
                     return;
             }
@@ -882,6 +1038,12 @@ public class GameState implements Runnable {
 
     public static void setMaxPlayers(Integer newMax){
         maxPlayers = newMax;
+
+        try {
+            ServerAdvertiser.getInstance().setCapacity(newMax);
+        } catch (IOException e) {
+            logger.warn("Couldn't update max players");
+        }
     }
 
     public static void endRace () {
@@ -889,11 +1051,11 @@ public class GameState implements Runnable {
         currentStage = GameStages.FINISHED;
     }
 
-    public static void setSpeedMultiplier (double multiplier) {
-        speedMultiplier = multiplier;
+    public static double getServerSpeedMultiplier() {
+        return serverSpeedMultiplier;
     }
 
-    public static double getSpeedMultiplier () {
-        return speedMultiplier;
+    public static void setTokensEnabled (boolean tokensEnabled) {
+        GameState.tokensEnabled = tokensEnabled;
     }
 }

src/main/java/seng302/gameServer/MainServerThread.java

@@ -1,30 +1,30 @@
 package seng302.gameServer;
 
 import java.io.IOException;
-import java.io.StringReader;
 import java.net.ServerSocket;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import java.util.Random;
 import java.util.Timer;
 import java.util.TimerTask;
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.w3c.dom.Document;
-import org.xml.sax.InputSource;
-import org.xml.sax.SAXException;
 import seng302.gameServer.messages.Message;
 import seng302.model.GeoPoint;
 import seng302.model.Player;
 import seng302.model.PolarTable;
 import seng302.model.ServerYacht;
-import seng302.model.mark.CompoundMark;
+import seng302.model.stream.xml.parser.RaceXMLData;
 import seng302.model.stream.xml.parser.RegattaXMLData;
 import seng302.utilities.GeoUtility;
-import seng302.utilities.XMLGenerator;
-import seng302.utilities.XMLParser;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.util.ArrayList;
+import java.util.Random;
+import java.util.Timer;
+import java.util.TimerTask;
 
 /**
  * A class describing the overall server, which creates and collects server threads for each client
@@ -37,37 +37,19 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
     private static final int PORT = 4942;
     private static final Integer CLIENT_UPDATES_PER_SECOND = 60;
 
-    private static final int MAX_WIND_SPEED = 12000;
-    private static final int MIN_WIND_SPEED = 8000;
-
     private boolean terminated;
 
     private Thread thread;
+    private boolean hasStarted = false;
 
     private ServerSocket serverSocket = null;
-    private ArrayList<ServerToClientThread> serverToClientThreads = new ArrayList<>();;
+    private ArrayList<ServerToClientThread> serverToClientThreads = new ArrayList<>();
     private static Integer capacity;
+    private RaceXMLData raceXMLData;
+    private RegattaXMLData regattaXMLData;
+    private boolean serverStarted = false;
 
     private void startAdvertisingServer() {
-        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
-        DocumentBuilder db;
-        Document doc;
-        XMLGenerator generator = new XMLGenerator();
-
-        try {
-            db = dbf.newDocumentBuilder();
-            String regatta = generator.getRegattaAsXml();
-            StringReader stringReader = new StringReader(regatta);
-            InputSource is = new InputSource(stringReader);
-            doc = db.parse(is);
-        } catch (ParserConfigurationException | IOException | SAXException e) {
-            logger.warn("Couldn't load race regatta");
-            return;
-        }
-
-        RegattaXMLData regattaXMLData = XMLParser.parseRegatta(doc);
-
-
         Integer capacity = GameState.getCapacity();
         Integer numPlayers = GameState.getNumberOfPlayers();
         Integer spacesLeft = capacity - numPlayers;
@@ -79,39 +61,46 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
 
         // Start advertising server
         try {
-            ServerAdvertiser.getInstance().setMapName(regattaXMLData.getCourseName()).setCapacity(capacity).setNumberOfPlayers(numPlayers);
-            ServerAdvertiser.getInstance().registerGame(PORT, regattaXMLData.getRegattaName());
+            ServerAdvertiser.getInstance()
+                .setMapName(regattaXMLData.getCourseName())
+                .setCapacity(capacity)
+                .setNumberOfPlayers(numPlayers - 1)
+                .registerGame(PORT, regattaXMLData.getRegattaName());
         } catch (IOException e) {
             logger.warn("Could not register server");
         }
     }
 
     public MainServerThread() {
-        new GameState("localhost");
+        new GameState();
         try {
             serverSocket = new ServerSocket(PORT);
         } catch (IOException e) {
             logger.trace("IO error in server thread handler upon trying to make new server socket",
                 0);
         }
-
-        startAdvertisingServer();
-
-        PolarTable.parsePolarFile(getClass().getResourceAsStream("/config/acc_polars.csv"));
-        GameState.addMessageEventListener(this::broadcastMessage);
         terminated = false;
         thread = new Thread(this, "MainServer");
-        startUpdatingWind();
-        startSpawningTokens();
         thread.start();
     }
 
+    private void startServer() {
+        PolarTable.parsePolarFile(getClass().getResourceAsStream("/server_config/acc_polars.csv"));
+        MessageFactory.updateXMLGenerator(raceXMLData, regattaXMLData);
+        GameState.setRace(raceXMLData);
+        MessageFactory.updateBoats(new ArrayList<>(GameState.getYachts().values()));
+        startAdvertisingServer();
+        GameState.addMessageEventListener(this::broadcastMessage);
+        sendSetupMessages();
+    }
 
     public void run() {
 
         new HeartbeatThread(this);
         new ServerListenThread(serverSocket, this);
 
+        hasStarted = true;
+
         //You should handle interrupts in some way, so that the thread won't keep on forever if you exit the app.
         while (!terminated) {
             if (GameState.getPlayerHasLeftFlag()) {
@@ -133,8 +122,8 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
             } catch (InterruptedException e) {
                 logger.trace("Interrupted exception in Main Server Thread thread sleep", 1);
             }
-            if (GameState.getCurrentStage() == GameStages.LOBBYING && GameState
-                .getCustomizationFlag()) {
+            if (GameState.getCurrentStage() == GameStages.LOBBYING && GameState.getCustomizationFlag()) {
+                MessageFactory.updateBoats(new ArrayList<>(GameState.getYachts().values()));
                 sendSetupMessages();
                 GameState.resetCustomizationFlag();
             }
@@ -160,8 +149,10 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
             }
         }
         try {
-            for (ServerToClientThread serverToClientThread : serverToClientThreads) {
-                serverToClientThread.terminate();
+            synchronized (this){
+                for (ServerToClientThread serverToClientThread : serverToClientThreads) {
+                    serverToClientThread.terminate();
+                }
             }
             serverSocket.close();
         } catch (IOException e) {
@@ -176,6 +167,7 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
     }
 
     private void sendSetupMessages() {
+        MessageFactory.updateBoats(new ArrayList<>(GameState.getYachts().values()));
         broadcastMessage(MessageFactory.getRaceXML());
         broadcastMessage(MessageFactory.getRegattaXML());
         broadcastMessage(MessageFactory.getBoatXML());
@@ -187,63 +179,6 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
         }
     }
 
-    private static void updateWind(){
-        Integer direction = GameState.getWindDirection().intValue();
-        Integer windSpeed = GameState.getWindSpeedMMS().intValue();
-
-        Random random = new Random();
-
-        if (Math.floorMod(random.nextInt(), 2) == 0){
-            direction += random.nextInt(4);
-            windSpeed += random.nextInt(20) + 459;
-        }
-        else{
-            direction -= random.nextInt(4);
-            windSpeed -= random.nextInt(20) + 459;
-        }
-
-        direction = Math.floorMod(direction, 360);
-
-        if (windSpeed > MAX_WIND_SPEED){
-            windSpeed -= random.nextInt(500);
-        }
-
-        if (windSpeed <= MIN_WIND_SPEED){
-            windSpeed += random.nextInt(500);
-        }
-
-        GameState.setWindSpeed(Double.valueOf(windSpeed));
-        GameState.setWindDirection(direction.doubleValue());
-    }
-
-
-
-
-    // TODO: 29/08/17 wmu16 - This sort of update should be in game state
-    private static void startUpdatingWind(){
-        Timer timer = new Timer();
-        timer.schedule(new TimerTask() {
-            @Override
-            public void run() {
-                updateWind();
-            }
-        }, 0, 500);
-    }
-
-    /**
-     * Start spawning coins every 60s after the first minute
-     */
-    private void startSpawningTokens() {
-        Timer timer = new Timer();
-        timer.schedule(new TimerTask() {
-            @Override
-            public void run() {
-                GameState.spawnNewToken();
-                broadcastMessage(MessageFactory.getRaceXML());
-            }
-        }, 10000, 60000);
-    }
-
     /**
      * A client has tried to connect to the server
      *
@@ -254,16 +189,43 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
         logger.debug("Player Connected From " + serverToClientThread.getThread().getName(), 0);
         if (serverToClientThreads.size() == 0) { //Sets first client as host.
             serverToClientThread.setAsHost();
+            serverToClientThread.raceXMLProperty().addListener((obs, oldVal, race) -> {
+                if (race != null) {
+                    raceXMLData = race;
+                }
+                if (regattaXMLData != null) {
+                    startServer();
+                }
+            });
+            serverToClientThread.regattaXMLProperty().addListener((obs, oldVal, regatta) -> {
+                if (regatta != null) {
+                    regattaXMLData = regatta;
+                }
+                if (raceXMLData != null) {
+                    startServer();
+                }
+            });
+        } else {
+            //serverToClientThread.addConnectionListener(this::sendSetupMessages);
         }
         serverToClientThreads.add(serverToClientThread);
-        serverToClientThread.addConnectionListener(this::sendSetupMessages);
-        serverToClientThread.addDisconnectListener(this::clientDisconnected);
 
         try {
             ServerAdvertiser.getInstance().setNumberOfPlayers(GameState.getNumberOfPlayers());
         } catch (IOException e) {
             logger.warn("Couldn't update advertisement");
         }
+
+        while (regattaXMLData == null && raceXMLData == null){
+            try {
+                Thread.sleep(50);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+
+        }
+        serverToClientThread.addConnectionListener(this::sendSetupMessages);
+        serverToClientThread.addDisconnectListener(this::clientDisconnected);
     }
 
     /**
@@ -284,6 +246,7 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
                 serverToClientThread.sendSetupMessages();
             }
         }
+
         serverToClientThreads.remove(closedConnection);
 
         try {
@@ -317,9 +280,9 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
         }, 0, 500);
 
 
-        if (GameState.getCurrentStage() == GameStages.LOBBYING) {
-            sendSetupMessages();
-        }
+//        if (GameState.getCurrentStage() == GameStages.LOBBYING) {
+//            sendSetupMessages();
+//        }
     }
 
     public void terminate() {
@@ -330,39 +293,170 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
      * Initialise boats to specific spaced out geopoints behind starting line.
      */
     private void initialiseBoatPositions() {
-        CompoundMark cm = GameState.getMarkOrder().getMarkOrder().get(0);
-        GeoPoint startMark1 = cm.getSubMark(1);
-        GeoPoint startMark2 = cm.getSubMark(2);
+//        CompoundMark cm = GameState.getMarkOrder().getMarkOrder().get(0);
+//        GeoPoint startMark1 = cm.getSubMark(1);
+//        GeoPoint startMark2 = cm.getSubMark(2);
+//
+//        // Calculating midpoint
+//        Double perpendicularAngle = GeoUtility.getBearing(startMark1, startMark2);
+//        Double length = GeoUtility.getDistance(startMark1, startMark2);
+//        GeoPoint midpoint = GeoUtility.getGeoCoordinate(startMark1, perpendicularAngle, length / 2);
+//
+//        // Setting each boats position side by side
+//        final double SEPARATION = 50.0;  // distance apart in meters
+//
+//        int boatIndex = 0;
+//        for (ServerYacht yacht : GameState.getYachts().values()) {
+//            int distanceApart = boatIndex / 2;
+//
+//            if (boatIndex % 2 == 1 && boatIndex != 0) {
+//                distanceApart++;
+//                distanceApart *= -1;
+//            }
+//
+//            GeoPoint spawnMark = GeoUtility
+//                .getGeoCoordinate(midpoint, perpendicularAngle, distanceApart * SEPARATION);
+//
+//            if (yacht.getHeading() < perpendicularAngle) {
+//                spawnMark = GeoUtility
+//                    .getGeoCoordinate(spawnMark, perpendicularAngle + 90, SEPARATION);
+//            } else {
+//                spawnMark = GeoUtility
+//                    .getGeoCoordinate(spawnMark, perpendicularAngle + 270, SEPARATION);
+//            }
+//
+//            yacht.setLocation(spawnMark);
+//            boatIndex++;
+//        }
 
-        // Calculating midpoint
-        Double perpendicularAngle = GeoUtility.getBearing(startMark1, startMark2);
-        Double length = GeoUtility.getDistance(startMark1, startMark2);
-        GeoPoint midpoint = GeoUtility.getGeoCoordinate(startMark1, perpendicularAngle, length / 2);
+//        final double SEPARATION = 50.0;  // distance apart in meters
+//
+//        //Reverse of the angle from start to first mark
+//        double angleToFirstMark = 360 - GeoUtility.getBearing(
+//            GameState.getMarkOrder().getMarkOrder().get(0).getMidPoint(),
+//            GameState.getMarkOrder().getMarkOrder().get(1).getMidPoint()
+//        );
+//
+//        //Length of start line
+//        double startLineLength = GeoUtility.getDistance(
+//            GameState.getMarkOrder().getMarkOrder().get(0).getSubMark(1),
+//            GameState.getMarkOrder().getMarkOrder().get(0).getSubMark(2)
+//        );
+//
+//        //Angle of start line
+//        double startMarkToMarkAngle = GeoUtility.getBearing(
+//            GameState.getMarkOrder().getMarkOrder().get(0).getSubMark(1),
+//            GameState.getMarkOrder().getMarkOrder().get(0).getSubMark(2)
+//        );
+//
+//        //How many yachts can fit along the start line
+//        int spacesAlongLine = (int) Math.round(startLineLength / SEPARATION);
+//        //The free space left by the boats.
+//        double buffer = (startLineLength % SEPARATION) / 2;
+//
+//        //Randomize starting order.
+//        List<ServerYacht> serverYachtList = new ArrayList<>(GameState.getYachts().values());
+//        Collections.shuffle(serverYachtList);
+//
+//        //set the starting point away from start line.
+//        GeoPoint startingPoint = GeoUtility.getGeoCoordinate(
+//            GameState.getMarkOrder().getMarkOrder().get(0).getSubMark(1),
+//            angleToFirstMark, SEPARATION
+//        );
+//
+//        //Move it along the start line
+//        startingPoint = GeoUtility.getGeoCoordinate(
+//            startingPoint, startMarkToMarkAngle, buffer
+//        );
+//
+//        int yachtCount = 0;
+//        int repeats = 0;
+//
+//        GeoPoint yachtLocation;
+//
+//        for (ServerYacht serverYacht : serverYachtList) {
+//
+//            //Move away from start line
+//            yachtLocation = GeoUtility.getGeoCoordinate(
+//                startingPoint, angleToFirstMark,repeats * SEPARATION
+//            );
+//            //Move along start line
+//            yachtLocation = GeoUtility.getGeoCoordinate(
+//                yachtLocation, startMarkToMarkAngle, yachtCount * SEPARATION
+//            );
+//            serverYacht.setLocation(yachtLocation);
+//            serverYacht.setHeading(GeoUtility.getBearing(
+//                yachtLocation, GameState.getMarkOrder().getMarkOrder().get(1).getMidPoint()
+//            ));
+//            //Set location for next yacht
+//            yachtCount++;
+//            if (yachtCount > spacesAlongLine) {
+//                yachtCount = 0;
+//                repeats++;
+//            }
+//        }
 
-        // Setting each boats position side by side
-        double DISTANCE_FACTOR = 50.0;  // distance apart in meters
-        int boatIndex = 0;
-        for (ServerYacht yacht : GameState.getYachts().values()) {
-            int distanceApart = boatIndex / 2;
+        final double DISTANCE_TO_START = 75d;
+        final double YACHT_SEPARATION = 20d;
 
-            if (boatIndex % 2 == 1 && boatIndex != 0) {
-                distanceApart++;
-                distanceApart *= -1;
+        //Length of start line
+        double startLineLength = GeoUtility.getDistance(
+            GameState.getMarkOrder().getMarkOrder().get(0).getSubMark(1),
+            GameState.getMarkOrder().getMarkOrder().get(0).getSubMark(2)
+        );
+
+        //How many yachts can fit along the start line
+        int spacesAlongLine = (int) Math.round(startLineLength / YACHT_SEPARATION);
+
+        //Angle of start line
+        double startMarkToMarkAngle = GeoUtility.getBearing(
+            GameState.getMarkOrder().getMarkOrder().get(0).getSubMark(1),
+            GameState.getMarkOrder().getMarkOrder().get(0).getSubMark(2)
+        );
+
+        //angle from first mark to the start
+        double angleToStart = GeoUtility.getBearing(
+            GameState.getMarkOrder().getMarkOrder().get(1).getMidPoint(),
+            GameState.getMarkOrder().getMarkOrder().get(0).getMidPoint()
+        );
+
+        double angleFromStart = GeoUtility.getBearing(
+            GameState.getMarkOrder().getMarkOrder().get(0).getMidPoint(),
+            GameState.getMarkOrder().getMarkOrder().get(1).getMidPoint()
+        );
+
+        GeoPoint startingPoint = GeoUtility.getGeoCoordinate(
+            GameState.getMarkOrder().getMarkOrder().get(0).getMidPoint(),
+            angleToStart, DISTANCE_TO_START
+        );
+
+        List<ServerYacht> randomisedYachts = new ArrayList<>(GameState.getYachts().values());
+        Collections.shuffle(randomisedYachts);
+        while (randomisedYachts.size() > 0) {
+
+            int numYachtsInLine = spacesAlongLine > randomisedYachts.size() ? randomisedYachts.size() : spacesAlongLine;
+            double yachtSpace = numYachtsInLine * YACHT_SEPARATION / 2;
+
+            GeoPoint firstYachtPoint = GeoUtility.getGeoCoordinate(
+                startingPoint, startMarkToMarkAngle + 180, yachtSpace
+            );
+
+            for (int i=0; i<numYachtsInLine; i++){
+                randomisedYachts.get(0).setHeading(angleFromStart);
+                randomisedYachts.get(0).setLocation(firstYachtPoint);
+                firstYachtPoint = GeoUtility.getGeoCoordinate(
+                    firstYachtPoint, startMarkToMarkAngle, yachtSpace
+                );
+                randomisedYachts.remove(0);
             }
 
-            GeoPoint spawnMark = GeoUtility
-                .getGeoCoordinate(midpoint, perpendicularAngle, distanceApart * DISTANCE_FACTOR);
-
-            if (yacht.getHeading() < perpendicularAngle) {
-                spawnMark = GeoUtility
-                    .getGeoCoordinate(spawnMark, perpendicularAngle + 90, DISTANCE_FACTOR);
-            } else {
-                spawnMark = GeoUtility
-                    .getGeoCoordinate(spawnMark, perpendicularAngle + 270, DISTANCE_FACTOR);
-            }
-
-            yacht.setLocation(spawnMark);
-            boatIndex++;
+            startingPoint = GeoUtility.getGeoCoordinate(
+                startingPoint, angleToStart, DISTANCE_TO_START
+            );
         }
     }
+
+    public boolean hasStarted() {
+        return hasStarted;
+    }
 }

src/main/java/seng302/gameServer/MessageFactory.java

@@ -1,9 +1,11 @@
 package seng302.gameServer;
 
+import seng302.gameServer.messages.*;
 import java.util.ArrayList;
 import java.util.List;
 import seng302.gameServer.messages.BoatLocationMessage;
 import seng302.gameServer.messages.BoatSubMessage;
+import seng302.gameServer.messages.ChatterMessage;
 import seng302.gameServer.messages.RaceStartNotificationType;
 import seng302.gameServer.messages.RaceStartStatusMessage;
 import seng302.gameServer.messages.RaceStatus;
@@ -11,13 +13,21 @@ import seng302.gameServer.messages.RaceStatusMessage;
 import seng302.gameServer.messages.RaceType;
 import seng302.gameServer.messages.XMLMessage;
 import seng302.gameServer.messages.XMLMessageSubType;
+import seng302.gameServer.messages.YachtEventCodeMessage;
+import seng302.gameServer.messages.YachtEventType;
 import seng302.model.Player;
 import seng302.model.ServerYacht;
 import seng302.model.stream.xml.generator.RaceXMLTemplate;
 import seng302.model.stream.xml.generator.RegattaXMLTemplate;
+import seng302.model.stream.xml.parser.RaceXMLData;
+import seng302.model.stream.xml.parser.RegattaXMLData;
 import seng302.model.token.Token;
+import seng302.model.token.TokenType;
 import seng302.utilities.XMLGenerator;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * A Class for interfacing between the data we have in the GameState to the messages we need to send
  * through the MainServerThread.
@@ -35,6 +45,51 @@ Ideally this class would be created with an instance of the GameState (I tried i
 public class MessageFactory {
 
     private static XMLGenerator xmlGenerator = new XMLGenerator();
+    private static XMLMessage race;
+    private static XMLMessage regatta;
+    private static XMLMessage boats;
+
+    public static void updateXMLGenerator(RaceXMLData race, RegattaXMLData regatta) {
+        xmlGenerator.setRegattaTemplate(
+            new RegattaXMLTemplate(
+                regatta.getRegattaName(),
+                regatta.getCourseName(),
+                regatta.getCentralLat(),
+                regatta.getCentralLng()
+            )
+        );
+        xmlGenerator.setRaceTemplate(
+            new RaceXMLTemplate(
+                new ArrayList<>(),
+                new ArrayList<>(),
+                race.getMarkSequence(),
+                race.getCourseLimit(),
+                new ArrayList<>(race.getCompoundMarks().values()),
+                GameState.getCapacity(), true
+            )
+        );
+        String xmlStr = xmlGenerator.getRaceAsXml();
+        MessageFactory.race = new XMLMessage(xmlStr, XMLMessageSubType.RACE, xmlStr.length());
+        xmlStr = xmlGenerator.getRegattaAsXml();
+        MessageFactory.regatta = new XMLMessage(xmlStr, XMLMessageSubType.REGATTA, xmlStr.length());
+        xmlStr = xmlGenerator.getBoatsAsXml();
+        MessageFactory.boats = new XMLMessage(xmlStr, XMLMessageSubType.BOAT, xmlStr.length());
+    }
+
+    public static void updateBoats(List<ServerYacht> yachts) {
+//        for (ServerYacht serverYacht : yachts) {
+//            System.out.println(serverYacht);
+//        }
+        xmlGenerator.getRace().setBoats(yachts);
+        String xmlStr = xmlGenerator.getBoatsAsXml();
+        MessageFactory.boats = new XMLMessage(xmlStr, XMLMessageSubType.BOAT, xmlStr.length());
+    }
+
+    public static void updateTokens(List<Token> tokens) {
+        xmlGenerator.getRace().setTokens(tokens);
+        String xmlStr = xmlGenerator.getRaceAsXml();
+        MessageFactory.race = new XMLMessage(xmlStr, XMLMessageSubType.RACE, xmlStr.length());
+    }
 
 
     public static RaceStartStatusMessage getRaceStartStatusMessage() {
@@ -95,37 +150,83 @@ public class MessageFactory {
     }
 
     public static XMLMessage getRaceXML() {
-        List<ServerYacht> yachts = new ArrayList<>(GameState.getYachts().values());
-        List<Token> tokens = GameState.getTokensInPlay();
-        RaceXMLTemplate raceXMLTemplate = new RaceXMLTemplate(yachts, tokens);
-        xmlGenerator.setRaceTemplate(raceXMLTemplate);
-
-        XMLMessage raceXMLMessage = new XMLMessage(
-            xmlGenerator.getRaceAsXml(),
-            XMLMessageSubType.RACE,
-            xmlGenerator.getRaceAsXml().length());
-
-        return raceXMLMessage;
+        return race;
     }
 
     public static XMLMessage getRegattaXML() {
-        //@TODO calculate lat/lng values
-
-        return new XMLMessage(
-            xmlGenerator.getRegattaAsXml(),
-            XMLMessageSubType.REGATTA,
-            xmlGenerator.getRegattaAsXml().length());
+       return regatta;
     }
 
     public static XMLMessage getBoatXML() {
-        List<ServerYacht> yachts = new ArrayList<>(GameState.getYachts().values());
-        List<Token> tokens = GameState.getTokensInPlay();
-        RaceXMLTemplate raceXMLTemplate = new RaceXMLTemplate(yachts, tokens);
-        xmlGenerator.setRaceTemplate(raceXMLTemplate);
+        return boats;
+    }
 
-        return new XMLMessage(
-            xmlGenerator.getBoatsAsXml(),
-            XMLMessageSubType.BOAT,
-            xmlGenerator.getBoatsAsXml().length());
+    public static YachtEventCodeMessage makeCollisionMessage(ServerYacht serverYacht) {
+        return new YachtEventCodeMessage(serverYacht.getSourceId(), YachtEventType.COLLISION);
+    }
+
+
+    /**
+     * Constructs a message to be sent out whenever a yacht picks up a boost
+     *
+     * @param serverYacht The yacht that has picked up a power up
+     * @param token The token which they picked up
+     * @return The corresponding YachtEventCodeMessage
+     */
+    public static YachtEventCodeMessage makePickupMessage(ServerYacht serverYacht, Token token) {
+        YachtEventType yachtEventType = null;
+        switch (token.getTokenType()) {
+            case BOOST:
+                yachtEventType = YachtEventType.TOKEN_VELOCITY;
+                break;
+            case HANDLING:
+                yachtEventType = YachtEventType.TOKEN_HANDLING;
+                break;
+            case WIND_WALKER:
+                yachtEventType = YachtEventType.TOKEN_WIND_WALKER;
+                break;
+            case BUMPER:
+                yachtEventType = YachtEventType.TOKEN_BUMPER;
+                break;
+            case RANDOM:
+                yachtEventType = YachtEventType.TOKEN_RANDOM;
+                break;
+        }
+        return new YachtEventCodeMessage(serverYacht.getSourceId(), yachtEventType);
+    }
+
+    /**
+     * Constructs a message representing a certain buff / debuff for a given yacht. For now this is
+     * just for the bumper debuff so the affected boat is aware that it has been crashed. This could
+     * however be extended to render affects for all boats given a certain debuff.
+     *
+     * @param yacht The yacht affected by some status
+     * @param token The token indicating what status they have
+     * @return A YachtEventCodeMessage
+     */
+    public static YachtEventCodeMessage makeStatusEffectMessage(ServerYacht yacht,
+        TokenType token) {
+        YachtEventType yachtEventType = null;
+        switch (token) {
+            case BUMPER:
+                yachtEventType = YachtEventType.BUMPER_CRASH;
+                break;
+        }
+        return new YachtEventCodeMessage(yacht.getSourceId(), yachtEventType);
+    }
+
+
+    /**
+     * Constructs a message to be sent out when a given yacht powers down (From a boost of any type)
+     *
+     * @param yacht The yacht that is powering down
+     * @return A YachtEventCodeMessage representing this action
+     */
+    public static YachtEventCodeMessage makePowerDownMessage(ServerYacht yacht) {
+        return new YachtEventCodeMessage(yacht.getSourceId(), YachtEventType.POWER_DOWN);
+    }
+
+    public static ChatterMessage makeChatterMessage(Integer messageType, String message) {
+        return new ChatterMessage(messageType, "SERVER: " + message);
     }
 }

src/main/java/seng302/gameServer/ServerAdvertiser.java

@@ -1,5 +1,10 @@
 package seng302.gameServer;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import seng302.discoveryServer.DiscoveryServerClient;
+import seng302.discoveryServer.util.ServerListing;
+
 import javax.jmdns.JmDNS;
 import javax.jmdns.ServiceInfo;
 import java.io.IOException;
@@ -32,12 +37,16 @@ public class ServerAdvertiser {
     private static ServerAdvertiser instance = null;
     private static JmDNS jmdnsInstance = null;
     private ServiceInfo serviceInfo; // Note: Whenever this is changed, our service will be re-registered on the network.
+    private DiscoveryServerClient repositoryClient;
 
     private Hashtable<String ,String> props;
+    private Logger logger = LoggerFactory.getLogger(ServerAdvertiser.class);
 
     private ServerAdvertiser() throws IOException{
         jmdnsInstance = JmDNS.create(InetAddress.getByName(getLocalHostIp()));
 
+        repositoryClient = new DiscoveryServerClient();
+
         props = new Hashtable<>();
         props.put("map", "");
         props.put("spacesLeft", "0");
@@ -122,10 +131,13 @@ public class ServerAdvertiser {
                     try {
                         jmdnsInstance.registerService(serviceInfo);
                     } catch (IOException e) {
-                        System.out.println("Failed");
+                        logger.warn("Failed to register service info");
                     }
                 }
             }, 0);
+
+        ServerListing serverListing = new ServerListing(serverName, props.get("map"), new DiscoveryServerClient().getInetIp(), portNo, Integer.parseInt(props.get("capacity")));
+        repositoryClient.register(serverListing);
     }
 
     /**

src/main/java/seng302/gameServer/ServerDescription.java

@@ -7,6 +7,10 @@ public class ServerDescription {
     private String serverName;
     private String mapName;
     private Integer numPlayers;
+    private Long lastUpdated;
+    private Long lastRefreshed;
+
+    private static Long EXPIRY_INTERVAL = 5000L;
 
     public ServerDescription(String serverName, String mapName, Integer numPlayers, Integer capacity, String address, Integer portNum){
         this.serverName = serverName;
@@ -15,6 +19,7 @@ public class ServerDescription {
         this.address = address;
         this.portNum = portNum;
         this.capacity = capacity;
+        lastUpdated = System.currentTimeMillis();
     }
 
 
@@ -80,4 +85,17 @@ public class ServerDescription {
         return this.getName().hashCode() + this.getAddress().hashCode() +
                 this.portNumber().hashCode() + this.getMapName().hashCode();
     }
+
+    public Boolean hasExpired(){
+        return System.currentTimeMillis() - lastUpdated > EXPIRY_INTERVAL;
+    }
+
+    public Boolean serverShouldBeRemoved() {
+        if (lastRefreshed == null) return false;
+        return System.currentTimeMillis() - lastRefreshed > EXPIRY_INTERVAL;
+    }
+
+    public void hasBeenRefreshed(){
+        lastRefreshed = System.currentTimeMillis();
+    }
 }

src/main/java/seng302/gameServer/ServerToClientThread.java

@@ -1,23 +1,11 @@
 package seng302.gameServer;
 
 
-import java.io.BufferedReader;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.net.Socket;
-import java.net.SocketException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ThreadLocalRandom;
-import java.util.stream.Collectors;
-import java.util.zip.CRC32;
-import java.util.zip.Checksum;
+import javafx.beans.property.SimpleObjectProperty;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import seng302.gameServer.messages.*;
+import org.w3c.dom.Document;
 import seng302.gameServer.messages.BoatAction;
 import seng302.gameServer.messages.ChatterMessage;
 import seng302.gameServer.messages.ClientType;
@@ -25,16 +13,29 @@ import seng302.gameServer.messages.CustomizeRequestType;
 import seng302.gameServer.messages.Message;
 import seng302.gameServer.messages.RegistrationResponseMessage;
 import seng302.gameServer.messages.RegistrationResponseStatus;
-import seng302.gameServer.messages.XMLMessage;
-import seng302.gameServer.messages.XMLMessageSubType;
 import seng302.model.Player;
 import seng302.model.ServerYacht;
 import seng302.model.stream.packets.PacketType;
 import seng302.model.stream.packets.StreamPacket;
-import seng302.model.stream.xml.generator.RaceXMLTemplate;
+import seng302.model.stream.xml.parser.RaceXMLData;
+import seng302.model.stream.xml.parser.RegattaXMLData;
+import seng302.utilities.StreamParser;
 import seng302.utilities.XMLGenerator;
+import seng302.utilities.XMLParser;
 import seng302.visualiser.fxObjects.assets_3D.BoatMeshType;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+import java.net.SocketException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.zip.CRC32;
+import java.util.zip.Checksum;
+
 /**
  * A class describing a single connection to a Client for the purposes of sending and receiving on
  * its own thread. All server threads created and owned by the server thread handler which can
@@ -78,9 +79,11 @@ public class ServerToClientThread implements Runnable {
     private List<ConnectionListener> connectionListeners = new ArrayList<>();
     private DisconnectListener disconnectListener;
 
-    private ServerYacht yacht;
     private Player player;
 
+    private SimpleObjectProperty<RaceXMLData> raceXMLProperty = new SimpleObjectProperty<>();
+    private SimpleObjectProperty<RegattaXMLData> regattaXMLProperty = new SimpleObjectProperty<>();
+
     public ServerToClientThread(Socket socket) {
         this.socket = socket;
         seqNo = 0;
@@ -101,33 +104,11 @@ public class ServerToClientThread implements Runnable {
     }
 
     private void setUpPlayer(){
-        BufferedReader fn;
-        String fName = "";
-        BufferedReader ln;
-        String lName = "";
-
-        fn = new BufferedReader(
-                new InputStreamReader(
-                        ServerToClientThread.class.getResourceAsStream(
-                                "/server_config/CSV_Database_of_First_Names.csv"
-                        )
-                )
-        );
-        List<String> all = fn.lines().collect(Collectors.toList());
-        fName = all.get(ThreadLocalRandom.current().nextInt(0, all.size()));
-        ln = new BufferedReader(
-                new InputStreamReader(
-                        ServerToClientThread.class.getResourceAsStream(
-                                "/server_config/CSV_Database_of_Last_Names.csv"
-                        )
-                )
-        );
-        all = ln.lines().collect(Collectors.toList());
-        lName = all.get(ThreadLocalRandom.current().nextInt(0, all.size()));
+        String shortName = "P" + sourceId;
+        String longName = "Player " + sourceId;
 
         ServerYacht yacht = new ServerYacht(
-            BoatMeshType.DINGHY, sourceId, sourceId.toString(), fName, fName + " " + lName, "NZ"
-        );
+            BoatMeshType.DINGHY, sourceId, sourceId.toString(), shortName, longName, "NZ");
 
         player = new Player(socket, yacht);
         GameState.addYacht(sourceId, yacht);
@@ -186,37 +167,52 @@ public class ServerToClientThread implements Runnable {
                     long computedCrc = checksum.getValue();
                     long packetCrc = Message.bytesToLong(getBytes(4));
                     if (computedCrc == packetCrc) {
+                        StreamPacket packet = new StreamPacket(type, payloadLength, timeStamp, payload);
                         switch (PacketType.assignPacketType(type, payload)) {
                             case BOAT_ACTION:
-                                BoatAction actionType = ServerPacketParser
-                                        .extractBoatAction(
-                                                new StreamPacket(type, payloadLength, timeStamp, payload));
+                                BoatAction actionType = ServerPacketParser.extractBoatAction(packet);
                                 GameState.updateBoat(sourceId, actionType);
                                 break;
 
                             case RACE_REGISTRATION_REQUEST:
-                                ClientType requestedType = ServerPacketParser.extractClientType(
-                                        new StreamPacket(type, payloadLength, timeStamp, payload));
-
+                                ClientType requestedType = ServerPacketParser
+                                    .extractClientType(packet);
                                 completeRegistration(requestedType);
                                 break;
                             case CHATTER_TEXT:
                                 ChatterMessage chatterMessage = ServerPacketParser
-                                    .extractChatterText(
-                                        new StreamPacket(type, payloadLength, timeStamp, payload));
+                                    .extractChatterText(packet);
                                 GameState.processChatter(chatterMessage, isHost);
                                 break;
                             case RACE_CUSTOMIZATION_REQUEST:
-                                Long sourceID = Message
-                                    .bytesToLong(Arrays.copyOfRange(payload, 0, 3));
+                                Long sourceID = Message.bytesToLong(
+                                    Arrays.copyOfRange(payload, 0, 3)
+                                );
                                 CustomizeRequestType requestType = ServerPacketParser
-                                    .extractCustomizationType(
-                                        new StreamPacket(type, payloadLength, timeStamp, payload));
+                                    .extractCustomizationType(packet);
+
                                 GameState.customizePlayer(sourceID, requestType,
-                                    Arrays.copyOfRange(payload, 6, payload.length));
+                                    Arrays.copyOfRange(payload, 6, payload.length)
+                                );
                                 GameState.setCustomizationFlag();
                                 // TODO: 17/08/2017 ajm412: Send a response packet here, not really necessary until we do shapes.
                                 break;
+                            case RACE_XML:
+                                Document document = StreamParser.extractXmlMessage(packet);
+                                raceXMLProperty.set(
+                                    XMLParser.parseRace(document)
+                                );
+                                GameState.setMaxPlayers(XMLParser.getMaxPlayers(document));
+                                GameState.setTokensEnabled(XMLParser.tokensEnabled(document));
+                                break;
+                            case REGATTA_XML:
+                                regattaXMLProperty.set(
+                                    XMLParser.parseRegatta(
+                                        StreamParser.extractXmlMessage(packet)
+                                    )
+                                );
+                                break;
+
                         }
                     } else {
                         logger.warn("Packet has been dropped", 1);
@@ -233,23 +229,9 @@ public class ServerToClientThread implements Runnable {
     }
 
     public void sendSetupMessages() {
-        xmlGenerator = new XMLGenerator();
-        RaceXMLTemplate race = new RaceXMLTemplate(new ArrayList<>(GameState.getYachts().values()), new ArrayList<>());
-
-        xmlGenerator.setRaceTemplate(race);
-
-        XMLMessage xmlMessage;
-        xmlMessage = new XMLMessage(xmlGenerator.getRegattaAsXml(), XMLMessageSubType.REGATTA,
-                xmlGenerator.getRegattaAsXml().length());
-        sendMessage(xmlMessage);
-
-        xmlMessage = new XMLMessage(xmlGenerator.getBoatsAsXml(), XMLMessageSubType.BOAT,
-                xmlGenerator.getBoatsAsXml().length());
-        sendMessage(xmlMessage);
-
-        xmlMessage = new XMLMessage(xmlGenerator.getRaceAsXml(), XMLMessageSubType.RACE,
-                xmlGenerator.getRaceAsXml().length());
-        sendMessage(xmlMessage);
+        sendMessage(MessageFactory.getRegattaXML());
+        sendMessage(MessageFactory.getBoatXML());
+        sendMessage(MessageFactory.getRaceXML());
     }
 
     private void closeSocket() {
@@ -318,10 +300,6 @@ public class ServerToClientThread implements Runnable {
         return socket;
     }
 
-    public ServerYacht getYacht() {
-        return yacht;
-    }
-
     public void addConnectionListener(ConnectionListener listener) {
         connectionListeners.add(listener);
     }
@@ -345,4 +323,12 @@ public class ServerToClientThread implements Runnable {
     public void setAsHost() {
         isHost = true;
     }
+
+    public SimpleObjectProperty<RaceXMLData> raceXMLProperty() {
+        return raceXMLProperty;
+    }
+
+    public SimpleObjectProperty<RegattaXMLData> regattaXMLProperty() {
+        return regattaXMLProperty;
+    }
 }

src/main/java/seng302/gameServer/messages/BoatActionMessage.java

@@ -5,19 +5,19 @@ package seng302.gameServer.messages;
  */
 public class BoatActionMessage extends Message{
     private final MessageType MESSAGE_TYPE = MessageType.BOAT_ACTION;
-    private final int MESSAGE_SIZE = 1;
+    private final int MESSAGE_SIZE = 5;
     private BoatAction actionType;
 
-    public BoatActionMessage(BoatAction actionType) {
+    public BoatActionMessage(BoatAction actionType, int sourceId) {
         this.actionType = actionType;
-        setHeader(new Header(MessageType.BOAT_ACTION, 0, (short) 1)); // the second variable is the source id
+        setHeader(new Header(MessageType.BOAT_ACTION, sourceId, (short) MESSAGE_SIZE)); // the second variable is the source id
         allocateBuffer();
         writeHeaderToBuffer();
         // Write message fields
         putInt(actionType.getValue(), 1);
+        putInt(sourceId, 4);
         writeCRC();
         rewind();
-
     }
 
     @Override

src/main/java/seng302/gameServer/messages/ChatterMessage.java

@@ -40,7 +40,7 @@ public class ChatterMessage extends Message {
         return message;
     }
 
-    public int getMessage_type() {
+    public int getMessageType() {
         return message_type;
     }
 }

src/main/java/seng302/gameServer/messages/MessageType.java

@@ -21,7 +21,10 @@ public enum MessageType {
     REGISTRATION_REQUEST(101),
     REGISTRATION_RESPONSE(102),
     CUSTOMIZATION_REQUEST(103),
-    CUSTOMIZATION_RESPONSE(104);
+    CUSTOMIZATION_RESPONSE(104),
+    REPO_REGISTRATION_REQUEST(201),
+    ROOM_CODE_REQUEST(202),
+    LOBBY_REQUEST(203);
 
 
     private int code;

src/main/java/seng302/gameServer/messages/RegistrationRequestMessage.java

@@ -4,8 +4,8 @@ package seng302.gameServer.messages;
 public class RegistrationRequestMessage extends Message {
     private static int MESSAGE_LENGTH = 2;
 
-    public RegistrationRequestMessage(ClientType type){
-        setHeader(new Header(MessageType.REGISTRATION_REQUEST, 1, (short) getSize()));
+    public RegistrationRequestMessage(ClientType type, int clientID){
+        setHeader(new Header(MessageType.REGISTRATION_REQUEST, clientID, (short) getSize()));
 
         allocateBuffer();
         writeHeaderToBuffer();

src/main/java/seng302/gameServer/messages/RoomCodeRequest.java

@@ -0,0 +1,24 @@
+package seng302.gameServer.messages;
+
+public class RoomCodeRequest extends Message{
+    private int size = 0;
+
+    @Override
+    public int getSize() {
+        return size;
+    }
+
+    public RoomCodeRequest(String roomCode){
+        size = roomCode.length() + 6;
+
+        setHeader(new Header(MessageType.ROOM_CODE_REQUEST, 0x01, (short)getSize()));
+        allocateBuffer();
+        writeHeaderToBuffer();
+
+        putInt(roomCode.length(), 6);
+        putBytes(roomCode.getBytes());
+
+        writeCRC();
+        rewind();
+    }
+}

src/main/java/seng302/gameServer/messages/ServerRegistrationMessage.java

@@ -0,0 +1,64 @@
+package seng302.gameServer.messages;
+
+import seng302.discoveryServer.util.ServerListing;
+
+public class ServerRegistrationMessage extends Message {
+    private int size;
+
+    public ServerRegistrationMessage(ServerListing serverListing) {
+        String serverName = serverListing.getServerName();
+        String mapName = serverListing.getMapName();
+        String address = serverListing.getAddress();
+        int port = serverListing.getPortNumber();
+        int players = serverListing.getPortNumber();
+        int capacity = serverListing.getCapacity();
+        String roomCode = serverListing.getRoomCode();
+
+        createMessage(serverName, mapName, address, port, players, capacity, roomCode);
+    }
+
+    public static ServerRegistrationMessage getEmptyRegistration() {
+        return new ServerRegistrationMessage("","","",0,0,0,"");
+    }
+
+    @Override
+    public int getSize() {
+        return size;
+    }
+
+    public ServerRegistrationMessage(String serverName, String mapName, String address, int port, int players, int capacity, String roomCode){
+        createMessage(serverName, mapName, address, port, players, capacity, roomCode);
+    }
+
+    private void createMessage(String serverName, String mapName, String address, int port, int players, int capacity, String roomCode){
+        size = serverName.getBytes().length + mapName.length() + address.length() + roomCode.length() + 36;
+
+        setHeader(new Header(MessageType.REPO_REGISTRATION_REQUEST, 0x01, (short) getSize()));
+        allocateBuffer();
+        writeHeaderToBuffer();
+
+        int nameLength = serverName.length();
+        int mapNameLength = mapName.length();
+        int addressLength = address.length();
+        int roomCodeLength = roomCode.length();
+
+        // Put fields here
+        putInt(nameLength, 6);
+        putInt(mapNameLength, 6);
+        putInt(addressLength, 6);
+        putInt(roomCodeLength, 6);
+
+        putInt(port, 4);
+        putInt(players, 4);
+        putInt(capacity, 4);
+
+        putBytes(serverName.getBytes());
+        putBytes(mapName.getBytes());
+        putBytes(address.getBytes());
+        putBytes(roomCode.getBytes());
+
+        writeCRC();
+        rewind();
+    }
+
+}

src/main/java/seng302/gameServer/messages/YachtEventType.java

@@ -1,11 +1,18 @@
 package seng302.gameServer.messages;
 
 /**
- * Created by wmu16 on 11/09/17.
+ * Enum for different event types for the yacht
  */
 public enum YachtEventType {
     COLLISION(33),
-    TOKEN(34);
+    TOKEN_VELOCITY(34),
+    TOKEN_BUMPER(35),
+    TOKEN_HANDLING(36),
+    TOKEN_WIND_WALKER(37),
+    TOKEN_RANDOM(38),
+    POWER_DOWN(39),
+    BUMPER_CRASH(40);
+
 
     private int code;
 

src/main/java/seng302/model/ClientYacht.java

@@ -6,16 +6,23 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Observable;
 import java.util.Observer;
+import java.util.Timer;
 import javafx.beans.property.ReadOnlyDoubleProperty;
 import javafx.beans.property.ReadOnlyDoubleWrapper;
 import javafx.beans.property.ReadOnlyIntegerProperty;
 import javafx.beans.property.ReadOnlyIntegerWrapper;
 import javafx.beans.property.ReadOnlyLongProperty;
 import javafx.beans.property.ReadOnlyLongWrapper;
+import javafx.beans.value.ObservableObjectValue;
+import javafx.collections.FXCollections;
 import javafx.scene.paint.Color;
+import jdk.nashorn.internal.objects.annotations.Function;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import seng302.model.token.TokenType;
 import seng302.visualiser.fxObjects.assets_3D.BoatMeshType;
+import seng302.model.token.TokenType;
+import seng302.visualiser.fxObjects.assets_3D.BoatObject;
 
 /**
  * Yacht class for the racing boat. <p> Class created to store more variables (eg. boat statuses)
@@ -35,6 +42,26 @@ public class ClientYacht extends Observable {
         void notifyRounding(ClientYacht yacht, int legNumber);
     }
 
+    @FunctionalInterface
+    public interface ColorChangeListener {
+
+        void notifyColorChange(ClientYacht yacht);
+    }
+
+    //This notifies RaceViewController so it can display icon - wmu16
+    @FunctionalInterface
+    public interface PowerUpListener {
+        void notifyPowerUp(ClientYacht yacht, TokenType tokenType);
+    }
+
+    //This notifies RaceViewController so it can remove token icon - wmu16
+    @FunctionalInterface
+    public interface PowerDownListener {
+        void notifyPowerDown(ClientYacht yacht);
+    }
+
+
+
     private Logger logger = LoggerFactory.getLogger(ClientYacht.class);
 
 
@@ -45,6 +72,7 @@ public class ClientYacht extends Observable {
     private String boatName;
     private String country;
     private Integer position;
+    private TokenType powerUp;
 
     private Long estimateTimeAtFinish;
     private Boolean sailIn = true;
@@ -57,12 +85,21 @@ public class ClientYacht extends Observable {
     private Integer boatStatus;
     private Double currentVelocity;
 
+    Timer t;
+
+    private BoatObject boatObject;
+
     private List<YachtLocationListener> locationListeners = new ArrayList<>();
     private List<MarkRoundingListener> markRoundingListeners = new ArrayList<>();
+    private List<PowerUpListener> powerUpListeners = new ArrayList<>();
+    private List<PowerDownListener> powerDownListeners = new ArrayList<>();
+    private List<ColorChangeListener> colorChangeListeners = new ArrayList<>();
+
     private ReadOnlyDoubleWrapper velocityProperty = new ReadOnlyDoubleWrapper();
     private ReadOnlyLongWrapper timeTillNextProperty = new ReadOnlyLongWrapper();
     private ReadOnlyLongWrapper timeSinceLastMarkProperty = new ReadOnlyLongWrapper();
     private ReadOnlyIntegerWrapper placingProperty = new ReadOnlyIntegerWrapper();
+    private ReadOnlyDoubleWrapper headingProperty = new ReadOnlyDoubleWrapper();
     private Color colour;
 
     public ClientYacht(BoatMeshType boatType, Integer sourceId, String hullID, String shortName,
@@ -75,6 +112,7 @@ public class ClientYacht extends Observable {
         this.country = country;
         this.location = new GeoPoint(57.670341, 11.826856);
         this.heading = 120.0;   //In degrees
+        this.headingProperty.set(this.heading);
         this.currentVelocity = 0d;
         this.boatStatus = 1;
         this.colour = Color.rgb(0, 0, 0, 1.0);
@@ -200,6 +238,32 @@ public class ClientYacht extends Observable {
         this.position = position;
     }
 
+    /**
+     * Powers down the boat and notifies the raceViewController to display
+     */
+    public void powerDown() {
+        this.powerUp = null;
+        for (PowerDownListener listener : powerDownListeners) {
+            listener.notifyPowerDown(this);
+        }
+    }
+
+    /**
+     * powers up the boat and notifies the raceViewController to display
+     *
+     * @param tokenType The type of token that this boat is being powered up with
+     */
+    public void setPowerUp(TokenType tokenType) {
+        this.powerUp = tokenType;
+        for (PowerUpListener listener : powerUpListeners) {
+            listener.notifyPowerUp(this, tokenType);
+        }
+    }
+
+    public TokenType getPowerUp() {
+        return powerUp;
+    }
+
     public void toggleSail() {
         sailIn = !sailIn;
     }
@@ -222,6 +286,7 @@ public class ClientYacht extends Observable {
 
     public void setHeading(Double heading) {
         this.heading = heading;
+        setHeadingProperty();
     }
 
     @Override
@@ -248,12 +313,15 @@ public class ClientYacht extends Observable {
 
     public void setColour(Color colour) {
         this.colour = colour;
+        for (ColorChangeListener listener : colorChangeListeners) {
+            listener.notifyColorChange(this);
+        }
     }
 
-
     public void updateLocation(double lat, double lng, double heading, double velocity) {
         setLocation(lat, lng);
         this.heading = heading;
+        setHeadingProperty();
         this.currentVelocity = velocity;
         updateVelocityProperty(velocity);
         for (YachtLocationListener yll : locationListeners) {
@@ -261,6 +329,10 @@ public class ClientYacht extends Observable {
         }
     }
 
+    private void setHeadingProperty() {
+        headingProperty.set(heading);
+    }
+
     public void addLocationListener(YachtLocationListener listener) {
         locationListeners.add(listener);
     }
@@ -269,6 +341,18 @@ public class ClientYacht extends Observable {
         markRoundingListeners.add(listener);
     }
 
+    public void addPowerUpListener(PowerUpListener listener) {
+        powerUpListeners.add(listener);
+    }
+
+    public void addPowerDownListener(PowerDownListener listener) {
+        powerDownListeners.add(listener);
+    }
+
+    public void addColorChangeListener(ColorChangeListener listener) {
+        colorChangeListeners.add(listener);
+    }
+
     public void removeMarkRoundingListener(MarkRoundingListener listener) {
         markRoundingListeners.remove(listener);
     }
@@ -289,4 +373,17 @@ public class ClientYacht extends Observable {
     public Double getCurrentVelocity() {
         return currentVelocity;
     }
+
+    public void setBoatObject(BoatObject newBoatObject) {
+        this.boatObject = newBoatObject;
+    }
+
+    public BoatObject getBoatObject() {
+        return this.boatObject;
+    }
+
+    public ReadOnlyDoubleWrapper getHeadingProperty() {
+        return headingProperty;
+    }
+
 }

src/main/java/seng302/model/GameKeyBind.java

@@ -30,7 +30,12 @@ public class GameKeyBind {
         keys.add(KeyCode.ENTER);
         keys.add(KeyCode.PAGE_UP);
         keys.add(KeyCode.PAGE_DOWN);
-        for (int i = 0; i < 7; i++) {
+        keys.add(KeyCode.F1);
+        keys.add(KeyCode.D);
+        keys.add(KeyCode.A);
+        keys.add(KeyCode.W);
+        keys.add(KeyCode.S);
+        for (int i = 0; i < 12; i++) {
             actionToKeyMap.put(KeyAction.getType(i + 1), keys.get(i));
             keyToActionMap.put(keys.get(i), KeyAction.getType(i + 1));
         }
@@ -47,6 +52,10 @@ public class GameKeyBind {
         return instance.actionToKeyMap.get(keyAction);
     }
 
+    public KeyAction getKeyAction(KeyCode keyCode) {
+        return instance.keyToActionMap.get(keyCode);
+    }
+
     /**
      * Binds a key to a key action
      *

src/main/java/seng302/model/KeyAction.java

@@ -10,7 +10,12 @@ public enum KeyAction {
     SAILS_STATE(4),
     TACK_GYBE(5),
     UPWIND(6),
-    DOWNWIND(7);
+    DOWNWIND(7),
+    VIEW(8),
+    RIGHT(9),
+    LEFT(10),
+    FORWARD(11),
+    BACKWARD(12);
 
     private final int type;
     private static final Map<Integer, KeyAction> intToTypeMap = new HashMap<>();

src/main/java/seng302/model/Limit.java

@@ -15,4 +15,9 @@ public class Limit extends GeoPoint {
     public Integer getSeqID() {
         return seqID;
     }
+
+    @Override
+    public String toString(){
+        return "Limit = {seqID=" + seqID + ", lat=" + getLat() + ", lng=" + getLng() + "}";
+    }
 }

src/main/java/seng302/model/PolarTable.java

@@ -4,7 +4,9 @@ import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.Map;
 
 /**
  * A static class for parsing and storing the polars. Will parse the whole polar table and also store the optimised
@@ -17,6 +19,7 @@ public final class PolarTable {
     private static HashMap<Double, HashMap<Double, Double>> polarTable;
     private static HashMap<Double, HashMap<Double, Double>> upwindOptimal;
     private static HashMap<Double, HashMap<Double, Double>> downwindOptimal;
+    private static Double optimalAngle;
 
     private static int upTwaIndex;
     private static int dnTwaIndex;
@@ -33,11 +36,13 @@ public final class PolarTable {
         upwindOptimal = new HashMap<>();
         downwindOptimal = new HashMap<>();
 
-        String line;
+        String line = null;
+        String check;
         Boolean isHeaderLine = true;
 
         try (BufferedReader br = new BufferedReader(new InputStreamReader(polarFile))) {
-            while ((line = br.readLine()) != null) {
+            while ((check = br.readLine()) != null) {
+                line = check;
                 String[] thisLine = line.split(",");
 
                 //Initial line in file
@@ -66,7 +71,10 @@ public final class PolarTable {
                     upwindOptimal.put(thisWindSpeed, thisUpWindPolar);
                     downwindOptimal.put(thisWindSpeed, thisDnWindPolar);
                 }
+
+
             }
+            getMaxSpeedAngle(line);
 
         } catch (IOException e) {
             System.out.println("[PolarTable] IO exception");
@@ -74,6 +82,27 @@ public final class PolarTable {
     }
 
 
+    /**
+     * Passes the final line of the polar table and iterates over the speeds for each
+     * angle, velocity pair to find the angle that produces the highest velocity
+     *
+     * @param line The last line of the polar file
+     */
+    private static void getMaxSpeedAngle(String line) {
+        String[] theLastLine = line.split(",");
+        Double maxWindVal = Double.parseDouble(theLastLine[0]);
+        Double optimalAngle = Double.parseDouble(theLastLine[1]);
+        Double maxSpeed = Double.parseDouble(theLastLine[2]);
+        for (Map.Entry<Double, Double> entry : polarTable.get(maxWindVal).entrySet()) {
+            if (entry.getValue() > maxSpeed) {
+                maxSpeed = entry.getValue();
+                optimalAngle = entry.getKey();
+            }
+        }
+        PolarTable.optimalAngle = optimalAngle;
+    }
+
+
 
     /**
      * Parses the header line of a polar file
@@ -85,14 +114,18 @@ public final class PolarTable {
             String thisItem = thisLine[i];
             if (thisItem.toLowerCase().startsWith("uptwa")) {
                 upTwaIndex = i;
-            }
-            else if (thisItem.toLowerCase().startsWith("dntwa")) {
+            } else if (thisItem.toLowerCase().startsWith("dntwa")) {
                 dnTwaIndex = i;
             }
         }
     }
 
 
+    public static Double getOptimalAngle() {
+        return optimalAngle;
+    }
+
+
     /**
      * @return The entire polar table
      */

src/main/java/seng302/model/ScaledPoint.java

@@ -0,0 +1,122 @@
+package seng302.model;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import javafx.geometry.Point2D;
+import seng302.utilities.GeoUtility;
+
+/**
+ * Contains information on a scaled lat lon point for use with mapping geographical elements to a 2d plane.
+ */
+public class ScaledPoint extends GeoPoint {
+
+    public enum ScaleDirection {
+        HORIZONTAL,
+        VERTICAL
+    }
+
+    private double x, y, scaleFactor;
+    private ScaleDirection scaleDirection;
+
+    private ScaledPoint(double lat, double lng, double x, double y, double scaleFactor, ScaleDirection direction) {
+        super(lat, lng);
+        this.x = x;
+        this.y = y;
+        this.scaleFactor = scaleFactor;
+        this.scaleDirection = direction;
+    }
+
+    public double getX() {
+        return x;
+    }
+
+    public double getY() {
+        return y;
+    }
+
+    public double getScaleFactor() {
+        return scaleFactor;
+    }
+
+    public ScaleDirection getScaleDirection() {
+        return scaleDirection;
+    }
+
+    public Point2D findScaledXY(GeoPoint unscaled) {
+        return findScaledXY(unscaled.getLat(), unscaled.getLng());
+    }
+
+    public Point2D findScaledXY(double unscaledLat, double unscaledLon) {
+        double distanceFromReference;
+        double angleFromReference;
+        double xReference = this.getX();
+        double yReference = this.getY();
+
+        angleFromReference = GeoUtility.getBearingRad(
+            this, new GeoPoint(unscaledLat, unscaledLon)
+        );
+        distanceFromReference = GeoUtility.getDistance(
+            this, new GeoPoint(unscaledLat, unscaledLon)
+        );
+        if (angleFromReference >= 0 && angleFromReference <= Math.PI / 2) {
+            xReference += scaleFactor * Math.sin(angleFromReference) * distanceFromReference;
+            yReference -= scaleFactor * Math.cos(angleFromReference) * distanceFromReference;
+        } else if (angleFromReference >= 0) {
+            angleFromReference = angleFromReference - Math.PI / 2;
+            xReference += scaleFactor * Math.cos(angleFromReference) * distanceFromReference;
+            yReference += scaleFactor * Math.sin(angleFromReference) * distanceFromReference;
+        } else if (angleFromReference < 0 && angleFromReference >= -Math.PI / 2) {
+            angleFromReference = Math.abs(angleFromReference);
+            xReference -= scaleFactor * Math.sin(angleFromReference) * distanceFromReference;
+            yReference -= scaleFactor * Math.cos(angleFromReference) * distanceFromReference;
+        } else {
+            angleFromReference = Math.abs(angleFromReference) - Math.PI / 2;
+            xReference -= scaleFactor * Math.cos(angleFromReference) * distanceFromReference;
+            yReference += scaleFactor * Math.sin(angleFromReference) * distanceFromReference;
+        }
+        return new Point2D(xReference, yReference);
+    }
+
+    public static ScaledPoint makeScaledPoint(double width, double height,
+        List<? extends GeoPoint> points, boolean centered) {
+
+        double referencePointX, referencePointY, scaleFactor, lat, lng;
+        ScaleDirection scaleDirection;
+        points = new ArrayList<>(points);
+        points.sort(Comparator.comparingDouble(GeoPoint::getLat));
+        GeoPoint minLatPoint = points.get(0);
+        GeoPoint maxLatPoint = points.get(points.size() - 1);
+
+        points.sort(Comparator.comparingDouble(GeoPoint::getLng));
+        GeoPoint minLonPoint = points.get(0);
+        GeoPoint maxLonPoint = points.get(points.size() - 1);
+
+        referencePointX = centered ? 0 : width / 2;
+        referencePointY = centered ? 0 : height / 2;
+
+        lat = (maxLatPoint.getLat() - minLatPoint.getLat()) / 2 + minLatPoint.getLat();
+        lng = (maxLonPoint.getLng() - minLonPoint.getLng()) / 2 + minLonPoint.getLng();
+
+        GeoPoint ref = new GeoPoint(lat, lng);
+
+        double vertDistance = GeoUtility.getDistance(
+            ref, new GeoPoint(ref.getLat(), maxLonPoint.getLng())
+        ) * 2.1;
+
+        double horiDistance = GeoUtility.getDistance(
+            ref, new GeoPoint(maxLatPoint.getLat(), ref.getLng())
+        ) * 2.1;
+
+        double vertScale = height / vertDistance;
+
+        if (horiDistance * vertScale > width) {
+            scaleFactor = width / horiDistance;
+            scaleDirection = ScaleDirection.HORIZONTAL;
+        } else {
+            scaleFactor = vertScale;
+            scaleDirection = ScaleDirection.VERTICAL;
+        }
+        return new ScaledPoint(lat, lng, referencePointX, referencePointY, scaleFactor, scaleDirection);
+    }
+}

src/main/java/seng302/model/ServerYacht.java

@@ -23,9 +23,9 @@ public class ServerYacht {
     //Boat info
     private BoatMeshType boatType;
     private Double turnStep = 5.0;
-    private Double maxSpeedMultiplier = 1.0;
-    private Double turnStepMultiplier = 1.0;
-    private Double accelerationMultiplier = 1.0;
+    private Double boatTypeSpeedMultiplier = 1.0;
+    private Double boatTypeTurnStepMultiplier = 1.0;
+    private Double boatTypeAccelerationMultiplier = 1.0;
     private Integer sourceId;
     private String hullID; //matches HullNum in the XML spec.
     private String shortName;
@@ -55,6 +55,8 @@ public class ServerYacht {
     //PowerUp
     private TokenType powerUp;
     private Long powerUpStartTime;
+    private Double powerUpSpeedMultiplier;
+    private Integer powerUpHandlingMultiplier;
 
     //turning mode
     private Boolean continuouslyTurning;
@@ -78,11 +80,11 @@ public class ServerYacht {
         this.legNumber = 0;
         this.boatColor = Colors.getColor(sourceId - 1);
         this.powerUp = null;
-
+        this.powerUpSpeedMultiplier = 1d;
+        this.powerUpHandlingMultiplier = 1;
         this.hasEnteredRoundingZone = false;
         this.hasPassedLine = false;
         this.hasPassedThroughGate = false;
-
         this.continuouslyTurning = false;
     }
 
@@ -110,13 +112,33 @@ public class ServerYacht {
         location = geoPoint;
     }
 
+    /**
+     * Powers up a yacht with a given yacht, only after powering it down first to avoid double power
+     * ups
+     *
+     * @param powerUp The given power up
+     */
     public void powerUp(TokenType powerUp) {
+        powerDown();
+        switch (powerUp) {
+            case BOOST:
+                powerUpSpeedMultiplier = GameState.VELOCITY_BOOST_MULTIPLIER;
+                break;
+            case HANDLING:
+                powerUpHandlingMultiplier = GameState.HANDLING_BOOST_MULTIPLIER;
+                break;
+        }
         this.powerUp = powerUp;
         powerUpStartTime = System.currentTimeMillis();
     }
 
+    /**
+     * Powers down a yacht, returning its power multipliers back to 1
+     */
     public void powerDown() {
         this.powerUp = null;
+        this.powerUpSpeedMultiplier = 1d;
+        this.powerUpHandlingMultiplier = 1;
     }
 
     public Long getPowerUpStartTime() {
@@ -133,7 +155,7 @@ public class ServerYacht {
      * @param amount the amount by which to adjust the boat heading.
      */
     public void adjustHeading(Double amount) {
-        Double newVal = heading + (amount * turnStepMultiplier);
+        Double newVal = heading + amount * powerUpHandlingMultiplier * boatTypeTurnStepMultiplier;
         lastHeading = heading;
         heading = (double) Math.floorMod(newVal.longValue(), 360L);
     }
@@ -156,11 +178,11 @@ public class ServerYacht {
     /**
      * Enables the boats auto pilot feature, which will move the boat towards a given heading.
      *
-     * @param thisHeading The heading to move the boat towards.
+     * @param newHeading The heading to move the boat towards.
      */
-    private void setAutoPilot(Double thisHeading) {
+    private void setAutoPilot(Double newHeading) {
         isAuto = true;
-        autoHeading = thisHeading;
+        autoHeading = newHeading;
     }
 
     /**
@@ -178,8 +200,9 @@ public class ServerYacht {
         if (isAuto) {
             turnTowardsHeading(autoHeading);
             if (Math.abs(heading - autoHeading)
-                <= turnStep) { //Cancel when within 1 turn step of target.
+                <= turnStep*1.5) {
                 isAuto = false;
+                setHeading(autoHeading);
             }
         }
     }
@@ -265,7 +288,7 @@ public class ServerYacht {
 
             // Take optimal heading and turn into a boat heading rather than a wind heading.
             optimalHeading =
-                optimalHeading + GameState.getWindDirection();
+                (optimalHeading + GameState.getWindDirection()) % 360;
 
             setAutoPilot(optimalHeading);
         }
@@ -434,18 +457,18 @@ public class ServerYacht {
     }
 
     public void setBoatType(BoatMeshType boatType) {
-        this.accelerationMultiplier = boatType.accelerationMultiplier;
-        this.maxSpeedMultiplier = boatType.maxSpeedMultiplier;
-        this.turnStepMultiplier = boatType.turnStep;
+        this.boatTypeAccelerationMultiplier = boatType.accelerationMultiplier;
+        this.boatTypeSpeedMultiplier = boatType.maxSpeedMultiplier;
+        this.boatTypeTurnStepMultiplier = boatType.turnStep;
         this.boatType = boatType;
     }
 
-    public Double getMaxSpeedMultiplier() {
-        return maxSpeedMultiplier;
+    public Double getBoatTypeSpeedMultiplier() {
+        return boatTypeSpeedMultiplier;
     }
 
-    public Double getAccelerationMultiplier(){
-        return accelerationMultiplier;
+    public Double getBoatTypeAccelerationMultiplier() {
+        return boatTypeAccelerationMultiplier;
     }
 
 
@@ -456,4 +479,20 @@ public class ServerYacht {
     public void setContinuouslyTurning(Boolean continuouslyTurning) {
         this.continuouslyTurning = continuouslyTurning;
     }
+
+    public Double getPowerUpSpeedMultiplier() {
+        return powerUpSpeedMultiplier;
+    }
+
+    public void setPowerUpSpeedMultiplier(Double powerUpSpeedMultiplier) {
+        this.powerUpSpeedMultiplier = powerUpSpeedMultiplier;
+    }
+
+    public Integer getPowerUpHandlingMultiplier() {
+        return powerUpHandlingMultiplier;
+    }
+
+    public void setPowerUpHandlingMultiplier(Integer powerUpHandlingMultiplier) {
+        this.powerUpHandlingMultiplier = powerUpHandlingMultiplier;
+    }
 }

src/main/java/seng302/model/mark/CompoundMark.java

@@ -1,6 +1,6 @@
 package seng302.model.mark;
 
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import seng302.gameServer.messages.RoundingSide;
 import seng302.model.GeoPoint;
@@ -10,13 +10,13 @@ public class CompoundMark {
 
 	private int compoundMarkId;
 	private String name;
-	private List<Mark> marks = new ArrayList<>();
+	private List<Mark> marks;
     private GeoPoint midPoint;
 
     public CompoundMark(int markID, String name, List<Mark> marks) {
         this.compoundMarkId = markID;
         this.name = name;
-        this.marks.addAll(marks);
+        this.marks = Collections.unmodifiableList(marks);
         if (marks.size() > 1) {
             this.midPoint = GeoUtility.getDirtyMidPoint(marks.get(0), marks.get(1));
         } else {

src/main/java/seng302/model/mark/Corner.java

@@ -32,4 +32,10 @@ public class Corner {
     public Integer getZoneSize() {
         return zoneSize;
     }
+
+    @Override
+    public String toString() {
+        return "Corner = {seqID=" + seqID + ", compoundMarkID=" + compoundMarkID + ", rounding="
+            + rounding +", zoneSize=" + zoneSize + "}";
+    }
 }

src/main/java/seng302/model/mark/MarkOrder.java

@@ -1,34 +1,33 @@
 package seng302.model.mark;
 
-import java.io.IOException;
-import java.io.StringReader;
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.w3c.dom.Document;
-import org.xml.sax.InputSource;
-import org.xml.sax.SAXException;
 import seng302.gameServer.messages.RoundingSide;
-import seng302.model.ServerYacht;
-import seng302.model.stream.xml.generator.RaceXMLTemplate;
 import seng302.model.stream.xml.parser.RaceXMLData;
-import seng302.model.token.Token;
-import seng302.utilities.XMLGenerator;
-import seng302.utilities.XMLParser;
-import java.util.*;
 
 /**
  * Class to hold the order of the marks in the race.
  */
 public class MarkOrder {
     private List<CompoundMark> raceMarkOrder;
+    private List<CompoundMark> orderedUniqueCompoundMarks;
     private Logger logger = LoggerFactory.getLogger(MarkOrder.class);
-    private Set<Mark> allMarks;
+    private List<Mark> allMarks;
 
-    public MarkOrder(){
-        loadRaceProperties();
+
+    public MarkOrder(RaceXMLData raceXMLData){
+        raceMarkOrder = new ArrayList<>();
+        for (Corner corner : raceXMLData.getMarkSequence()){
+            CompoundMark compoundMark = raceXMLData.getCompoundMarks().get(corner.getCompoundMarkID());
+            compoundMark.setRoundingSide(
+                RoundingSide.getRoundingSide(corner.getRounding())
+            );
+            raceMarkOrder.add(compoundMark);
+        }
+        orderedUniqueCompoundMarks = new ArrayList<>(raceXMLData.getCompoundMarks().values());
     }
 
     /**
@@ -40,10 +39,13 @@ public class MarkOrder {
             logger.warn("Race order accessed but not instantiated");
             return null;
         }
-
         return Collections.unmodifiableList(raceMarkOrder);
     }
 
+    public List<CompoundMark> getOrderedUniqueCompoundMarks() {
+        return orderedUniqueCompoundMarks;
+    }
+
     /**
      * @param seqID The seqID of the current mark the boat is heading to
      * @return A Boolean indicating if this coming mark is the last one (finish line)
@@ -74,70 +76,4 @@ public class MarkOrder {
     public CompoundMark getNextMark(Integer currentSeqID) throws IndexOutOfBoundsException {
         return raceMarkOrder.get(currentSeqID + 1);
     }
-
-    public Set<Mark> getAllMarks(){
-        return Collections.unmodifiableSet(allMarks);
-    }
-
-    /**
-     * Loads the race order from an XML string
-     * @param xml An AC35 RaceXML
-     * @return An ordered list of marks in the race
-     */
-    private List<CompoundMark> loadRaceOrderFromXML(String xml) {
-
-        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
-        DocumentBuilder db;
-        Document doc;
-        allMarks = new HashSet<>();
-
-        try {
-            db = dbf.newDocumentBuilder();
-            doc = db.parse(new InputSource(new StringReader(xml)));
-        } catch (ParserConfigurationException | IOException | SAXException e) {
-            logger.error("Failed to read generated race XML");
-            return null;
-        }
-        
-        RaceXMLData data = XMLParser.parseRace(doc);
-
-        if (data != null){
-            logger.debug("Loaded RaceXML for mark order");
-            List<Corner> corners = data.getMarkSequence();
-            Map<Integer, CompoundMark> marks = data.getCompoundMarks();
-            List<CompoundMark> course = new ArrayList<>();
-            for (Corner corner : corners){
-                CompoundMark compoundMark = marks.get(corner.getCompoundMarkID());
-                compoundMark.setRoundingSide(
-                    RoundingSide.getRoundingSide(corner.getRounding())
-                );
-                course.add(compoundMark);
-                allMarks.addAll(compoundMark.getMarks());
-            }
-
-            return course;
-        }
-
-        return null;
-    }
-
-    /**
-     * Load the raceXML and mark order
-     */
-    private void loadRaceProperties(){
-        XMLGenerator generator = new XMLGenerator();
-
-        // TODO: 29/08/17 wmu16 - This is terrible, having to make a template just to receive constant data
-        generator.setRaceTemplate(new RaceXMLTemplate(
-            new ArrayList<>(),
-            new ArrayList<>()));
-
-        String raceXML = generator.getRaceAsXml();
-
-        if (raceXML == null){
-            logger.error("Failed to generate raceXML (for race properties)");
-            return;
-        }
-        raceMarkOrder = loadRaceOrderFromXML(raceXML);
-    }
 }

src/main/java/seng302/model/stream/packets/PacketType.java

@@ -20,7 +20,9 @@ public enum PacketType {
     RACE_REGISTRATION_REQUEST,
     RACE_REGISTRATION_RESPONSE,
     RACE_CUSTOMIZATION_REQUEST,
-    RACE_CUSTOMIZATION_RESPONSE;
+    RACE_CUSTOMIZATION_RESPONSE,
+
+    SERVER_REGISTRATION, ROOM_CODE_REQUEST, LOBBY_REQUEST;
 
     public static PacketType assignPacketType(int packetType, byte[] payload){
         switch(packetType){
@@ -65,6 +67,10 @@ public enum PacketType {
                 return RACE_CUSTOMIZATION_REQUEST;
             case 104:
                 return RACE_CUSTOMIZATION_RESPONSE;
+            case 201:
+                return SERVER_REGISTRATION;
+            case 202:
+                return ROOM_CODE_REQUEST;
             default:
         }
         return OTHER;

src/main/java/seng302/model/stream/xml/generator/RaceXMLTemplate.java

@@ -1,10 +1,12 @@
 package seng302.model.stream.xml.generator;
 
 import java.time.LocalDateTime;
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import seng302.model.Limit;
 import seng302.model.ServerYacht;
+import seng302.model.mark.CompoundMark;
+import seng302.model.mark.Corner;
 import seng302.model.token.Token;
 
 /**
@@ -15,11 +17,22 @@ public class RaceXMLTemplate {
     private List<ServerYacht> yachts;
     private LocalDateTime startTime;
     private List<Token> tokens;
+    private List<Corner> roundings;
+    private List<Limit> courseLimit;
+    private List<CompoundMark> course;
+    private Integer maxPlayers;
+    private Boolean tokensEnabled;
 
-    public RaceXMLTemplate(List<ServerYacht> yachts, List<Token> tokens) {
+    public RaceXMLTemplate(List<ServerYacht> yachts, List<Token> tokens, List<Corner> roundings,
+        List<Limit> limit, List<CompoundMark> course, Integer maxPlayers, Boolean tokensEnabled) {
         this.yachts = yachts;
         this.tokens = tokens;
+        this.roundings = roundings;
+        this.courseLimit = limit;
+        this.course = course;
         startTime = LocalDateTime.now();
+        this.maxPlayers = maxPlayers;
+        this.tokensEnabled = tokensEnabled;
     }
 
     /**
@@ -39,6 +52,18 @@ public class RaceXMLTemplate {
         return Collections.unmodifiableList(tokens);
     }
 
+    public List<CompoundMark> getCompoundMarks() {
+        return Collections.unmodifiableList(course);
+    }
+
+    public List<Limit> getCourseLimit() {
+        return Collections.unmodifiableList(courseLimit);
+    }
+
+    public List<Corner> getRoundings() {
+        return Collections.unmodifiableList(roundings);
+    }
+
     /**
      * Set the time until the race starts
      * @param seconds The time in seconds until the race starts
@@ -54,4 +79,20 @@ public class RaceXMLTemplate {
     public String getRaceStartTime(){
         return startTime.toString();
     }
+
+    public void setBoats(List<ServerYacht> boats) {
+        yachts = boats;
+    }
+
+    public void setTokens(List<Token> tokens) {
+        this.tokens = tokens;
+    }
+
+    public String getTokensEnabled() {
+        return tokensEnabled.toString();
+    }
+
+    public String getMaxPlayers() {
+        return maxPlayers.toString();
+    }
 }

src/main/java/seng302/model/token/Token.java

@@ -1,5 +1,9 @@
 package seng302.model.token;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
 import seng302.model.GeoPoint;
 
 /**
@@ -9,13 +13,50 @@ import seng302.model.GeoPoint;
 public class Token extends GeoPoint {
 
     private TokenType tokenType;
+    private Random random = new Random();
 
+    //Constructor for creating a specific type client side
     public Token(TokenType tokenType, double lat, double lng) {
         super(lat, lng);
         this.tokenType = tokenType;
     }
 
+    //Making random type server side
+    public Token(double lat, double lng) {
+        super(lat, lng);
+        assignRandomType();
+    }
+
+    //Making random type server side
+    public Token(GeoPoint geoPoint) {
+        super(geoPoint.getLat(), geoPoint.getLng());
+        assignRandomType();
+    }
+
     public TokenType getTokenType() {
         return tokenType;
     }
+
+    /**
+     * Assigns a random type to the token (including the random type token)
+     */
+    public void assignRandomType() {
+        tokenType = TokenType.values()[random.nextInt(TokenType.values().length)];
+    }
+
+    /**
+     * Assigns a random, concrete type to the token (cannot be the random type)
+     */
+    public void realiseRandom() {
+        List<TokenType> tokenTypeList = new ArrayList<>(Arrays.asList(TokenType.values()));
+        tokenTypeList.remove(TokenType.RANDOM);
+        tokenType = tokenTypeList.get(random.nextInt(tokenTypeList.size()));
+    }
+
+    /**
+     * Exists for testing purposes only
+     */
+    public void assignType(TokenType tokenType) {
+        this.tokenType = tokenType;
+    }
 }

src/main/java/seng302/model/token/TokenType.java

@@ -5,27 +5,32 @@ package seng302.model.token;
  * Created by wmu16 on 28/08/17.
  */
 public enum TokenType {
-    BOOST(0),
-    HANDLING(1);
+
+    BOOST(0, "Boost", 10_000),
+    HANDLING(1, "Handling", 10_000),
+    BUMPER(2, "Bumper", 10_000),
+    WIND_WALKER(3, "Wind Walker", 10_000),
+    RANDOM(4, "Random", 10_000);
 
     private int value;
+    private String name;
+    private int timeout;
 
-    TokenType(int value) {
+    TokenType(int value, String name, int timeout) {
         this.value = value;
+        this.name = name;
+        this.timeout = timeout;
     }
 
     public int getValue() {
         return value;
     }
 
-    public static TokenType getToken(int value) {
-        switch (value) {
-            case 0:
-                return BOOST;
-            case 1:
-                return HANDLING;
-            default:
-                return BOOST;
-        }
+    public String getName() {
+        return name;
+    }
+
+    public int getTimeout() {
+        return timeout;
     }
 }

src/main/java/seng302/utilities/RandomSpawn.java

@@ -0,0 +1,64 @@
+package seng302.utilities;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Random;
+import seng302.model.GeoPoint;
+import seng302.model.mark.CompoundMark;
+import seng302.model.token.Token;
+
+/**
+ * A class for generating and spawning tokens in random locations
+ * Created by wmu16 on 27/09/17.
+ */
+public class RandomSpawn {
+
+    private static final Integer DEGREES_IN_CIRCLE = 360;
+
+    private HashMap<GeoPoint, Double> spawnRadii;
+    private Object[] spawnCentres;
+    private Random random;
+
+    /**
+     * @param markOrder this must be the ORDERED list of marks. Better yet UNIQUE to avoid over
+     * computation
+     */
+    public RandomSpawn(List<CompoundMark> markOrder) {
+        this.spawnRadii = new HashMap<>();
+        random = new Random();
+
+        spawnRadii = generateSpawnRadii(markOrder);
+        spawnCentres = spawnRadii.keySet().toArray();
+    }
+
+    private HashMap<GeoPoint, Double> generateSpawnRadii(List<CompoundMark> markOrder) {
+        HashMap<GeoPoint, Double> spawnRadii = new HashMap<>();
+        for (int i = 0; i < markOrder.size() - 1; i++) {
+            GeoPoint spawnCentre = GeoUtility.getDirtyMidPoint(
+                markOrder.get(i).getMidPoint(),
+                markOrder.get(i + 1).getMidPoint());
+
+            Double distance = GeoUtility.getDistance(spawnCentre, markOrder.get(i).getMidPoint());
+            spawnRadii.put(spawnCentre, distance);
+        }
+
+        return spawnRadii;
+    }
+
+
+    /**
+     * @return A random token type at a random location in a random radii of the set of possible
+     * radii
+     */
+    public Token getRandomToken() {
+        GeoPoint randomSpawnCentre = (GeoPoint) spawnCentres[random.nextInt(spawnCentres.length)];
+        Double spawnRadius = spawnRadii.get(randomSpawnCentre);
+        Double randomDistance = spawnRadius * random.nextDouble();
+        Double randomAngle = random.nextDouble() * DEGREES_IN_CIRCLE;
+        GeoPoint randomLocation = GeoUtility
+            .getGeoCoordinate(randomSpawnCentre, randomAngle, randomDistance);
+        return new Token(randomLocation);
+
+    }
+
+}

src/main/java/seng302/utilities/Sounds.java

@@ -101,6 +101,10 @@ public class Sounds {
         musicPlayer.setCycleCount(MediaPlayer.INDEFINITE);
         musicPlayer.setVolume(0.3);
         musicPlayer.play();
+        musicPlayer.setMute(musicMuted);
+        if (soundEffect != null) {
+            soundEffect.stop();
+        }
     }
 
 

src/main/java/seng302/utilities/StreamParser.java

@@ -136,7 +136,6 @@ public class StreamParser {
         long messageLength = bytesToLong(Arrays.copyOfRange(payload, 12, 14));
         String xmlMessage = new String(
             (Arrays.copyOfRange(payload, 14, (int) (14 + messageLength)))).trim();
-
         //Create XML document Object
         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
         DocumentBuilder db;

src/main/java/seng302/utilities/XMLGenerator.java

@@ -179,4 +179,8 @@ public class XMLGenerator {
     public RegattaXMLTemplate getRegatta() {
         return regatta;
     }
+
+    public RaceXMLTemplate getRace() {
+        return race;
+    }
 }

src/main/java/seng302/utilities/XMLParser.java

@@ -1,19 +1,31 @@
 package seng302.utilities;
 
+import java.io.IOException;
+import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Random;
 import javafx.scene.paint.Color;
+import javafx.util.Pair;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
 import seng302.model.ClientYacht;
+import seng302.model.Colors;
 import seng302.model.Limit;
 import seng302.model.mark.CompoundMark;
 import seng302.model.mark.Corner;
 import seng302.model.mark.Mark;
+import seng302.model.stream.xml.generator.RaceXMLTemplate;
+import seng302.model.stream.xml.generator.RegattaXMLTemplate;
 import seng302.model.stream.xml.parser.RaceXMLData;
 import seng302.model.stream.xml.parser.RegattaXMLData;
 import seng302.model.token.Token;
@@ -25,6 +37,8 @@ import seng302.visualiser.fxObjects.assets_3D.BoatMeshType;
  */
 public class XMLParser {
 
+    private static final int MAX_PLAYERS = 8;
+
     /**
      * Returns the text content of a given child element tag, assuming it exists, as an Integer.
      *
@@ -35,7 +49,7 @@ public class XMLParser {
     private static Integer getElementInt(Element ele, String tag) {
         NodeList tagList = ele.getElementsByTagName(tag);
         if (tagList.getLength() > 0) {
-            return Integer.parseInt(tagList.item(0).getTextContent());
+            return Integer.parseInt(tagList.item(0).getTextContent().replaceAll("\\s+",""));
         } else {
             return null;
         }
@@ -67,7 +81,7 @@ public class XMLParser {
     private static Double getElementDouble(Element ele, String tag) {
         NodeList tagList = ele.getElementsByTagName(tag);
         if (tagList.getLength() > 0) {
-            return Double.parseDouble(tagList.item(0).getTextContent());
+            return Double.parseDouble(tagList.item(0).getTextContent().replaceAll("\\s+",""));
         } else {
             return null;
         }
@@ -139,14 +153,26 @@ public class XMLParser {
             Node currentBoat = boatsList.item(i);
             if (currentBoat.getNodeName().equals("Boat")) {
 //                    Boat boat = new Boat(currentBoat);
+                BoatMeshType boatMeshType;
+                try {
+                    boatMeshType = BoatMeshType.valueOf(XMLParser.getNodeAttributeString(currentBoat, "Type"));
+                } catch (IllegalArgumentException e){
+                    boatMeshType = BoatMeshType.DINGHY;
+                }
+                Color color;
+                try {
+                    color = Color.web(getNodeAttributeString(currentBoat, "Color"));
+                } catch (NullPointerException npe) {
+                    color = Colors.getColor(new Random().nextInt(8));
+                }
                 ClientYacht yacht = new ClientYacht(
-                    BoatMeshType.valueOf(XMLParser.getNodeAttributeString(currentBoat, "Type")),
+                    boatMeshType,
                     XMLParser.getNodeAttributeInt(currentBoat, "SourceID"),
                     XMLParser.getNodeAttributeString(currentBoat, "HullNum"),
                     XMLParser.getNodeAttributeString(currentBoat, "ShortName"),
                     XMLParser.getNodeAttributeString(currentBoat, "BoatName"),
                     XMLParser.getNodeAttributeString(currentBoat, "Country"));
-                yacht.setColour(Color.web(getNodeAttributeString(currentBoat, "Color")));
+                yacht.setColour(color);
                 competingBoats.put(yacht.getSourceId(), yacht);
             }
         }
@@ -173,6 +199,36 @@ public class XMLParser {
         );
     }
 
+    public static Boolean tokensEnabled(Document doc) {
+        Element docEle = doc.getDocumentElement();
+        try {
+            NamedNodeMap namedNodeMap = docEle.getElementsByTagName("Tokens").item(0).getAttributes();
+            Node node = namedNodeMap.getNamedItem("Enabled");
+            if (node != null) {
+                return Boolean.parseBoolean(node.getNodeValue());
+            }
+        } catch (NullPointerException npe) {
+            npe.printStackTrace();
+            return false;
+        }
+        return false;
+    }
+
+    public static Integer getMaxPlayers(Document doc) {
+        Element docEle = doc.getDocumentElement();
+        try {
+            NamedNodeMap namedNodeMap = docEle.getElementsByTagName("Participants").item(0).getAttributes();
+            Node node = namedNodeMap.getNamedItem("MaxPlayers");
+            if (node != null) {
+                return Integer.parseInt(node.getNodeValue());
+            }
+        } catch (NullPointerException npe) {
+            npe.printStackTrace();
+            return MAX_PLAYERS;
+        }
+        return MAX_PLAYERS;
+    }
+
     /**
      * Returns an object containing the data extracted from the given xml formatted document
      *
@@ -182,7 +238,7 @@ public class XMLParser {
     public static RaceXMLData parseRace(Document doc) {
         Element docEle = doc.getDocumentElement();
         return new RaceXMLData(
-            extractParticpantIDs(docEle),
+            extractParticipantIDs(docEle),
             extractTokens(docEle),
             extractCompoundMarks(docEle),
             extractMarkOrder(docEle),
@@ -195,17 +251,20 @@ public class XMLParser {
      */
     private static List<Token> extractTokens(Element docEle) {
         List<Token> tokens = new ArrayList<>();
-        NodeList tokenList = docEle.getElementsByTagName("Tokens").item(0).getChildNodes();
-        for (int i = 0; i < tokenList.getLength(); i++) {
-            Node tokenNode = tokenList.item(i);
-            if (tokenNode.getNodeName().equals("Token")) {
-                String tokenType = getNodeAttributeString(tokenNode, "TokenType");
-                Double lat = getNodeAttributeDouble(tokenNode, "TargetLat");
-                Double lng = getNodeAttributeDouble(tokenNode, "TargetLng");
-                tokens.add(new Token(TokenType.valueOf(tokenType), lat, lng));
+        try {
+            NodeList tokenList = docEle.getElementsByTagName("Tokens").item(0).getChildNodes();
+            for (int i = 0; i < tokenList.getLength(); i++) {
+                Node tokenNode = tokenList.item(i);
+                if (tokenNode.getNodeName().equals("Token")) {
+                    String tokenType = getNodeAttributeString(tokenNode, "TokenType");
+                    Double lat = getNodeAttributeDouble(tokenNode, "TargetLat");
+                    Double lng = getNodeAttributeDouble(tokenNode, "TargetLng");
+                    tokens.add(new Token(TokenType.valueOf(tokenType), lat, lng));
+                }
             }
+        } catch (NullPointerException npe) {
+            return new ArrayList<>();
         }
-
         return tokens;
     }
 
@@ -218,13 +277,11 @@ public class XMLParser {
         for (int i = 0; i < limitList.getLength(); i++) {
             Node limitNode = limitList.item(i);
             if (limitNode.getNodeName().equals("Limit")) {
-                courseLimit.add(
-                    new Limit(
-                        XMLParser.getNodeAttributeInt(limitNode, "SeqID"),
-                        XMLParser.getNodeAttributeDouble(limitNode, "Lat"),
-                        XMLParser.getNodeAttributeDouble(limitNode, "Lon")
-                    )
-                );
+                courseLimit.add(new Limit(
+                    XMLParser.getNodeAttributeInt(limitNode, "SeqID"),
+                    XMLParser.getNodeAttributeDouble(limitNode, "Lat"),
+                    XMLParser.getNodeAttributeDouble(limitNode, "Lon")
+                ));
             }
         }
         return courseLimit;
@@ -256,7 +313,7 @@ public class XMLParser {
     /**
      * Extracts course participants data
      */
-    private static List<Integer> extractParticpantIDs (Element docEle) {
+    private static List<Integer> extractParticipantIDs(Element docEle) {
         List<Integer> boatIDs = new ArrayList<>();
         NodeList pList = docEle.getElementsByTagName("Participants").item(0).getChildNodes();
         for (int i = 0; i < pList.getLength(); i++) {
@@ -278,10 +335,11 @@ public class XMLParser {
         for (int i = 0; i < cMarkList.getLength(); i++) {
             Node cMarkNode = cMarkList.item(i);
             if (cMarkNode.getNodeName().equals("CompoundMark")) {
+                String name = XMLParser.getNodeAttributeString(cMarkNode, "Name");
+                name = (name == null || name.equals("")) ? "Mark " + i+1: name;
                 cMark = new CompoundMark(
                     XMLParser.getNodeAttributeInt(cMarkNode, "CompoundMarkID"),
-                    XMLParser.getNodeAttributeString(cMarkNode, "Name"),
-                    createMarks(cMarkNode)
+                    name, createMarks(cMarkNode)
                 );
                 allMarks.add(cMark);
             }
@@ -302,14 +360,169 @@ public class XMLParser {
             Node markNode = childMarks.item(i);
             if (markNode.getNodeName().equals("Mark")) {
                 Integer seqID = XMLParser.getNodeAttributeInt(markNode, "SeqID");
+                seqID = (seqID == null) ? i+1 : seqID;
+
                 Integer sourceID = XMLParser.getNodeAttributeInt(markNode, "SourceID");
+                sourceID = (sourceID == null) ? i+1 : sourceID;
+
                 String markName = XMLParser.getNodeAttributeString(markNode, "Name");
+                markName = (markName == null || markName.equals("")) ? cMarkName + " " + i+1: markName;
+
                 Double targetLat = XMLParser.getNodeAttributeDouble(markNode, "TargetLat");
                 Double targetLng = XMLParser.getNodeAttributeDouble(markNode, "TargetLng");
+
                 Mark mark = new Mark(markName, seqID, targetLat, targetLng, sourceID);
                 subMarks.add(mark);
             }
         }
         return subMarks;
     }
+
+    /**
+     * This ungodly combination of existing methods and code blocks parses a race definition file.
+     * Look upon it and despair.
+     * @param url The input file path
+     * @param serverName the name of the server
+     * @param repetitions the repetitions of a segment of the race def file.
+     * @param maxPlayers max number of players. uses the default race max if null or greater than the actual max.
+     * @param tokensEnabled if tokens are enabled
+     * @return a pair which contains regatta string, race string as key, value pair.
+     */
+    public static Pair<RegattaXMLTemplate, RaceXMLTemplate> parseRaceDef(
+            String url, String serverName, Integer repetitions, Integer maxPlayers, Boolean tokensEnabled
+    ) {
+        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+        DocumentBuilder db;
+        Document doc = null;
+        try {
+            db = dbf.newDocumentBuilder();
+            doc = db.parse(XMLParser.class.getResourceAsStream(url));
+        } catch (ParserConfigurationException | IOException | SAXException e) {
+            e.printStackTrace();
+        }
+        Element docEle = doc.getDocumentElement();
+
+        RegattaXMLTemplate regattaXMLTemplate = new RegattaXMLTemplate(
+            serverName, XMLParser.getElementString(docEle, "CourseName"),
+            XMLParser.getElementDouble(docEle, "CentralLat"),
+            XMLParser.getElementDouble(docEle, "CentralLng")
+        );
+
+        XMLGenerator xmlGenerator = new XMLGenerator();
+        xmlGenerator.setRegattaTemplate(regattaXMLTemplate);
+
+        if (maxPlayers == null) {
+            maxPlayers = XMLParser.getElementInt(docEle, "MaxPlayers");
+        } else if (maxPlayers > XMLParser.getElementInt(docEle, "MaxPlayers")) {
+            maxPlayers = XMLParser.getElementInt(docEle, "MaxPlayers");
+        }
+
+        RaceXMLTemplate raceXMLTemplate = new RaceXMLTemplate(
+            new ArrayList<>(), new ArrayList<>(),
+            XMLParser.extractMarkOrderRaceDef(docEle, repetitions),
+            XMLParser.extractCourseLimitRaceDef(docEle),
+            XMLParser.extractCompoundMarksRaceDef(docEle),
+            maxPlayers, tokensEnabled
+        );
+        xmlGenerator.setRaceTemplate(raceXMLTemplate);
+        return new Pair<>(regattaXMLTemplate, raceXMLTemplate);
+    }
+
+    private static List<Corner> extractMarkOrderRaceDef(Element docEle, int repitions){
+        List<Corner> compoundMarkSequence = new ArrayList<>();
+        NodeList cornerList = docEle.getElementsByTagName("Course").item(0).getChildNodes();
+
+        int seqId = 1;
+        final int zoneSize = 3;
+
+        for (int i=0; i<cornerList.getLength(); i++) {
+            Node segment = cornerList.item(i);
+            if (segment.getNodeName().equals("OpeningSegment") ||
+                segment.getNodeName().equals("ClosingSegment")) {
+
+                seqId = parseCourseSegment(segment, seqId, compoundMarkSequence);
+
+            } else if (segment.getNodeName().equals("RepeatingSegment")) {
+                for (int k = 0; k < repitions; k++) {
+                    seqId = parseCourseSegment(segment, seqId, compoundMarkSequence);
+                }
+            }
+        }
+        return compoundMarkSequence;
+    }
+
+    /**
+     * Parses a segment of the course adding new Corners to the given list.
+     * @param segment Segment to parse
+     * @param seqID initial sequence ID
+     * @param course course to add corners to
+     * @return the last sequence id.
+     */
+    private static int parseCourseSegment(Node segment, int seqID, List<Corner> course) {
+        NodeList segmentList = segment.getChildNodes();
+        for (int j = 0; j < segmentList.getLength(); j++) {
+            Node corner = segmentList.item(j);
+            if (corner.getNodeName().equals("Corner")) {
+                String rounding = XMLParser.getNodeAttributeString(corner, "Rounding");
+                rounding = //Converting "P" to "Port" and "S" to "Stbd"
+                    rounding.equals("P") ? "Port" :
+                    rounding.equals("S") ? "Stbd" : rounding;
+                course.add(new Corner(
+                    seqID++, XMLParser.getNodeAttributeInt(corner, "CompoundMarkID"),
+                    rounding, 3
+                ));
+            }
+        }
+        return seqID;
+    }
+
+    private static List<Limit> extractCourseLimitRaceDef(Element docEle) {
+        List<Limit> courseLimit = new ArrayList<>();
+        NodeList limitList = docEle.getElementsByTagName("CourseLimit").item(0).getChildNodes();
+        int seqId = 1;
+        for (int i = 0; i < limitList.getLength(); i++) {
+            Node limitNode = limitList.item(i);
+            if (limitNode.getNodeName().equals("Limit")) {
+                courseLimit.add(new Limit(
+                    seqId++, XMLParser.getNodeAttributeDouble(limitNode, "Lat"),
+                    XMLParser.getNodeAttributeDouble(limitNode, "Lng")
+                ));
+            }
+        }
+        return courseLimit;
+    }
+
+    private static List<CompoundMark> extractCompoundMarksRaceDef(Element docEle){
+        List<CompoundMark> allMarks = new ArrayList<>();
+        NodeList cMarkList = docEle.getElementsByTagName("Marks").item(0).getChildNodes();
+        CompoundMark cMark;
+        int markCount = 200;
+        for (int i = 0; i < cMarkList.getLength(); i++) {
+            Node cMarkNode = cMarkList.item(i);
+            if (cMarkNode.getNodeName().equals("CompoundMark")) {
+                Integer id = XMLParser.getNodeAttributeInt(cMarkNode, "CompoundMarkID");
+                List<Mark> subMarks = createMarksRaceDef(cMarkNode, markCount,"Mark " + id);
+                markCount += subMarks.size();
+                allMarks.add(new CompoundMark(id, "Mark " + id, subMarks));
+            }
+        }
+        return allMarks;
+    }
+
+    private static List<Mark> createMarksRaceDef(Node compoundMark, int markCount, String markName) {
+        List<Mark> subMarks = new ArrayList<>();
+        NodeList childMarks = compoundMark.getChildNodes();
+        int seqID = 1;
+        for (int i = 0; i < childMarks.getLength(); i++) {
+            Node markNode = childMarks.item(i);
+            if (markNode.getNodeName().equals("Mark")) {
+                Double targetLat = XMLParser.getNodeAttributeDouble(markNode, "Lat");
+                Double targetLng = XMLParser.getNodeAttributeDouble(markNode, "Lng");
+                Mark mark = new Mark(markName + " subMark " + seqID, seqID, targetLat, targetLng, markCount++);
+                subMarks.add(mark);
+                seqID += 1;
+            }
+        }
+        return subMarks;
+    }
 }

src/main/java/seng302/visualiser/ClientToServerThread.java

@@ -1,5 +1,14 @@
 package seng302.visualiser;
 
+import javafx.application.Platform;
+import javafx.util.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import seng302.gameServer.messages.*;
+import seng302.model.stream.packets.PacketType;
+import seng302.model.stream.packets.StreamPacket;
+import seng302.utilities.XMLParser;
+
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -14,6 +23,7 @@ import java.util.TimerTask;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.zip.CRC32;
 import java.util.zip.Checksum;
+import javafx.util.Pair;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import seng302.gameServer.messages.BoatAction;
@@ -25,8 +35,15 @@ import seng302.gameServer.messages.CustomizeRequestType;
 import seng302.gameServer.messages.Message;
 import seng302.gameServer.messages.RegistrationRequestMessage;
 import seng302.gameServer.messages.RegistrationResponseStatus;
+import seng302.gameServer.messages.XMLMessage;
+import seng302.gameServer.messages.XMLMessageSubType;
 import seng302.model.stream.packets.PacketType;
 import seng302.model.stream.packets.StreamPacket;
+import seng302.model.stream.xml.generator.RaceXMLTemplate;
+import seng302.model.stream.xml.generator.RegattaXMLTemplate;
+import seng302.utilities.XMLGenerator;
+import seng302.utilities.XMLParser;
+import seng302.visualiser.controllers.ViewManager;
 
 /**
  * A class describing a single connection to a Server for the purposes of sending and receiving on
@@ -34,6 +51,8 @@ import seng302.model.stream.packets.StreamPacket;
  */
 public class ClientToServerThread implements Runnable {
 
+    private boolean isStarted = false;
+
     /**
      * Functional interface for receiving packets from client socket.
      */
@@ -44,7 +63,12 @@ public class ClientToServerThread implements Runnable {
 
     @FunctionalInterface
     public interface DisconnectedFromHostListener {
-        void notifYDisconnection (String message);
+        void notifyDisconnection(String message);
+    }
+
+    @FunctionalInterface
+    public interface ConnectionErrorListener {
+        void notifyConnectionError(String message);
     }
 
     private class ByteReadException extends Exception {
@@ -56,6 +80,7 @@ public class ClientToServerThread implements Runnable {
     private Queue<StreamPacket> streamPackets = new ConcurrentLinkedQueue<>();
     private List<ClientSocketListener> listeners = new ArrayList<>();
     private List<DisconnectedFromHostListener> disconnectionListeners = new ArrayList<>();
+    private ConnectionErrorListener connectionErrorListener = null;
     private Thread thread;
 
     private Socket socket;
@@ -68,7 +93,7 @@ public class ClientToServerThread implements Runnable {
     private Timer upWindPacketTimer = new Timer();
     private Timer downWindPacketTimer = new Timer();
     private boolean upwindTimerFlag = false, downwindTimerFlag = false;
-    static public final int PACKET_SENDING_INTERVAL_MS = 100;
+    public static final int PACKET_SENDING_INTERVAL_MS = 100;
 
     private int clientId = -1;
 
@@ -103,6 +128,8 @@ public class ClientToServerThread implements Runnable {
      * variable is false.
      */
     public void run() {
+        isStarted = true;
+
         int sync1;
         int sync2;
         // TODO: 14/07/17 wmu16 - Work out how to fix this while loop
@@ -133,8 +160,10 @@ public class ClientToServerThread implements Runnable {
                             else {
                                 if (clientId == -1) continue; // Do not continue if not registered
                                 streamPackets.add(new StreamPacket(type, payloadLength, timeStamp, payload));
-                                for (ClientSocketListener csl : listeners)
-                                    csl.newPacket();
+                                synchronized (this) {
+                                    for (ClientSocketListener csl : listeners)
+                                        csl.newPacket();
+                                }
                             }
                         }
                     } else {
@@ -150,6 +179,11 @@ public class ClientToServerThread implements Runnable {
         logger.warn("Closed connection to server", 1);
         notifyDisconnectListeners("Connection to server was terminated");
         closeSocket();
+
+        Platform.runLater(() -> {
+            ViewManager.getInstance().showErrorSnackBar("Server rejected connection.");
+            ViewManager.getInstance().goToStartView();
+        });
     }
 
     public void sendCustomizationRequest(CustomizeRequestType reqType, byte[] payload) {
@@ -166,16 +200,22 @@ public class ClientToServerThread implements Runnable {
     private void notifyDisconnectListeners (String message) {
         if (socketOpen) {
             for (DisconnectedFromHostListener listener : disconnectionListeners) {
-                listener.notifYDisconnection(message);
+                listener.notifyDisconnection(message);
             }
         }
     }
 
+    private void handleConnectionError(String message){
+        if (connectionErrorListener != null){
+            connectionErrorListener.notifyConnectionError(message);
+        }
+    }
+
     /**
      * Sends a request to the server asking for a source ID
      */
     private void sendRegistrationRequest() {
-        RegistrationRequestMessage requestMessage = new RegistrationRequestMessage(ClientType.PLAYER);
+        RegistrationRequestMessage requestMessage = new RegistrationRequestMessage(ClientType.PLAYER, clientId);
 
         try {
             os.write(requestMessage.getBuffer());
@@ -191,9 +231,8 @@ public class ClientToServerThread implements Runnable {
      * @param packet The registration requests packet
      */
     private void processRegistrationResponse(StreamPacket packet){
-        int sourceId = (int) Message.bytesToLong(Arrays.copyOfRange(packet.getPayload(), 0, 3));
+        int sourceId = (int) Message.bytesToLong(Arrays.copyOfRange(packet.getPayload(), 0, 4));
         int statusCode = (int) Message.bytesToLong(Arrays.copyOfRange(packet.getPayload(), 4,5));
-
         RegistrationResponseStatus status = RegistrationResponseStatus.getResponseStatus(statusCode);
 
         if (status.equals(RegistrationResponseStatus.SUCCESS_PLAYING)){
@@ -211,8 +250,10 @@ public class ClientToServerThread implements Runnable {
         else{
             alertErrorText = "Could not connect to server";
         }
+        handleConnectionError("Server no longer available.");
         notifyDisconnectListeners(alertErrorText);
-        closeSocket();
+
+        System.out.println();
     }
 
     /**
@@ -243,7 +284,7 @@ public class ClientToServerThread implements Runnable {
                         new TimerTask() {
                             @Override
                             public void run() {
-                                sendBoatActionMessage(new BoatActionMessage(BoatAction.DOWNWIND));
+                                sendBoatActionMessage(new BoatActionMessage(BoatAction.DOWNWIND, clientId));
                             }
                         }, 0, PACKET_SENDING_INTERVAL_MS
                     );
@@ -256,14 +297,14 @@ public class ClientToServerThread implements Runnable {
                         new TimerTask() {
                             @Override
                             public void run() {
-                                sendBoatActionMessage(new BoatActionMessage(BoatAction.UPWIND));
+                                sendBoatActionMessage(new BoatActionMessage(BoatAction.UPWIND, clientId));
                             }
                         }, 0, PACKET_SENDING_INTERVAL_MS
                     );
                 }
                 break;
             default:
-                sendBoatActionMessage(new BoatActionMessage(actionType));
+                sendBoatActionMessage(new BoatActionMessage(actionType, clientId));
                 break;
         }
     }
@@ -319,7 +360,9 @@ public class ClientToServerThread implements Runnable {
     }
 
     public void addStreamObserver (ClientSocketListener streamListener) {
-        listeners.add(streamListener);
+        synchronized (this){
+            listeners.add(streamListener);
+        }
     }
 
     public void removeStreamObserver (ClientSocketListener streamListener) {
@@ -327,11 +370,21 @@ public class ClientToServerThread implements Runnable {
     }
 
     public void addDisconnectionListener (DisconnectedFromHostListener listener) {
-        disconnectionListeners.add(listener);
+        synchronized (this){
+            disconnectionListeners.add(listener);
+        }
     }
 
     public void removeDisconnectionListener (DisconnectedFromHostListener listener) {
-        disconnectionListeners.remove(listener);
+        synchronized (this){
+            disconnectionListeners.remove(listener);
+        }
+    }
+
+    public void setConnectionErrorListener(ConnectionErrorListener listener){
+        synchronized (this){
+            connectionErrorListener = listener;
+        }
     }
 
     private int readByte() throws ByteReadException {
@@ -346,8 +399,9 @@ public class ClientToServerThread implements Runnable {
         }
         if (currentByte == -1) {
             notifyDisconnectListeners("Cannot read from server.");
-            closeSocket();
             logger.warn("InputStream reach end of stream", 1);
+            handleConnectionError("Could not connect to server. Server is no longer available.");
+            closeSocket();
         }
         return currentByte;
     }
@@ -369,4 +423,29 @@ public class ClientToServerThread implements Runnable {
     public int getClientId () {
         return clientId;
     }
+
+    public void sendXML(String path, String serverName, Integer legRepeats, Integer maxPlayers, Boolean tokensEnabled) {
+        Pair<RegattaXMLTemplate, RaceXMLTemplate> regattaRace = XMLParser.parseRaceDef(
+            path, serverName, legRepeats, maxPlayers, tokensEnabled
+        );
+        XMLGenerator xmlGenerator = new XMLGenerator();
+        xmlGenerator.setRegattaTemplate(regattaRace.getKey());
+        xmlGenerator.setRaceTemplate(regattaRace.getValue());
+        String regatta = xmlGenerator.getRegattaAsXml();
+        String race = xmlGenerator.getRaceAsXml();
+        sendByteBuffer(
+            new XMLMessage(
+                regatta, XMLMessageSubType.REGATTA, regatta.length()
+            ).getBuffer()
+        );
+        sendByteBuffer(
+            new XMLMessage(
+                race, XMLMessageSubType.RACE, race.length()
+            ).getBuffer()
+        );
+    }
+
+    public boolean hasStarted() {
+        return isStarted;
+    }
 }

src/main/java/seng302/visualiser/GameClient.java

@@ -10,15 +10,15 @@ import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.TimeZone;
+import java.util.Timer;
+import java.util.TimerTask;
 import javafx.application.Platform;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
-import javafx.fxml.FXMLLoader;
-import javafx.scene.control.Alert;
-import javafx.scene.control.Alert.AlertType;
 import javafx.scene.input.KeyCode;
 import javafx.scene.input.KeyEvent;
 import javafx.scene.layout.Pane;
+import javafx.scene.paint.Color;
 import javafx.util.Pair;
 import seng302.gameServer.GameStages;
 import seng302.gameServer.GameState;
@@ -39,6 +39,7 @@ import seng302.model.stream.parser.RaceStatusData;
 import seng302.model.stream.parser.YachtEventData;
 import seng302.model.stream.xml.parser.RaceXMLData;
 import seng302.model.stream.xml.parser.RegattaXMLData;
+import seng302.model.token.TokenType;
 import seng302.utilities.Sounds;
 import seng302.utilities.StreamParser;
 import seng302.utilities.XMLGenerator;
@@ -46,6 +47,13 @@ import seng302.utilities.XMLParser;
 import seng302.visualiser.controllers.LobbyController;
 import seng302.visualiser.controllers.RaceViewController;
 import seng302.visualiser.controllers.ViewManager;
+import seng302.visualiser.controllers.dialogs.PopupDialogController;
+
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.util.*;
 
 /**
  * This class is a client side instance of a yacht racing game in JavaFX. The game is instantiated
@@ -93,7 +101,6 @@ public class GameClient {
             socketThread.addDisconnectionListener((cause) -> {
                 showConnectionError(cause);
                 tearDownConnection();
-                Platform.runLater(this::loadStartScreen);
             });
             socketThread.addStreamObserver(this::parsePackets);
 
@@ -110,36 +117,75 @@ public class GameClient {
             ViewManager.getInstance().setProperty("serverName", regattaData.getRegattaName());
             ViewManager.getInstance().setProperty("mapName", regattaData.getCourseName());
 
+            getServerThread().setConnectionErrorListener((eMessage) -> {
+                ViewManager.getInstance().showErrorSnackBar(eMessage);
+                //destroyClientToServerThread();
+            });
+
             this.lobbyController = ViewManager.getInstance().goToLobby(true);
 
         } catch (IOException ioe) {
-            showConnectionError("Unable to find server");
+            ViewManager.getInstance().showErrorSnackBar("There are no servers currently available.");
         }
     }
 
+    private void destroyClientToServerThread() {
+        socketThread.closeSocket();
+        socketThread = null;
+    }
+
     /**
      * Connect to a game as the host at the given address and starts the visualiser.
      * @param ipAddress IP to connect to.
      * @param portNumber Port to connect to.
      */
-    public ServerDescription runAsHost(String ipAddress, Integer portNumber, String serverName, Integer maxPlayers) {
+    public ServerDescription runAsHost(
+        String ipAddress, Integer portNumber, String serverName, Integer maxPlayers, String race,
+        Integer numLegs, Boolean tokensEnabled
+    ) {
         XMLGenerator.setDefaultRaceName(serverName);
-        GameState.setMaxPlayers(maxPlayers);
 
         server = new MainServerThread();
 
+        while (!server.hasStarted()){
+            try {
+                Thread.sleep(10);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
         try {
             startClientToServerThread(ipAddress, 4942);
         } catch (IOException e) {
             showConnectionError("Cannot connect to server as host");
         }
 
-        while (regattaData == null){
+        // Wait for C2S thread
+        while (!socketThread.hasStarted()){
+            try {
+                Thread.sleep(10);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+        socketThread.sendXML(race, serverName, numLegs, maxPlayers, tokensEnabled);
+
+        int triesLeft = 15;
+
+        while (regattaData == null && triesLeft > 0){
             try {
                 Thread.sleep(100);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
+            triesLeft--;
+        }
+
+        if (triesLeft <= 0){
+            showConnectionError("Could not launch server");
+            return null;
         }
 
         this.lobbyController = ViewManager.getInstance().goToLobby(false);
@@ -156,23 +202,15 @@ public class GameClient {
         }
     }
 
-    private void loadStartScreen() {
-        FXMLLoader fxmlLoader = new FXMLLoader(
-            getClass().getResource("/views/StartScreenView.fxml"));
-        try {
-            holderPane.getChildren().clear();
-            holderPane.getChildren().add(fxmlLoader.load());
-        } catch (IOException e) {
-            showConnectionError("JavaFX crashed. Please restart the app");
-        }
-    }
 
     private void showConnectionError (String message) {
         Platform.runLater(() -> {
-            Alert alert = new Alert(AlertType.ERROR);
-            alert.setHeaderText("Connection Error");
-            alert.setContentText(message);
-            alert.showAndWait();
+            PopupDialogController controller = ViewManager.getInstance().showPopupDialog();
+            controller.setHeader("Oops");
+            controller.setContent(message);
+            controller.setOptionButtonText("GO HOME");
+            controller
+                .setOptionButtonEventHandler(event -> ViewManager.getInstance().goToStartView());
         });
     }
 
@@ -250,12 +288,7 @@ public class GameClient {
                     break;
 
                 case YACHT_EVENT_CODE:
-                    YachtEventData yachtEventData = StreamParser.extractYachtEventCode(packet);
-                    if (yachtEventData.getEventId() == YachtEventType.COLLISION.getCode()) {
-                        showCollisionAlert(StreamParser.extractYachtEventCode(packet));
-                    } else if (yachtEventData.getEventId() == YachtEventType.TOKEN.getCode()) {
-                        showPickUp();
-                    }
+                    processYachtEvent(StreamParser.extractYachtEventCode(packet));
                     break;
 
                 case CHATTER_TEXT:
@@ -275,12 +308,13 @@ public class GameClient {
 
             ClientYacht player = allBoatsMap.get(socketThread.getClientId());
             raceView.loadRace(allBoatsMap, courseData, raceState, player);
-
+            raceView.showView();
             raceView.getSendPressedProperty().addListener((obs, old, isPressed) -> {
                 if (isPressed) {
                     formatAndSendChatMessage(raceView.readChatInput());
                 }
             });
+            sendToggleTurningModePacket(); // notify the server about player's steering mode
         }
     }
 
@@ -398,7 +432,11 @@ public class GameClient {
         }
 
         if (gameKeyBind.getKeyCode(KeyAction.SAILS_STATE) == e.getCode()) {  // sails in/sails out
-            socketThread.sendBoatAction(BoatAction.SAILS_IN);
+            if (allBoatsMap.get(socketThread.getClientId()).getSailIn()) {
+                socketThread.sendBoatAction(BoatAction.SAILS_OUT);
+            } else {
+                socketThread.sendBoatAction(BoatAction.SAILS_IN);
+            }
             allBoatsMap.get(socketThread.getClientId()).toggleSail();
         } else if (gameKeyBind.getKeyCode(KeyAction.UPWIND) == e.getCode()
             || gameKeyBind.getKeyCode(KeyAction.DOWNWIND) == e.getCode()) {
@@ -410,21 +448,66 @@ public class GameClient {
         return courseData;
     }
 
+
+    /**
+     * Appropriately displays the event client side given the YachtEventCode (collision / token..)
+     *
+     * @param yachtEventData The YachtEvent data packet
+     */
+    private void processYachtEvent(YachtEventData yachtEventData) {
+        ClientYacht thisYacht = allBoatsMap.get(yachtEventData.getSubjectId().intValue());
+
+        if (yachtEventData.getEventId() == YachtEventType.COLLISION.getCode()) {
+            showCollisionAlert(thisYacht);
+        } else if (yachtEventData.getEventId() == YachtEventType.POWER_DOWN.getCode()) {
+            thisYacht.powerDown();
+            Sounds.playTokenPickupSound();  // TODO: 23/09/17 This should be power down sound
+        } else if (yachtEventData.getEventId() == YachtEventType.BUMPER_CRASH.getCode()) {
+            showDisableAlert(thisYacht);
+        } else {        //Else all token pickup types
+            TokenType tokenType = null;
+            if (yachtEventData.getEventId() == YachtEventType.TOKEN_VELOCITY.getCode()) {
+                tokenType = TokenType.BOOST;
+            } else if (yachtEventData.getEventId() == YachtEventType.TOKEN_BUMPER.getCode()) {
+                tokenType = TokenType.BUMPER;
+            } else if (yachtEventData.getEventId() == YachtEventType.TOKEN_HANDLING.getCode()) {
+                tokenType = TokenType.HANDLING;
+            } else if (yachtEventData.getEventId() == YachtEventType.TOKEN_RANDOM.getCode()) {
+                tokenType = TokenType.RANDOM;
+            } else if (yachtEventData.getEventId() == YachtEventType.TOKEN_WIND_WALKER.getCode()) {
+                tokenType = TokenType.WIND_WALKER;
+            }
+
+            Sounds.playTokenPickupSound();
+            thisYacht.setPowerUp(tokenType);
+        }
+    }
+
+
+    /**
+     * Turns a disabled boat black until the bumper affect wears off
+     *
+     * @param yacht The yacht to show as disabled
+     */
+    private void showDisableAlert(ClientYacht yacht) {
+        Color originalColor = yacht.getColour();
+        yacht.setColour(Color.BLACK);
+
+        Timer disableTimer = new Timer("Disable Timer");
+        disableTimer.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                yacht.setColour(originalColor);
+            }
+        }, GameState.BUMPER_DISABLE_TIME);
+    }
+
     /**
      * Tells race view to show a collision animation.
      */
-    private void showCollisionAlert(YachtEventData yachtEventData) {
+    private void showCollisionAlert(ClientYacht yacht) {
         Sounds.playCrashSound();
-        raceState.storeCollision(
-            allBoatsMap.get(
-                yachtEventData.getSubjectId().intValue()
-            )
-        );
-    }
-
-    // TODO: 11/09/17 wmu16 - Add in functionality to viually indicate a pickup to a user
-    private void showPickUp() {
-        Sounds.playTokenPickupSound();
+        raceState.storeCollision(yacht);
     }
 
     private void formatAndSendChatMessage(String rawChat) {

src/main/java/seng302/visualiser/GameView.java

@@ -1,443 +1,31 @@
 package seng302.visualiser;
 
-import javafx.application.Platform;
-import javafx.collections.ObservableList;
-import javafx.geometry.Point2D;
-import javafx.scene.*;
-import javafx.scene.image.ImageView;
-import javafx.scene.layout.Pane;
-import javafx.scene.paint.Color;
-import javafx.scene.paint.Paint;
-import javafx.scene.shape.Polygon;
-import seng302.gameServer.messages.RoundingSide;
-import seng302.model.GeoPoint;
+import java.util.ArrayList;
+import java.util.List;
+import javafx.scene.Group;
+import javafx.scene.Node;
 import seng302.model.Limit;
+import seng302.model.ScaledPoint;
 import seng302.model.mark.CompoundMark;
 import seng302.model.mark.Corner;
-import seng302.model.mark.Mark;
-import seng302.utilities.GeoUtility;
-import seng302.visualiser.fxObjects.MarkArrowFactory;
-import seng302.visualiser.fxObjects.assets_2D.*;
-
-import java.util.*;
 
 /**
- * Created by cir27 on 20/07/17.
+ * Abstract class for keeping functionality common between race visualisation.
  */
-public class GameView extends Pane {
+public abstract class GameView {
 
-    private double bufferSize = 50;
-    private double horizontalBuffer = 0;
+    double canvasWidth, canvasHeight;
+    ScaledPoint scaledPoint;
 
-    private double canvasWidth = 1100;
-    private double canvasHeight = 920;
-    private boolean horizontalInversion = false;
+    List<Limit> borderPoints;
+    Group gameObjects = new Group();
+    Group markers = new Group();
+    Group tokens = new Group();
+    List<CompoundMark> course = new ArrayList<>();
+    List<CompoundMark> compoundMarks = new ArrayList<>();
+    List<Corner> courseOrder = new ArrayList<>();
 
-    private double distanceScaleFactor;
-    private ScaleDirection scaleDirection;
-    private GeoPoint minLatPoint, minLonPoint, maxLatPoint, maxLonPoint;
-    private double referencePointX, referencePointY;
-
-    private Polygon raceBorder = new CourseBoundary();
-
-    /* Note that if either of these is null then values for it have not been added and the other
-       should be used as the limits of the map. */
-    private List<Limit> borderPoints;
-    private Map<Mark, Marker2D> markerObjects;
-
-    private ObservableList<Node> gameObjects;
-    private Group markers = new Group();
-    private Group tokens = new Group();
-    private List<CompoundMark> course = new ArrayList<>();
-
-    private ImageView mapImage = new ImageView();
-
-    private enum ScaleDirection {
-        HORIZONTAL,
-        VERTICAL
-    }
-
-    public GameView () {
-        gameObjects = this.getChildren();
-        gameObjects.addAll(mapImage, raceBorder, markers, tokens);
-    }
-
-    /**
-     * Adds a course to the GameView. The view is scaled accordingly unless a border is set in which
-     * case the course is added relative ot the border.
-     *
-     * @param newCourse the mark objects that make up the course.
-     * @param sequence The sequence the marks travel through
-     */
-    public void updateCourse(List<CompoundMark> newCourse, List<Corner> sequence) {
-        markerObjects = new HashMap<>();
-
-        for (Corner corner : sequence) { //Makes course out of all compound marks.
-            for (CompoundMark compoundMark : newCourse) {
-                if (corner.getCompoundMarkID() == compoundMark.getId()) {
-                    course.add(compoundMark);
-                }
-            }
-        }
-
-        // TODO: 16/08/17 Updating mark roundings here. It should not happen here. Nor should it be done this way.
-        for (Corner corner : sequence){
-            CompoundMark compoundMark = course.get(corner.getSeqID() - 1);
-            compoundMark.setRoundingSide(
-                RoundingSide.getRoundingSide(corner.getRounding())
-            );
-        }
-
-        final List<Gate> gates = new ArrayList<>();
-        Paint colour = Color.BLACK;
-        //Creates new markers
-        for (CompoundMark cMark : newCourse) {
-            //Set start and end colour
-            if (cMark.getId() == sequence.get(0).getCompoundMarkID()) {
-                colour = Color.GREEN;
-            } else if (cMark.getId() == sequence.get(sequence.size() - 1).getCompoundMarkID()) {
-                colour = Color.RED;
-            }
-            //Create mark dots
-            for (Mark mark : cMark.getMarks()) {
-                makeAndBindMarker(mark, colour);
-            }
-            //Create gate line
-            if (cMark.isGate()) {
-                for (int i = 1; i < cMark.getMarks().size(); i++) {
-                    gates.add(
-                        makeAndBindGate(
-                            markerObjects.get(cMark.getSubMark(i)),
-                            markerObjects.get(cMark.getSubMark(i + 1)),
-                            colour
-                        )
-                    );
-                }
-            }
-            colour = Color.BLACK;
-        }
-
-        createMarkArrows(sequence);
-
-        //Scale race to markers if there is no border.
-        if (borderPoints == null) {
-            rescaleRace(new ArrayList<>(markerObjects.keySet()));
-        }
-        //Move the Markers to initial position.
-        markerObjects.forEach(((mark, marker2D) -> {
-            Point2D p2d = findScaledXY(mark.getLat(), mark.getLng());
-            marker2D.setLayoutX(p2d.getX());
-            marker2D.setLayoutY(p2d.getY());
-        }));
-        Platform.runLater(() -> {
-            markers.getChildren().clear();
-            markers.getChildren().addAll(gates);
-            markers.getChildren().addAll(markerObjects.values());
-        });
-    }
-
-    /**
-     * Calculates all the data needed for to create mark arrows. Requires that a course has been
-     * added to the gameview.
-     * @param sequence The order in which marks are traversed.
-     */
-    private void createMarkArrows (List<Corner> sequence) {
-        for (int i=1; i < sequence.size()-1; i++) { //General case.
-            double averageLat = 0;
-            double averageLng = 0;
-            int numMarks = course.get(i-1).getMarks().size();
-            for (Mark mark : course.get(i-1).getMarks()) {
-                averageLat += mark.getLat();
-                averageLng += mark.getLng();
-            }
-            GeoPoint lastMarkAv = new GeoPoint(averageLat / numMarks, averageLng / numMarks);
-            numMarks = course.get(i+1).getMarks().size();
-            averageLat = 0;
-            averageLng = 0;
-            for (Mark mark : course.get(i+1).getMarks()) {
-                averageLat += mark.getLat();
-                averageLng += mark.getLng();
-            }
-            GeoPoint nextMarkAv = new GeoPoint(averageLat / numMarks, averageLng / numMarks);
-            // TODO: 16/08/17 This comparison doesn't need to exist but the alternative is to user server enum client side.
-            for (Mark mark : course.get(i).getMarks()) {
-                markerObjects.get(mark).addArrows(
-                    mark.getRoundingSide() == RoundingSide.STARBOARD ? MarkArrowFactory.RoundingSide.STARBOARD : MarkArrowFactory.RoundingSide.PORT,
-                    GeoUtility.getBearing(lastMarkAv, mark),
-                    GeoUtility.getBearing(mark, nextMarkAv)
-                );
-            }
-        }
-        createStartLineArrows();
-        createFinishLineArrows();
-    }
-
-    private void createStartLineArrows () {
-        double averageLat = 0;
-        double averageLng = 0;
-        int numMarks = 0;
-        for (Mark mark : course.get(1).getMarks()) {
-            numMarks += 1;
-            averageLat += mark.getLat();
-            averageLng += mark.getLng();
-        }
-        GeoPoint firstMarkAv = new GeoPoint(averageLat / numMarks, averageLng / numMarks);
-        for (Mark mark : course.get(0).getMarks()) {
-            markerObjects.get(mark).addArrows(
-                mark.getRoundingSide() == RoundingSide.STARBOARD ? MarkArrowFactory.RoundingSide.STARBOARD : MarkArrowFactory.RoundingSide.PORT,
-                0d, //90
-                GeoUtility.getBearing(mark, firstMarkAv)
-            );
-        }
-    }
-
-    private void createFinishLineArrows () {
-        double numMarks = 0;
-        double averageLat = 0;
-        double averageLng = 0;
-        for (Mark mark : course.get(course.size()-2).getMarks()) {
-            numMarks += 1;
-            averageLat += mark.getLat();
-            averageLng += mark.getLng();
-        }
-        GeoPoint secondToLastMarkAv = new GeoPoint(averageLat / numMarks, averageLng / numMarks);
-        for (Mark mark : course.get(course.size()-1).getMarks()) {
-            markerObjects.get(mark).addArrows(
-                mark.getRoundingSide() == RoundingSide.STARBOARD ? MarkArrowFactory.RoundingSide.STARBOARD : MarkArrowFactory.RoundingSide.PORT,
-                GeoUtility.getBearing(secondToLastMarkAv, mark),
-                GeoUtility.getBearing(mark, mark)
-            );
-        }
-    }
-
-    /**
-     * Creates a new Marker and binds it's position to the given Mark.
-     *
-     * @param observableMark The mark to bind the marker to.
-     * @param colour The desired colour of the mark
-     */
-    private void makeAndBindMarker(Mark observableMark, Paint colour) {
-        Marker2D marker2D = new Marker2D(colour);
-//        marker.addArrows(MarkArrowFactory.RoundingSide.PORT, ThreadLocalRandom.current().nextDouble(91, 180), ThreadLocalRandom.current().nextDouble(1, 90));
-        markerObjects.put(observableMark, marker2D);
-        observableMark.addPositionListener((mark, lat, lon) -> {
-            Point2D p2d = findScaledXY(lat, lon);
-            markerObjects.get(mark).setLayoutX(p2d.getX());
-            markerObjects.get(mark).setLayoutY(p2d.getY());
-        });
-    }
-
-    /**
-     * Creates a new gate connecting the given marks.
-     *
-     * @param m1 The first Mark of the gate.
-     * @param m2 The second Mark of the gate.
-     * @param colour The desired colour of the gate.
-     * @return the new gate.
-     */
-    private Gate makeAndBindGate(Marker2D m1, Marker2D m2, Paint colour) {
-        Gate gate = new Gate(colour);
-        gate.startXProperty().bind(
-            m1.layoutXProperty()
-        );
-        gate.startYProperty().bind(
-            m1.layoutYProperty()
-        );
-        gate.endXProperty().bind(
-            m2.layoutXProperty()
-        );
-        gate.endYProperty().bind(
-            m2.layoutYProperty()
-        );
-        return gate;
-    }
-
-    /**
-     * Adds a border to the GameView and rescales to the size of the border, does not rescale if a
-     * border already exists. Assumes the border is larger than the course.
-     *
-     * @param border the race border to be drawn.
-     */
-    public void updateBorder(List<Limit> border) {
-        if (borderPoints == null) {
-            borderPoints = border;
-            rescaleRace(new ArrayList<>(borderPoints));
-        }
-
-        rescaleRace(new ArrayList<>(border));
-
-        List<Double> boundaryPoints = new ArrayList<>();
-        for (Limit limit : border) {
-            Point2D location = findScaledXY(limit.getLat(), limit.getLng());
-            boundaryPoints.add(location.getX());
-            boundaryPoints.add(location.getY());
-        }
-        raceBorder.getPoints().setAll(boundaryPoints);
-    }
-
-    /**
-     * Rescales the race to the size of the window.
-     *
-     * @param limitingCoordinates the set of geo points that contains the extremities of the race.
-     */
-    public void rescaleRace(List<GeoPoint> limitingCoordinates) {
-        //Check is called once to avoid unnecessarily change the course limits once the race is running
-        findMinMaxPoint(limitingCoordinates);
-        double minLonToMaxLon = scaleRaceExtremities();
-        calculateReferencePointLocation(minLonToMaxLon);
-    }
-
-    /**
-     * Sets the class variables minLatPoint, maxLatPoint, minLonPoint, maxLonPoint to the point with
-     * the leftmost point, rightmost point, southern most point and northern most point
-     * respectively.
-     */
-    private void findMinMaxPoint(List<GeoPoint> points) {
-        List<GeoPoint> sortedPoints = new ArrayList<>(points);
-        sortedPoints.sort(Comparator.comparingDouble(GeoPoint::getLat));
-        minLatPoint = new GeoPoint(sortedPoints.get(0).getLat(), sortedPoints.get(0).getLng());
-        GeoPoint maxLat = sortedPoints.get(sortedPoints.size() - 1);
-        maxLatPoint = new GeoPoint(maxLat.getLat(), maxLat.getLng());
-
-        sortedPoints.sort(Comparator.comparingDouble(GeoPoint::getLng));
-        minLonPoint = new GeoPoint(sortedPoints.get(0).getLat(), sortedPoints.get(0).getLng());
-        GeoPoint maxLon = sortedPoints.get(sortedPoints.size() - 1);
-        maxLonPoint = new GeoPoint(maxLon.getLat(), maxLon.getLng());
-        if (maxLonPoint.getLng() - minLonPoint.getLng() > 180) {
-            horizontalInversion = true;
-        }
-    }
-
-    /**
-     * Calculates the location of a reference point, this is always the point with minimum latitude,
-     * in relation to the canvas.
-     *
-     * @param minLonToMaxLon The horizontal distance between the point of minimum longitude to
-     * maximum longitude.
-     */
-    private void calculateReferencePointLocation(double minLonToMaxLon) {
-        GeoPoint referencePoint = minLatPoint;
-        double referenceAngle;
-
-        if (scaleDirection == ScaleDirection.HORIZONTAL) {
-            referenceAngle = Math.abs(
-                GeoUtility.getBearingRad(referencePoint, minLonPoint)
-            );
-            referencePointX =
-                bufferSize + distanceScaleFactor * Math.sin(referenceAngle) * GeoUtility
-                    .getDistance(referencePoint, minLonPoint);
-            referenceAngle = Math.abs(GeoUtility.getDistance(referencePoint, maxLatPoint));
-            referencePointY = canvasHeight - (bufferSize + bufferSize);
-            referencePointY -= distanceScaleFactor * Math.cos(referenceAngle) * GeoUtility
-                .getDistance(referencePoint, maxLatPoint);
-            referencePointY = referencePointY / 2;
-            referencePointY += bufferSize;
-            referencePointY += distanceScaleFactor * Math.cos(referenceAngle) * GeoUtility
-                .getDistance(referencePoint, maxLatPoint);
-        } else {
-            referencePointY = canvasHeight - bufferSize;
-            referenceAngle = Math.abs(
-                Math.toRadians(
-                    GeoUtility.getDistance(referencePoint, minLonPoint)
-                )
-            );
-            referencePointX = bufferSize;
-            referencePointX += distanceScaleFactor * Math.sin(referenceAngle) * GeoUtility
-                .getDistance(referencePoint, minLonPoint);
-            referencePointX +=
-                ((canvasWidth - (bufferSize + bufferSize)) - (minLonToMaxLon * distanceScaleFactor))
-                    / 2;
-            referencePointX += horizontalBuffer;
-        }
-        if (horizontalInversion) {
-            referencePointX = canvasWidth - bufferSize - (referencePointX - bufferSize);
-        }
-    }
-
-
-    /**
-     * Finds the scale factor necessary to fit all race markers within the onscreen map and assigns
-     * it to distanceScaleFactor Returns the max horizontal distance of the map.
-     */
-    private double scaleRaceExtremities() {
-
-        double vertAngle = Math.abs(
-            GeoUtility.getBearingRad(minLatPoint, maxLatPoint)
-        );
-        double vertDistance =
-            Math.cos(vertAngle) * GeoUtility.getDistance(minLatPoint, maxLatPoint);
-        double horiAngle = Math.abs(
-            GeoUtility.getBearingRad(minLonPoint, maxLonPoint)
-        );
-        if (horiAngle <= (Math.PI / 2)) {
-            horiAngle = (Math.PI / 2) - horiAngle;
-        } else {
-            horiAngle = horiAngle - (Math.PI / 2);
-        }
-        double horiDistance =
-            Math.cos(horiAngle) * GeoUtility.getDistance(minLonPoint, maxLonPoint);
-
-        double vertScale = (canvasHeight - (bufferSize + bufferSize)) / vertDistance;
-
-        if ((horiDistance * vertScale) > (canvasWidth - (bufferSize + bufferSize))) {
-            distanceScaleFactor = (canvasWidth - (bufferSize + bufferSize)) / horiDistance;
-            scaleDirection = ScaleDirection.HORIZONTAL;
-        } else {
-            distanceScaleFactor = vertScale;
-            scaleDirection = ScaleDirection.VERTICAL;
-        }
-        return horiDistance;
-    }
-
-    private Point2D findScaledXY(double unscaledLat, double unscaledLon) {
-        double distanceFromReference;
-        double angleFromReference;
-        double xAxisLocation = referencePointX;
-        double yAxisLocation = referencePointY;
-
-        angleFromReference = GeoUtility.getBearingRad(
-            minLatPoint, new GeoPoint(unscaledLat, unscaledLon)
-        );
-        distanceFromReference = GeoUtility.getDistance(
-            minLatPoint, new GeoPoint(unscaledLat, unscaledLon)
-        );
-        if (angleFromReference >= 0 && angleFromReference <= Math.PI / 2) {
-            xAxisLocation += Math
-                .round(distanceScaleFactor * Math.sin(angleFromReference) * distanceFromReference);
-            yAxisLocation -= Math
-                .round(distanceScaleFactor * Math.cos(angleFromReference) * distanceFromReference);
-        } else if (angleFromReference >= 0) {
-            angleFromReference = angleFromReference - Math.PI / 2;
-            xAxisLocation += Math
-                .round(distanceScaleFactor * Math.cos(angleFromReference) * distanceFromReference);
-            yAxisLocation += Math
-                .round(distanceScaleFactor * Math.sin(angleFromReference) * distanceFromReference);
-        } else if (angleFromReference < 0 && angleFromReference >= -Math.PI / 2) {
-            angleFromReference = Math.abs(angleFromReference);
-            xAxisLocation -= Math
-                .round(distanceScaleFactor * Math.sin(angleFromReference) * distanceFromReference);
-            yAxisLocation -= Math
-                .round(distanceScaleFactor * Math.cos(angleFromReference) * distanceFromReference);
-        } else {
-            angleFromReference = Math.abs(angleFromReference) - Math.PI / 2;
-            xAxisLocation -= Math
-                .round(distanceScaleFactor * Math.cos(angleFromReference) * distanceFromReference);
-            yAxisLocation += Math
-                .round(distanceScaleFactor * Math.sin(angleFromReference) * distanceFromReference);
-        }
-        if (horizontalInversion) {
-            xAxisLocation = canvasWidth - bufferSize - (xAxisLocation - bufferSize);
-        }
-        return new Point2D(xAxisLocation, yAxisLocation);
-    }
-
-
-    public void setSize(Double width, Double height){
-        this.canvasWidth = width;
-        this.canvasHeight = height;
-    }
-
-    public void setHorizontalBuffer(Double buff){
-        this.horizontalBuffer = buff;
-    }
+    public abstract Node getAssets();
+    public abstract void updateCourse(List<CompoundMark> newCourse, List<Corner> sequence);
+    public abstract void updateBorder(List<Limit> border);
 }

src/main/java/seng302/visualiser/GameView3D.java

@@ -1,38 +1,49 @@
 package seng302.visualiser;
 
 import java.util.ArrayList;
-import java.util.Comparator;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import javafx.animation.AnimationTimer;
 import javafx.application.Platform;
+import javafx.beans.value.ObservableValue;
 import javafx.geometry.Point2D;
 import javafx.geometry.Point3D;
+import javafx.scene.Camera;
 import javafx.scene.Group;
 import javafx.scene.Node;
 import javafx.scene.PerspectiveCamera;
 import javafx.scene.SceneAntialiasing;
 import javafx.scene.SubScene;
+import javafx.scene.image.Image;
 import javafx.scene.input.KeyEvent;
 import javafx.scene.paint.Color;
 import javafx.scene.transform.Rotate;
 import javafx.scene.transform.Scale;
 import javafx.scene.transform.Translate;
+import org.fxyz3d.scene.Skybox;
 import seng302.gameServer.messages.RoundingSide;
 import seng302.model.ClientYacht;
-import seng302.model.GeoPoint;
+import seng302.model.GameKeyBind;
+import seng302.model.KeyAction;
 import seng302.model.Limit;
+import seng302.model.ScaledPoint;
 import seng302.model.mark.CompoundMark;
 import seng302.model.mark.Corner;
 import seng302.model.mark.Mark;
 import seng302.model.token.Token;
 import seng302.utilities.GeoUtility;
 import seng302.utilities.Sounds;
+import seng302.visualiser.cameras.ChaseCamera;
+import seng302.visualiser.cameras.IsometricCamera;
+import seng302.visualiser.cameras.RaceCamera;
+import seng302.visualiser.cameras.TopDownCamera;
+import seng302.visualiser.controllers.ViewManager;
 import seng302.visualiser.fxObjects.MarkArrowFactory;
-import seng302.visualiser.fxObjects.assets_3D.BoatMeshType;
 import seng302.visualiser.fxObjects.assets_3D.BoatObject;
 import seng302.visualiser.fxObjects.assets_3D.Marker3D;
+import seng302.visualiser.fxObjects.assets_3D.Model;
 import seng302.visualiser.fxObjects.assets_3D.ModelFactory;
 import seng302.visualiser.fxObjects.assets_3D.ModelType;
 
@@ -40,73 +51,67 @@ import seng302.visualiser.fxObjects.assets_3D.ModelType;
  * Collection of animated3D assets that displays a race.
  */
 
-public class GameView3D {
-
+public class GameView3D extends GameView{
 
     private final double FOV = 60;
-    private final double DEFAULT_CAMERA_DEPTH = -125;
     private final double DEFAULT_CAMERA_X = 0;
-    private final double DEFAULT_CAMERA_Y = 155;
+    private final double DEFAULT_CAMERA_Y = 100;
 
     private Group root3D;
     private SubScene view;
-    //    ParallelCamera camera;
-    private PerspectiveCamera camera;
     private Group gameObjects;
 
-    private double bufferSize = 0;
-    private double canvasWidth = 200;
-    private double canvasHeight = 200;
-    private boolean horizontalInversion = false;
-
-    private double distanceScaleFactor;
-    private ScaleDirection scaleDirection;
-    private GeoPoint minLatPoint, minLonPoint, maxLatPoint, maxLonPoint;
-    private double referencePointX, referencePointY;
     private Group raceBorder = new Group();
+    // Cameras
+    private PerspectiveCamera isometricCam;
+    private PerspectiveCamera topDownCam;
+    private PerspectiveCamera chaseCam;
 
     /* Note that if either of these is null then values for it have not been added and the other
        should be used as the limits of the map. */
-    private List<Limit> borderPoints;
     private Map<Mark, Marker3D> markerObjects;
 
+    private BoatObject playerBoat;
     private Map<ClientYacht, BoatObject> boatObjects = new HashMap<>();
-    private BoatObject selectedBoat = null;
     private Group wakesGroup = new Group();
     private Group boatObjectGroup = new Group();
-    private Group markers = new Group();
-    private Group tokens = new Group();
-    private List<CompoundMark> course = new ArrayList<>();
     private List<Node> mapTokens;
     private AnimationTimer playerBoatAnimationTimer;
     private Group trail = new Group();
     private Double windDir;
-
-    private enum ScaleDirection {
-        HORIZONTAL,
-        VERTICAL
-    }
+    private Skybox skybox;
 
     public GameView3D () {
-        camera = new PerspectiveCamera(true);
-        camera.getTransforms().addAll(
-            new Translate(DEFAULT_CAMERA_X,DEFAULT_CAMERA_Y, DEFAULT_CAMERA_DEPTH)
-        );
-        camera.setFarClip(600);
-        camera.setNearClip(0.1);
-        camera.setFieldOfView(FOV);
+        isometricCam = new IsometricCamera(DEFAULT_CAMERA_X, DEFAULT_CAMERA_Y);
+        topDownCam = new TopDownCamera();
+        chaseCam = new ChaseCamera();
+
+        canvasWidth = canvasHeight = 300;
+
+        for (PerspectiveCamera pc : Arrays.asList(isometricCam, topDownCam, chaseCam)) {
+            pc.setFarClip(100000);
+            pc.setNearClip(0.1);
+            pc.setFieldOfView(FOV);
+        }
+
         gameObjects = new Group();
-        root3D = new Group(camera, gameObjects);
+        root3D = new Group(isometricCam, gameObjects);
         view = new SubScene(
-            root3D, 1000, 1000, true, SceneAntialiasing.BALANCED
+            root3D, 5000, 3000, true, SceneAntialiasing.BALANCED
         );
-        view.setCamera(camera);
-        camera.getTransforms().add(new Rotate(30, new Point3D(1,0,0)));
+        view.setCamera(isometricCam);
+
+        skybox = new Skybox(new Image(getClass().getResourceAsStream("/images/skybox.jpg")), 100000, isometricCam);
+        skybox.getTransforms().addAll(new Rotate(90, Rotate.X_AXIS));
+
+        Model land = ModelFactory.importModel(ModelType.LAND_SMOOTH);
+        land.getAssets().getTransforms().add(new Rotate(90, Rotate.X_AXIS));
 
         gameObjects.getChildren().addAll(
-            ModelFactory.importModel(ModelType.OCEAN).getAssets(),
-            raceBorder, trail, markers, tokens
+            raceBorder, trail, markers, tokens, skybox, land.getAssets()
         );
+
+
         view.sceneProperty().addListener((obs, old, scene) -> {
             if (scene != null) {
                 scene.addEventHandler(KeyEvent.KEY_PRESSED, this::cameraMovement);
@@ -114,8 +119,10 @@ public class GameView3D {
         });
     }
 
+    @Override
     public void updateCourse(List<CompoundMark> newCourse, List<Corner> sequence) {
         markerObjects = new HashMap<>();
+        compoundMarks = newCourse;
 
         for (Corner corner : sequence) { //Makes course out of all compound marks.
             for (CompoundMark compoundMark : newCourse) {
@@ -166,11 +173,13 @@ public class GameView3D {
 
         //Scale race to markers if there is no border.
         if (borderPoints == null) {
-            rescaleRace(new ArrayList<>(markerObjects.keySet()));
+            scaledPoint = ScaledPoint.makeScaledPoint(
+                canvasWidth, canvasHeight, new ArrayList<>(markerObjects.keySet()), true
+            );
         }
         //Move the Markers to initial position.
         markerObjects.forEach(((mark, marker) -> {
-            Point2D p2d = findScaledXY(mark.getLat(), mark.getLng());
+            Point2D p2d = scaledPoint.findScaledXY(mark.getLat(), mark.getLng());
             marker.setLayoutX(p2d.getX());
             marker.setLayoutY(p2d.getY());
         }));
@@ -190,7 +199,7 @@ public class GameView3D {
     private void makeAndBindMarker(Mark observableMark, ModelType markerType) {
         markerObjects.put(observableMark, new Marker3D(markerType));
         observableMark.addPositionListener((mark, lat, lon) -> {
-            Point2D p2d = findScaledXY(lat, lon);
+            Point2D p2d = scaledPoint.findScaledXY(lat, lon);
             markerObjects.get(mark).setLayoutX(p2d.getX());
             markerObjects.get(mark).setLayoutY(p2d.getY());
         });
@@ -205,8 +214,8 @@ public class GameView3D {
      * @return the new gate.
      */
     private Group makeGate(Mark m1, Mark m2, ModelType gateType) {
-        Point2D m1Location = findScaledXY(m1);
-        Point2D m2Location = findScaledXY(m2);
+        Point2D m1Location = scaledPoint.findScaledXY(m1);
+        Point2D m2Location = scaledPoint.findScaledXY(m2);
 
         Group barrier = ModelFactory.importModel(gateType).getAssets();
         barrier.getTransforms().addAll(
@@ -264,191 +273,46 @@ public class GameView3D {
         }
     }
 
-    /**
-     * Sets the class variables minLatPoint, maxLatPoint, minLonPoint, maxLonPoint to the point with
-     * the leftmost point, rightmost point, southern most point and northern most point
-     * respectively.
-     */
-    private void findMinMaxPoint(List<GeoPoint> points) {
-        List<GeoPoint> sortedPoints = new ArrayList<>(points);
-        sortedPoints.sort(Comparator.comparingDouble(GeoPoint::getLat));
-        minLatPoint = new GeoPoint(sortedPoints.get(0).getLat(), sortedPoints.get(0).getLng());
-        GeoPoint maxLat = sortedPoints.get(sortedPoints.size() - 1);
-        maxLatPoint = new GeoPoint(maxLat.getLat(), maxLat.getLng());
-
-        sortedPoints.sort(Comparator.comparingDouble(GeoPoint::getLng));
-        minLonPoint = new GeoPoint(sortedPoints.get(0).getLat(), sortedPoints.get(0).getLng());
-        GeoPoint maxLon = sortedPoints.get(sortedPoints.size() - 1);
-        maxLonPoint = new GeoPoint(maxLon.getLat(), maxLon.getLng());
-        if (maxLonPoint.getLng() - minLonPoint.getLng() > 180) {
-            horizontalInversion = true;
-        }
-    }
-
-    /**
-     * Calculates the location of a reference point, this is always the point with minimum latitude,
-     * in relation to the canvas.
-     *
-     * @param minLonToMaxLon The horizontal distance between the point of minimum longitude to
-     * maximum longitude.
-     */
-    private void calculateReferencePointLocation(double minLonToMaxLon) {
-        GeoPoint referencePoint = minLatPoint;
-        double referenceAngle;
-
-        if (scaleDirection == ScaleDirection.HORIZONTAL) {
-            referenceAngle = Math.abs(
-                GeoUtility.getBearingRad(referencePoint, minLonPoint)
-            );
-            referencePointX =
-                -100 + distanceScaleFactor * Math.sin(referenceAngle) * GeoUtility
-                    .getDistance(referencePoint, minLonPoint);
-            referenceAngle = Math.abs(GeoUtility.getDistance(referencePoint, maxLatPoint));
-            referencePointY = -100 + canvasHeight - (bufferSize + bufferSize);
-            referencePointY -= distanceScaleFactor * Math.cos(referenceAngle) * GeoUtility
-                .getDistance(referencePoint, maxLatPoint);
-            referencePointY = referencePointY / 2;
-            referencePointY += bufferSize;
-            referencePointY += distanceScaleFactor * Math.cos(referenceAngle) * GeoUtility
-                .getDistance(referencePoint, maxLatPoint);
-        } else {
-            referencePointY = -100 + canvasHeight - bufferSize;
-            referenceAngle = Math.abs(
-                Math.toRadians(
-                    GeoUtility.getDistance(referencePoint, minLonPoint)
-                )
-            );
-            referencePointX = -100 + bufferSize;
-            referencePointX += distanceScaleFactor * Math.sin(referenceAngle) * GeoUtility
-                .getDistance(referencePoint, minLonPoint);
-            referencePointX +=
-                ((canvasWidth - (bufferSize + bufferSize)) - (minLonToMaxLon * distanceScaleFactor))
-                    / 2;
-        }
-        if (horizontalInversion) {
-            referencePointX = -100 + canvasWidth - bufferSize - (referencePointX - bufferSize);
-        }
-    }
-
-
-    /**
-     * Finds the scale factor necessary to fit all race markers within the onscreen map and assigns
-     * it to distanceScaleFactor Returns the max horizontal distance of the map.
-     */
-    private double scaleRaceExtremities() {
-
-        double vertAngle = Math.abs(
-            GeoUtility.getBearingRad(minLatPoint, maxLatPoint)
-        );
-        double vertDistance =
-            Math.cos(vertAngle) * GeoUtility.getDistance(minLatPoint, maxLatPoint);
-        double horiAngle = Math.abs(
-            GeoUtility.getBearingRad(minLonPoint, maxLonPoint)
-        );
-        if (horiAngle <= (Math.PI / 2)) {
-            horiAngle = (Math.PI / 2) - horiAngle;
-        } else {
-            horiAngle = horiAngle - (Math.PI / 2);
-        }
-        double horiDistance =
-            Math.cos(horiAngle) * GeoUtility.getDistance(minLonPoint, maxLonPoint);
-
-        double vertScale = (canvasHeight - (bufferSize + bufferSize)) / vertDistance;
-
-        if ((horiDistance * vertScale) > (canvasWidth - (bufferSize + bufferSize))) {
-            distanceScaleFactor = (canvasWidth - (bufferSize + bufferSize)) / horiDistance;
-            scaleDirection = ScaleDirection.HORIZONTAL;
-        } else {
-            distanceScaleFactor = vertScale;
-            scaleDirection = ScaleDirection.VERTICAL;
-        }
-        return horiDistance;
-    }
-
-    private Point2D findScaledXY(GeoPoint unscaled) {
-        return findScaledXY(unscaled.getLat(), unscaled.getLng());
-    }
-
-    private Point2D findScaledXY(double unscaledLat, double unscaledLon) {
-        double distanceFromReference;
-        double angleFromReference;
-        double xAxisLocation = referencePointX;
-        double yAxisLocation = referencePointY;
-
-        angleFromReference = GeoUtility.getBearingRad(
-            minLatPoint, new GeoPoint(unscaledLat, unscaledLon)
-        );
-        distanceFromReference = GeoUtility.getDistance(
-            minLatPoint, new GeoPoint(unscaledLat, unscaledLon)
-        );
-        if (angleFromReference >= 0 && angleFromReference <= Math.PI / 2) {
-            xAxisLocation += distanceScaleFactor * Math.sin(angleFromReference) * distanceFromReference;
-            yAxisLocation -= distanceScaleFactor * Math.cos(angleFromReference) * distanceFromReference;
-        } else if (angleFromReference >= 0) {
-            angleFromReference = angleFromReference - Math.PI / 2;
-            xAxisLocation += distanceScaleFactor * Math.cos(angleFromReference) * distanceFromReference;
-            yAxisLocation += distanceScaleFactor * Math.sin(angleFromReference) * distanceFromReference;
-        } else if (angleFromReference < 0 && angleFromReference >= -Math.PI / 2) {
-            angleFromReference = Math.abs(angleFromReference);
-            xAxisLocation -= distanceScaleFactor * Math.sin(angleFromReference) * distanceFromReference;
-            yAxisLocation -= distanceScaleFactor * Math.cos(angleFromReference) * distanceFromReference;
-        } else {
-            angleFromReference = Math.abs(angleFromReference) - Math.PI / 2;
-            xAxisLocation -= distanceScaleFactor * Math.cos(angleFromReference) * distanceFromReference;
-            yAxisLocation += distanceScaleFactor * Math.sin(angleFromReference) * distanceFromReference;
-        }
-        if (horizontalInversion) {
-            xAxisLocation = canvasWidth - bufferSize - (xAxisLocation - bufferSize);
-        }
-        return new Point2D(xAxisLocation, yAxisLocation);
-    }
-
     public void cameraMovement(KeyEvent event) {
-        switch (event.getCode()) {
-            case NUMPAD8:
-                camera.getTransforms().addAll(new Rotate(0.5, new Point3D(1,0,0)));
-                break;
-            case NUMPAD2:
-                camera.getTransforms().addAll(new Rotate(-0.5, new Point3D(1,0,0)));
-                break;
-            case NUMPAD4:
-                camera.getTransforms().addAll(new Rotate(-0.5, new Point3D(0,1,0)));
-                break;
-            case NUMPAD6:
-                camera.getTransforms().addAll(new Rotate(0.5, new Point3D(0,1,0)));
-                break;
-            case Z:
-                camera.getTransforms().addAll(new Translate(0, 0, 1.5));
-                break;
-            case X:
-                camera.getTransforms().addAll(new Translate(0, 0, -1.5));
-                break;
-            case W:
-                camera.getTransforms().addAll(new Translate(0, -1, 0));
-                break;
-            case S:
-                camera.getTransforms().addAll(new Translate(0, 1, 0));
-                break;
-            case A:
-                camera.getTransforms().addAll(new Translate(-1, 0, 0));
-                break;
-            case D:
-                camera.getTransforms().addAll(new Translate(1, 0, 0));
-                break;
+        GameKeyBind keyBinds = GameKeyBind.getInstance();
+        KeyAction keyPressed = keyBinds.getKeyAction(event.getCode());
+        if (keyPressed != null) {
+            switch (keyPressed) {
+                case ZOOM_IN:
+                    ((RaceCamera) view.getCamera()).zoomIn();
+                    break;
+                case ZOOM_OUT:
+                    ((RaceCamera) view.getCamera()).zoomOut();
+                    break;
+                case FORWARD:
+                    ((RaceCamera) view.getCamera()).panUp();
+                    break;
+                case BACKWARD:
+                    ((RaceCamera) view.getCamera()).panDown();
+                    break;
+                case LEFT:
+                    ((RaceCamera) view.getCamera()).panLeft();
+                    break;
+                case RIGHT:
+                    ((RaceCamera) view.getCamera()).panRight();
+                    break;
+                case VIEW:
+                    toggleCamera();
+                    break;
+            }
         }
     }
 
-    /**
-     * Rescales the race to the size of the window.
-     *
-     * @param limitingCoordinates the set of geo points that contains the extremities of the race.
-     */
-    private void rescaleRace(List<GeoPoint> limitingCoordinates) {
-        //Check is called once to avoid unnecessarily change the course limits once the race is running
-        findMinMaxPoint(limitingCoordinates);
-        double minLonToMaxLon = scaleRaceExtremities();
-        calculateReferencePointLocation(minLonToMaxLon);
-//        drawGoogleMap();
+    private void toggleCamera() {
+        Camera currCamera = view.getCamera();
+
+        if (currCamera.equals(isometricCam)) {
+            view.setCamera(topDownCam);
+        } else if (currCamera.equals(topDownCam)) {
+            view.setCamera(chaseCam);
+        } else {
+            view.setCamera(isometricCam);
+        }
     }
 
     /**
@@ -466,13 +330,42 @@ public class GameView3D {
             wakesGroup.getChildren().add(newBoat.getWake());
             wakes.add(newBoat.getWake());
             boatObjectGroup.getChildren().add(newBoat);
-            clientYacht.addLocationListener((boat, lat, lon, heading, sailIn, velocity) -> {
-                BoatObject bo = boatObjects.get(boat);
-                Point2D p2d = findScaledXY(lat, lon);
-                bo.moveTo(p2d.getX(), p2d.getY(), heading, velocity, sailIn, windDir);
-            });
+            clientYacht.addLocationListener(this::updateBoatLocation);
+            clientYacht.addColorChangeListener(this::updateBoatColor);
+
+            if (clientYacht.getSourceId().equals(
+                ViewManager.getInstance().getGameClient().getServerThread().getClientId())) {
+                ((ChaseCamera) chaseCam).setPlayerBoat(newBoat);
+                ((TopDownCamera) topDownCam).setPlayerBoat(newBoat);
+
+                newBoat.setMarkIndicator(ModelFactory.importSTL("mark_pointer.stl"));
+                playerBoat = newBoat;
+
+            }
         }
         Platform.runLater(() -> {
+            ClientYacht playerYacht = ViewManager.getInstance().getGameClient().getAllBoatsMap()
+                .get(ViewManager.getInstance().getGameClient().getServerThread().getClientId());
+
+            for (ObservableValue o : Arrays
+                .asList(playerBoat.layoutXProperty(), playerBoat.layoutXProperty())) {
+                o.addListener((obs, oldVal, newVal) -> {
+
+                    List<Mark> marks = course.get(playerYacht.getLegNumber()).getMarks();
+                    Point2D midPoint = new Point2D(0, 0);
+                    if (marks.size() == 1) {
+                        midPoint = scaledPoint.findScaledXY(marks.get(0));
+                    } else if (marks.size() == 2) {
+                        midPoint = (scaledPoint.findScaledXY(marks.get(0)))
+                            .midpoint(scaledPoint.findScaledXY(marks.get(1)));
+                    }
+
+                    if (midPoint != null) {
+                        playerBoat.updateMarkIndicator(midPoint);
+                    }
+
+                });
+            }
             gameObjects.getChildren().addAll(wakes);
             gameObjects.getChildren().addAll(boatObjectGroup);
         });
@@ -482,6 +375,23 @@ public class GameView3D {
         return view;
     }
 
+    /**
+     * Updates the boatObjects color with that of the clientYachts object. Used in notification from
+     * a listener on this attribute in clientYacht to re paint the boat mesh
+     *
+     * @param clientYacht The yacht to update the colour for
+     */
+    private void updateBoatColor(ClientYacht clientYacht) {
+        boatObjects.get(clientYacht).setFill(clientYacht.getColour());
+    }
+
+    private void updateBoatLocation(ClientYacht boat, Double lat, Double lon, Double heading,
+        Boolean sailIn, Double velocity) {
+        BoatObject bo = boatObjects.get(boat);
+        Point2D p2d = scaledPoint.findScaledXY(lat, lon);
+        bo.moveTo(p2d.getX(), p2d.getY(), heading, velocity, sailIn, windDir);
+    }
+
     /**
      * Adds a border to the GameView and rescales to the size of the border, does not rescale if a
      * border already exists. Assumes the border is larger than the course.
@@ -491,18 +401,20 @@ public class GameView3D {
     public void updateBorder(List<Limit> border) {
         if (borderPoints == null) {
             borderPoints = border;
-            rescaleRace(new ArrayList<>(borderPoints));
+            scaledPoint = ScaledPoint.makeScaledPoint(
+                canvasWidth, canvasHeight, new ArrayList<>(borderPoints), true
+            );
         }
         List<Node> boundaryAssets = new ArrayList<>();
 
-        Point2D lastLocation = findScaledXY(border.get(0).getLat(), border.get(0).getLng());
+        Point2D lastLocation = scaledPoint.findScaledXY(border.get(0).getLat(), border.get(0).getLng());
         Group pylon = ModelFactory.importModel(ModelType.BORDER_PYLON).getAssets();
         pylon.setLayoutX(lastLocation.getX());
         pylon.setLayoutY(lastLocation.getY());
         boundaryAssets.add(pylon);
 
         for (int i=1; i<border.size(); i++) {
-            Point2D location = findScaledXY(border.get(i).getLat(), border.get(i).getLng());
+            Point2D location = scaledPoint.findScaledXY(border.get(i).getLat(), border.get(i).getLng());
             pylon = ModelFactory.importModel(ModelType.BORDER_PYLON).getAssets();
             pylon.setLayoutX(location.getX());
             pylon.setLayoutY(location.getY());
@@ -528,7 +440,7 @@ public class GameView3D {
             boundaryAssets.add(pylon);
         }
 
-        Point2D firstLocation = findScaledXY(border.get(0).getLat(), border.get(0).getLng());
+        Point2D firstLocation = scaledPoint.findScaledXY(border.get(0).getLat(), border.get(0).getLng());
         Group barrier = ModelFactory.importModel(ModelType.BORDER_BARRIER).getAssets();
         barrier.getTransforms().addAll(
             new Rotate(
@@ -556,8 +468,28 @@ public class GameView3D {
     public void updateTokens(List<Token> newTokens) {
         mapTokens = new ArrayList<>();
         for (Token token : newTokens) {
-            Point2D location = findScaledXY(token.getLat(), token.getLng());
-            Node tokenObject = ModelFactory.importModel(ModelType.VELOCITY_PICKUP).getAssets();
+            Point2D location = scaledPoint.findScaledXY(token.getLat(), token.getLng());
+
+            ModelType modelType = null;
+            switch (token.getTokenType()) {
+                case BOOST:
+                    modelType = ModelType.VELOCITY_PICKUP;
+                    break;
+                case HANDLING:
+                    modelType = ModelType.HANDLING_PICKUP;
+                    break;
+                case BUMPER:
+                    modelType = ModelType.BUMPER_PICKUP;
+                    break;
+                case RANDOM:
+                    modelType = ModelType.RANDOM_PICKUP;
+                    break;
+                case WIND_WALKER:
+                    modelType = ModelType.WIND_WALKER_PICKUP;
+                    break;
+            }
+
+            Node tokenObject = ModelFactory.importModel(modelType).getAssets();
             tokenObject.setLayoutX(location.getX());
             tokenObject.setLayoutY(location.getY());
             mapTokens.add(tokenObject);
@@ -572,19 +504,17 @@ public class GameView3D {
         playerYacht.toggleSail();
         playerBoatAnimationTimer = new AnimationTimer() {
 
-            double count = 60;
-            Point2D lastLocation = findScaledXY(playerYacht.getLocation());
+            Point2D lastLocation = scaledPoint.findScaledXY(playerYacht.getLocation());
 
             @Override
             public void handle(long now) {
-                if (--count == 0) {
-                    count = 60;
+                Point2D location = scaledPoint.findScaledXY(playerYacht.getLocation());
+                if (Math.abs(lastLocation.distance(location)) > 2) {
                     Node segment = ModelFactory.importModel(ModelType.TRAIL_SEGMENT).getAssets();
-                    Point2D location = findScaledXY(playerYacht.getLocation());
+                    location = scaledPoint.findScaledXY(playerYacht.getLocation());
                     segment.getTransforms().addAll(
                         new Translate(location.getX(), location.getY(), 0),
-                        new Rotate(playerYacht.getHeading(), new Point3D(0,0,1)),
-                        new Scale(1, lastLocation.distance(location) / 5, 1)
+                        new Rotate(playerYacht.getHeading(), new Point3D(0,0,1))
                     );
                     trail.getChildren().add(segment);
                     if (trail.getChildren().size() > 50) {
@@ -631,4 +561,4 @@ public class GameView3D {
             }
         }
     }
-}
+}

src/main/java/seng302/visualiser/MapMaker.java

@@ -0,0 +1,126 @@
+package seng302.visualiser;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import javafx.scene.Node;
+import javafx.util.Pair;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import seng302.model.stream.xml.generator.RaceXMLTemplate;
+import seng302.model.stream.xml.generator.RegattaXMLTemplate;
+import seng302.model.stream.xml.parser.RaceXMLData;
+import seng302.model.stream.xml.parser.RegattaXMLData;
+import seng302.utilities.XMLGenerator;
+import seng302.utilities.XMLParser;
+
+/**
+ * Makes maps from map definition xml files.
+ */
+public class MapMaker {
+
+    private List<MapPreview> mapPreviews = new ArrayList<>();
+    private List<RaceXMLData> races = new ArrayList<>();
+    private List<RegattaXMLData> regattas = new ArrayList<>();
+    private List<String> filePaths = new ArrayList<>();
+    private List<Integer> maxPlayers = new ArrayList<>();
+    private static MapMaker instance;
+    private int index = 0;
+    private XMLGenerator xmlGenerator = new XMLGenerator();
+
+    private List<String> maps = new ArrayList<>(Arrays.asList("default.xml", "horseshoe.xml"));
+
+    public static MapMaker getInstance() {
+        if (instance == null) {
+            instance = new MapMaker();
+        }
+        return instance;
+    }
+
+    private MapMaker() {
+        for (String mapPath : maps){
+            String path = ("/maps/" + mapPath);
+
+            Pair<RegattaXMLTemplate, RaceXMLTemplate> regattaRace = XMLParser.parseRaceDef(
+                    path, "", 1, null, false
+            );
+
+            RegattaXMLTemplate regattaTemplate = regattaRace.getKey();
+
+            filePaths.add(path);
+
+            regattas.add(new RegattaXMLData(
+                    regattaTemplate.getRegattaId(),
+                    regattaTemplate.getName(),
+                    regattaTemplate.getCourseName(),
+                    regattaTemplate.getLatitude(),
+                    regattaTemplate.getLongitude(),
+                    regattaTemplate.getUtcOffset()
+            ));
+
+            RaceXMLTemplate raceTemplate = regattaRace.getValue();
+            xmlGenerator.setRaceTemplate(raceTemplate);
+            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+            DocumentBuilder db;
+            Document doc = null;
+            try {
+                db = dbf.newDocumentBuilder();
+                doc = db.parse(new InputSource(new StringReader(xmlGenerator.getRaceAsXml())));
+            } catch (ParserConfigurationException | IOException | SAXException e) {
+                e.printStackTrace();
+            }
+
+            RaceXMLData race = XMLParser.parseRace(doc);
+            maxPlayers.add(XMLParser.getMaxPlayers(doc));
+
+            mapPreviews.add(new MapPreview(
+                    new ArrayList<>(race.getCompoundMarks().values()),
+                    race.getMarkSequence(), race.getCourseLimit()
+            ));
+
+            races.add(race);
+        }
+
+    }
+
+    public void next() {
+        index += 1;
+        if (index >= mapPreviews.size()) {
+            index = 0;
+        }
+    }
+
+    public void previous() {
+        index -= 1;
+        if (index < 0) {
+            index = mapPreviews.size() - 1;
+        }
+    }
+
+    public Node getCurrentGameView() {
+        return mapPreviews.get(index).getAssets();
+    }
+
+    public RaceXMLData getCurrentRace() {
+        return races.get(index);
+    }
+
+    public RegattaXMLData getCurrentRegatta() {
+        return regattas.get(index);
+    }
+
+    public String getCurrentRacePath() {
+        return filePaths.get(index);
+    }
+
+    public Integer getMaxPlayers() {
+        return maxPlayers.get(index);
+    }
+}

src/main/java/seng302/visualiser/MapPreview.java

@@ -0,0 +1,283 @@
+package seng302.visualiser;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javafx.application.Platform;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Polygon;
+import seng302.gameServer.messages.RoundingSide;
+import seng302.model.GeoPoint;
+import seng302.model.Limit;
+import seng302.model.ScaledPoint;
+import seng302.model.mark.CompoundMark;
+import seng302.model.mark.Corner;
+import seng302.model.mark.Mark;
+import seng302.utilities.GeoUtility;
+import seng302.visualiser.fxObjects.MarkArrowFactory;
+import seng302.visualiser.fxObjects.assets_2D.CourseBoundary;
+import seng302.visualiser.fxObjects.assets_2D.Gate;
+import seng302.visualiser.fxObjects.assets_2D.Marker2D;
+
+/**
+ * Created by cir27 on 20/07/17.
+ */
+public class MapPreview extends GameView {
+
+    private Polygon raceBorder = new CourseBoundary();
+    private Map<Mark, Marker2D> markerObjects;
+
+    public MapPreview(List<CompoundMark> marks, List<Corner> course, List<Limit> border) {
+        this.compoundMarks = marks;
+        this.courseOrder = course;
+        this.borderPoints = border;
+        gameObjects.getChildren().addAll(raceBorder, markers, tokens);
+        gameObjects.parentProperty().addListener((obs, old, parent) -> {
+            if (parent != null) {
+                canvasWidth = parent.prefWidth(1);
+                canvasHeight = parent.prefHeight(1);
+                updateBorder(borderPoints);
+                updateCourse(compoundMarks, courseOrder);
+            }
+        });
+    }
+
+    @Override
+    public Node getAssets() {
+        return gameObjects;
+    }
+
+    public void setSize(double width, double height) {
+        canvasHeight = height;
+        canvasWidth = width;
+        updateBorder(borderPoints);
+        updateCourse(compoundMarks, courseOrder);
+    }
+
+    /**
+     * Adds a course to the GameView. The view is scaled accordingly unless a border is set in which
+     * case the course is added relative ot the border.
+     *
+     * @param newCourse the mark objects that make up the course.
+     * @param sequence The sequence the marks travel through
+     */
+    @Override
+    public void updateCourse(List<CompoundMark> newCourse, List<Corner> sequence) {
+
+        if (newCourse.size() == 0) {
+            return;
+        }
+        compoundMarks = newCourse;
+        markerObjects = new HashMap<>();
+        courseOrder = sequence;
+
+        for (Corner corner : courseOrder) { //Makes course out of all compound marks.
+            for (CompoundMark compoundMark : newCourse) {
+                if (corner.getCompoundMarkID() == compoundMark.getId()) {
+                    course.add(compoundMark);
+                }
+            }
+        }
+
+        // TODO: 16/08/17 Updating mark roundings here. It should not happen here. Nor should it be done this way.
+        for (Corner corner : sequence){
+            CompoundMark compoundMark = course.get(corner.getSeqID() - 1);
+            compoundMark.setRoundingSide(
+                RoundingSide.getRoundingSide(corner.getRounding())
+            );
+        }
+
+        final List<Gate> gates = new ArrayList<>();
+        Paint colour = Color.BLACK;
+        //Creates new markers
+        for (CompoundMark cMark : newCourse) {
+            //Set start and end colour
+            if (cMark.getId() == sequence.get(0).getCompoundMarkID()) {
+                colour = Color.GREEN;
+            } else if (cMark.getId() == sequence.get(sequence.size() - 1).getCompoundMarkID()) {
+                colour = Color.RED;
+            }
+            //Create mark dots
+            for (Mark mark : cMark.getMarks()) {
+                makeAndBindMarker(mark, colour);
+            }
+            //Create gate line
+            if (cMark.isGate()) {
+                for (int i = 1; i < cMark.getMarks().size(); i++) {
+                    gates.add(
+                        makeAndBindGate(
+                            markerObjects.get(cMark.getSubMark(i)),
+                            markerObjects.get(cMark.getSubMark(i + 1)),
+                            colour
+                        )
+                    );
+                }
+            }
+            colour = Color.BLACK;
+        }
+
+        createMarkArrows(sequence);
+
+        //Scale race to markers if there is no border.
+        if (borderPoints == null) {
+            scaledPoint = ScaledPoint.makeScaledPoint(
+                canvasWidth, canvasHeight, new ArrayList<>(markerObjects.keySet()), false
+            );
+        }
+        //Move the Markers to initial position.
+        markerObjects.forEach(((mark, marker2D) -> {
+            Point2D p2d = scaledPoint.findScaledXY(mark.getLat(), mark.getLng());
+            marker2D.setLayoutX(p2d.getX());
+            marker2D.setLayoutY(p2d.getY());
+        }));
+        Platform.runLater(() -> {
+            markers.getChildren().clear();
+            markers.getChildren().addAll(gates);
+            markers.getChildren().addAll(markerObjects.values());
+        });
+    }
+
+    /**
+     * Calculates all the data needed for to create mark arrows. Requires that a course has been
+     * added to the gameview.
+     * @param sequence The order in which marks are traversed.
+     */
+    private void createMarkArrows (List<Corner> sequence) {
+        for (int i=1; i < sequence.size()-1; i++) { //General case.
+            double averageLat = 0;
+            double averageLng = 0;
+            int numMarks = course.get(i-1).getMarks().size();
+            for (Mark mark : course.get(i-1).getMarks()) {
+                averageLat += mark.getLat();
+                averageLng += mark.getLng();
+            }
+            GeoPoint lastMarkAv = new GeoPoint(averageLat / numMarks, averageLng / numMarks);
+            numMarks = course.get(i+1).getMarks().size();
+            averageLat = 0;
+            averageLng = 0;
+            for (Mark mark : course.get(i+1).getMarks()) {
+                averageLat += mark.getLat();
+                averageLng += mark.getLng();
+            }
+            GeoPoint nextMarkAv = new GeoPoint(averageLat / numMarks, averageLng / numMarks);
+            // TODO: 16/08/17 This comparison doesn't need to exist but the alternative is to user server enum client side.
+            for (Mark mark : course.get(i).getMarks()) {
+                markerObjects.get(mark).addArrows(
+                    mark.getRoundingSide() == RoundingSide.STARBOARD ? MarkArrowFactory.RoundingSide.STARBOARD : MarkArrowFactory.RoundingSide.PORT,
+                    GeoUtility.getBearing(lastMarkAv, mark),
+                    GeoUtility.getBearing(mark, nextMarkAv)
+                );
+            }
+        }
+        createStartLineArrows();
+        createFinishLineArrows();
+    }
+
+    private void createStartLineArrows () {
+        double averageLat = 0;
+        double averageLng = 0;
+        int numMarks = 0;
+        for (Mark mark : course.get(1).getMarks()) {
+            numMarks += 1;
+            averageLat += mark.getLat();
+            averageLng += mark.getLng();
+        }
+        GeoPoint firstMarkAv = new GeoPoint(averageLat / numMarks, averageLng / numMarks);
+        for (Mark mark : course.get(0).getMarks()) {
+            markerObjects.get(mark).addArrows(
+                mark.getRoundingSide() == RoundingSide.STARBOARD ? MarkArrowFactory.RoundingSide.STARBOARD : MarkArrowFactory.RoundingSide.PORT,
+                0d, //90
+                GeoUtility.getBearing(mark, firstMarkAv)
+            );
+        }
+    }
+
+    private void createFinishLineArrows () {
+        double numMarks = 0;
+        double averageLat = 0;
+        double averageLng = 0;
+        for (Mark mark : course.get(course.size()-2).getMarks()) {
+            numMarks += 1;
+            averageLat += mark.getLat();
+            averageLng += mark.getLng();
+        }
+        GeoPoint secondToLastMarkAv = new GeoPoint(averageLat / numMarks, averageLng / numMarks);
+        for (Mark mark : course.get(course.size()-1).getMarks()) {
+            markerObjects.get(mark).addArrows(
+                mark.getRoundingSide() == RoundingSide.STARBOARD ? MarkArrowFactory.RoundingSide.STARBOARD : MarkArrowFactory.RoundingSide.PORT,
+                GeoUtility.getBearing(secondToLastMarkAv, mark),
+                GeoUtility.getBearing(mark, mark)
+            );
+        }
+    }
+
+    /**
+     * Creates a new Marker and binds it's position to the given Mark.
+     *
+     * @param observableMark The mark to bind the marker to.
+     * @param colour The desired colour of the mark
+     */
+    private void makeAndBindMarker(Mark observableMark, Paint colour) {
+        Marker2D marker2D = new Marker2D(colour);
+//        marker.addArrows(MarkArrowFactory.RoundingSide.PORT, ThreadLocalRandom.current().nextDouble(91, 180), ThreadLocalRandom.current().nextDouble(1, 90));
+        markerObjects.put(observableMark, marker2D);
+        observableMark.addPositionListener((mark, lat, lon) -> {
+            Point2D p2d = scaledPoint.findScaledXY(lat, lon);
+            markerObjects.get(mark).setLayoutX(p2d.getX());
+            markerObjects.get(mark).setLayoutY(p2d.getY());
+        });
+    }
+
+    /**
+     * Creates a new gate connecting the given marks.
+     *
+     * @param m1 The first Mark of the gate.
+     * @param m2 The second Mark of the gate.
+     * @param colour The desired colour of the gate.
+     * @return the new gate.
+     */
+    private Gate makeAndBindGate(Marker2D m1, Marker2D m2, Paint colour) {
+        Gate gate = new Gate(colour);
+        gate.startXProperty().bind(
+            m1.layoutXProperty()
+        );
+        gate.startYProperty().bind(
+            m1.layoutYProperty()
+        );
+        gate.endXProperty().bind(
+            m2.layoutXProperty()
+        );
+        gate.endYProperty().bind(
+            m2.layoutYProperty()
+        );
+        return gate;
+    }
+
+    /**
+     * Adds a border to the GameView and rescales to the size of the border, does not rescale if a
+     * border already exists. Assumes the border is larger than the course.
+     *
+     * @param border the race border to be drawn.
+     */
+    @Override
+    public void updateBorder(List<Limit> border) {
+        if (border.size() == 0) {
+            return;
+        }
+
+        borderPoints = border;
+        scaledPoint = ScaledPoint.makeScaledPoint(canvasWidth, canvasHeight, border, false);
+
+        List<Double> boundaryPoints = new ArrayList<>();
+        for (Limit limit : border) {
+            Point2D location = scaledPoint.findScaledXY(limit.getLat(), limit.getLng());
+            boundaryPoints.add(location.getX());
+            boundaryPoints.add(location.getY());
+        }
+        raceBorder.getPoints().setAll(boundaryPoints);
+    }
+}

src/main/java/seng302/visualiser/ServerListener.java

@@ -6,11 +6,10 @@ import seng302.gameServer.ServerDescription;
 import javax.jmdns.JmDNS;
 import javax.jmdns.ServiceEvent;
 import javax.jmdns.ServiceListener;
+import javax.jmdns.impl.JmDNSImpl;
 import java.io.IOException;
 import java.net.InetAddress;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
 
 import static seng302.gameServer.ServerAdvertiser.getLocalHostIp;
 
@@ -18,6 +17,7 @@ import static seng302.gameServer.ServerAdvertiser.getLocalHostIp;
  * Listens for servers on the local network
  */
 public class ServerListener{
+    private static Integer SERVICE_REFRESH_INTERVAL = 5 * 1000;
     private static ServerListener instance;
     private ServerListenerDelegate delegate;
     private JmDNS jmdns = null;
@@ -91,8 +91,16 @@ public class ServerListener{
 
     private ServerListener() throws IOException {
         jmdns = JmDNS.create(InetAddress.getByName(getLocalHostIp()));
+
         listener = new GameServeMonitor();
         jmdns.addServiceListener(ServerAdvertiser.SERVICE_TYPE, listener);
+
+        /*new Timer().schedule(new TimerTask() {
+            @Override
+            public void run() {
+                refresh();
+            }
+        }, 50, SERVICE_REFRESH_INTERVAL);*/
     }
 
     public static ServerListener getInstance() throws IOException {
@@ -110,4 +118,25 @@ public class ServerListener{
     public void setDelegate(ServerListenerDelegate delegate){
         this.delegate = delegate;
     }
+
+    public void refresh(){
+        ArrayList<ServerDescription> servers = new ArrayList<>(listener.servers);
+
+        for (ServerDescription serverDescription : servers){
+            if (serverDescription.hasExpired()){
+                jmdns.requestServiceInfo(ServerAdvertiser.SERVICE_TYPE, serverDescription.getName());
+            }
+            else{
+                serverDescription.hasBeenRefreshed();
+            }
+        }
+
+        for (ServerDescription server : servers){
+            if (server.serverShouldBeRemoved()){
+                listener.servers.remove(server);
+                delegate.serverRemoved(new ArrayList<ServerDescription>(listener.servers));
+            }
+        }
+
+    }
 }

src/main/java/seng302/visualiser/cameras/ChaseCamera.java

@@ -0,0 +1,130 @@
+package seng302.visualiser.cameras;
+
+import java.util.Arrays;
+import javafx.beans.property.DoubleProperty;
+import javafx.collections.ObservableList;
+import javafx.geometry.Point3D;
+import javafx.scene.PerspectiveCamera;
+import javafx.scene.transform.Rotate;
+import javafx.scene.transform.Transform;
+import javafx.scene.transform.Translate;
+import seng302.visualiser.fxObjects.assets_3D.BoatObject;
+
+
+public class ChaseCamera extends PerspectiveCamera implements RaceCamera {
+
+    private final Double VERTICAL_PAN_LIMIT = 20.0;
+    private final Double NEAR_ZOOM_LIMIT = -15.0;
+    private final Double FAR_ZOOM_LIMIT = -125.0;
+
+    private final Double ZOOM_STEP = 2.5;
+    private final Double PAN_STEP = 2.5;
+
+    private ObservableList<Transform> transforms;
+    private BoatObject playerBoat;
+
+    private Double zoomFactor;
+    private Double horizontalPan;
+    private Double verticalPan;
+
+
+    public ChaseCamera() {
+        super(true);
+        transforms = this.getTransforms();
+
+        zoomFactor = (FAR_ZOOM_LIMIT + NEAR_ZOOM_LIMIT) / 2.0;
+        this.horizontalPan = 0.0;
+        this.verticalPan = 0.0;
+    }
+
+    /**
+     * Sets a player boat object to observe and update the camera with.
+     *
+     * @param playerBoat The player boat to be observed.
+     */
+    public void setPlayerBoat(BoatObject playerBoat) {
+        this.playerBoat = playerBoat;
+
+        for (DoubleProperty o : Arrays
+            .asList(playerBoat.getRotationProperty(), playerBoat.layoutYProperty(),
+                playerBoat.layoutXProperty())) {
+            o.addListener((obs, oldVal, newVal) -> repositionCamera());
+        }
+    }
+
+    /**
+     * Moves the camera to a new position after some change (Zooming or Panning)
+     */
+    private void repositionCamera() {
+        transforms.clear();
+        transforms.addAll(
+            new Translate(playerBoat.getLayoutX(), playerBoat.getLayoutY(), 0),
+            new Rotate(playerBoat.getRotationProperty().getValue() + horizontalPan,
+                new Point3D(0, 0, 1)),
+            new Rotate(60 + verticalPan, new Point3D(1, 0, 0)),
+            new Translate(0, 0, zoomFactor)
+        );
+    }
+
+    /**
+     * Adjusts the zoom amount (camera depth) by some adjustment value
+     * @param adjustment the adjustment to be made to the camera
+     */
+    private void adjustZoomFactor(Double adjustment) {
+        if (zoomFactor + adjustment < NEAR_ZOOM_LIMIT && zoomFactor + adjustment > FAR_ZOOM_LIMIT) {
+            zoomFactor = zoomFactor + adjustment;
+            repositionCamera();
+        }
+    }
+
+    /**
+     * Adjusts the Vertical Panning of the Camera
+     * @param adjustment the adjustment to be made to the camera
+     */
+    private void adjustVerticalPan(Double adjustment) {
+        if (verticalPan + adjustment >= -VERTICAL_PAN_LIMIT
+            && verticalPan + adjustment <= VERTICAL_PAN_LIMIT) {
+            verticalPan += adjustment;
+            repositionCamera();
+        }
+    }
+
+    /**
+     * Adjusts the Horizontal Panning of the Camera.
+     * @param adjustment the adjustment to be made to the camera
+     */
+    private void adjustHorizontalPan(Double adjustment) {
+        this.horizontalPan += adjustment;
+        repositionCamera();
+    }
+
+    @Override
+    public void zoomIn() {
+        adjustZoomFactor(ZOOM_STEP);
+    }
+
+    @Override
+    public void zoomOut() {
+        adjustZoomFactor(-ZOOM_STEP);
+    }
+
+    @Override
+    public void panLeft() {
+        adjustHorizontalPan(-PAN_STEP);
+    }
+
+    @Override
+    public void panRight() {
+        adjustHorizontalPan(PAN_STEP);
+    }
+
+    @Override
+    public void panUp() {
+        adjustVerticalPan(-PAN_STEP);
+    }
+
+    @Override
+    public void panDown() {
+        adjustVerticalPan(PAN_STEP);
+    }
+}

src/main/java/seng302/visualiser/cameras/IsometricCamera.java

@@ -0,0 +1,113 @@
+package seng302.visualiser.cameras;
+
+import javafx.collections.ObservableList;
+import javafx.geometry.Point3D;
+import javafx.scene.PerspectiveCamera;
+import javafx.scene.transform.Rotate;
+import javafx.scene.transform.Transform;
+import javafx.scene.transform.Translate;
+
+public class IsometricCamera extends PerspectiveCamera implements RaceCamera {
+
+    private final Double MIN_X = -120.0;
+    private final Double MAX_X = 125.0;
+
+    private final Double MIN_Y = 40.0;
+    private final Double MAX_Y = 170.0;
+
+    private final Double PAN_LIMIT = 160.0;
+    private final Double NEAR_ZOOM_LIMIT = -50.0;
+    private final Double FAR_ZOOM_LIMIT = -160.0;
+
+    private Double horizontalPan;
+    private Double verticalPan;
+    private Double zoomFactor;
+
+    private ObservableList<Transform> transforms;
+
+    public IsometricCamera(Double cameraStartX, Double cameraStartY) {
+        super(true);
+        transforms = this.getTransforms();
+
+        zoomFactor = (FAR_ZOOM_LIMIT + NEAR_ZOOM_LIMIT) / 2.0;
+        horizontalPan = cameraStartX;
+        verticalPan = cameraStartY;
+
+        updateCamera();
+    }
+
+    /**
+     * Moves the camera to a new position after some change (Zooming or Panning)
+     */
+    private void updateCamera() {
+        transforms.clear();
+        transforms.addAll(
+            new Translate(horizontalPan, verticalPan, zoomFactor),
+            new Rotate(30, new Point3D(1, 0, 0))
+        );
+    }
+
+    /**
+     * Adjusts the zoom amount (camera depth) by some adjustment value
+     *
+     * @param adjustment the adjustment to be made to the camera
+     */
+    private void adjustZoomFactor(Double adjustment) {
+        if (zoomFactor + adjustment < NEAR_ZOOM_LIMIT && zoomFactor + adjustment > FAR_ZOOM_LIMIT) {
+            zoomFactor = zoomFactor + adjustment;
+            updateCamera();
+        }
+    }
+
+    /**
+     * Adjusts the Vertical Panning of the Camera
+     * @param adjustment the adjustment to be made to the camera
+     */
+    private void adjustVerticalPan(Double adjustment) {
+        if (verticalPan + adjustment >= MIN_Y && verticalPan + adjustment <= MAX_Y) {
+            verticalPan += adjustment;
+            updateCamera();
+        }
+    }
+
+    /**
+     * Adjusts the Horizontal Panning of the Camera.
+     * @param adjustment the adjustment to be made to the camera
+     */
+    private void adjustHorizontalPan(Double adjustment) {
+        if (horizontalPan + adjustment >= MIN_X && horizontalPan + adjustment <= MIN_Y) {
+            this.horizontalPan += adjustment;
+            updateCamera();
+        }
+    }
+
+    @Override
+    public void zoomIn() {
+        adjustZoomFactor(-2.5);
+    }
+
+    @Override
+    public void zoomOut() {
+        adjustZoomFactor(2.5);
+    }
+
+    @Override
+    public void panLeft() {
+        adjustHorizontalPan(-2.5);
+    }
+
+    @Override
+    public void panRight() {
+        adjustHorizontalPan(2.5);
+    }
+
+    @Override
+    public void panUp() {
+        adjustVerticalPan(-2.5);
+    }
+
+    @Override
+    public void panDown() {
+        adjustVerticalPan(2.5);
+    }
+}

src/main/java/seng302/visualiser/cameras/RaceCamera.java

@@ -0,0 +1,18 @@
+package seng302.visualiser.cameras;
+
+
+public interface RaceCamera {
+
+    void zoomIn();
+
+    void zoomOut();
+
+    void panLeft();
+
+    void panRight();
+
+    void panUp();
+
+    void panDown();
+
+}

src/main/java/seng302/visualiser/cameras/TopDownCamera.java

@@ -0,0 +1,123 @@
+package seng302.visualiser.cameras;
+
+
+import java.util.Arrays;
+import javafx.beans.property.DoubleProperty;
+import javafx.collections.ObservableList;
+import javafx.scene.PerspectiveCamera;
+import javafx.scene.transform.Transform;
+import javafx.scene.transform.Translate;
+import seng302.visualiser.fxObjects.assets_3D.BoatObject;
+
+public class TopDownCamera extends PerspectiveCamera implements RaceCamera {
+
+    private final Double PAN_LIMIT = 30.0;
+    private final Double NEAR_ZOOM_LIMIT = -30.0;
+    private final Double FAR_ZOOM_LIMIT = -130.0;
+    private final Double ZOOM_STEP = 2.5;
+
+    private ObservableList<Transform> transforms;
+    private BoatObject playerBoat;
+
+    private Double zoomFactor;
+    private Double horizontalPan;
+    private Double verticalPan;
+
+    public TopDownCamera() {
+        super(true);
+        transforms = this.getTransforms();
+
+        zoomFactor = (FAR_ZOOM_LIMIT + NEAR_ZOOM_LIMIT) / 2.0;
+        horizontalPan = 0.0;
+        verticalPan = 0.0;
+    }
+
+    /**
+     * Sets a player boat object to observe and update the camera with.
+     *
+     * @param playerBoat The player boat to be observed.
+     */
+    public void setPlayerBoat(BoatObject playerBoat) {
+        this.playerBoat = playerBoat;
+
+        for (DoubleProperty o : Arrays
+            .asList(playerBoat.layoutXProperty(), playerBoat.layoutYProperty())) {
+            o.addListener((obs, oldVal, newVal) -> updateCamera());
+        }
+    }
+
+    /**
+     * Moves the camera to a new position after some change (Zooming or Panning)
+     */
+    private void updateCamera() {
+        transforms.clear();
+        transforms.addAll(
+            new Translate(playerBoat.getLayoutX() + horizontalPan,
+                playerBoat.getLayoutY() + verticalPan, zoomFactor)
+        );
+    }
+
+    /**
+     * Adjusts the zoom amount (camera depth) by some adjustment value
+     * @param adjustment the adjustment to be made to the camera
+     */
+    private void adjustZoomFactor(Double adjustment) {
+        if (zoomFactor + adjustment < NEAR_ZOOM_LIMIT && zoomFactor + adjustment > FAR_ZOOM_LIMIT) {
+            zoomFactor = zoomFactor + adjustment;
+            updateCamera();
+        }
+    }
+
+    /**
+     * Adjusts the Vertical Panning of the Camera
+     * @param adjustment the adjustment to be made to the camera
+     */
+    private void adjustVerticalPan(Double adjustment) {
+        if (verticalPan + adjustment >= -PAN_LIMIT && verticalPan + adjustment <= PAN_LIMIT) {
+            verticalPan += adjustment;
+            updateCamera();
+        }
+    }
+
+    /**
+     * Adjusts the Horizontal Panning of the Camera.
+     * @param adjustment the adjustment to be made to the camera
+     */
+    private void adjustHorizontalPan(Double adjustment) {
+        if (horizontalPan + adjustment >= -PAN_LIMIT && horizontalPan + adjustment <= PAN_LIMIT) {
+            horizontalPan += adjustment;
+            updateCamera();
+        }
+    }
+
+    @Override
+    public void zoomIn() {
+        adjustZoomFactor(ZOOM_STEP);
+    }
+
+    @Override
+    public void zoomOut() {
+        adjustZoomFactor(-ZOOM_STEP);
+    }
+
+    @Override
+    public void panLeft() {
+        adjustHorizontalPan(-1.0);
+    }
+
+    @Override
+    public void panRight() {
+        adjustHorizontalPan(1.0);
+    }
+
+    @Override
+    public void panUp() {
+        adjustVerticalPan(-1.0);
+    }
+
+    @Override
+    public void panDown() {
+        adjustVerticalPan(1.0);
+    }
+
+}

src/main/java/seng302/visualiser/controllers/FinishScreenViewController.java

@@ -88,7 +88,6 @@ public class FinishScreenViewController implements Initializable {
 
     public void switchToStartScreenView() {
         Sounds.playButtonClick();
-        //TODO merge fix
         setContentPane("/views/StartScreenView.fxml");
     }
 

src/main/java/seng302/visualiser/controllers/LobbyController.java

@@ -9,10 +9,11 @@ import javafx.fxml.FXMLLoader;
 import javafx.fxml.Initializable;
 import javafx.scene.control.Label;
 import javafx.scene.control.ScrollPane;
-import javafx.scene.layout.Pane;
+import javafx.scene.layout.AnchorPane;
 import javafx.scene.layout.StackPane;
 import javafx.scene.layout.VBox;
 import javafx.scene.paint.Color;
+import seng302.discoveryServer.DiscoveryServerClient;
 import seng302.gameServer.GameStages;
 import seng302.gameServer.GameState;
 import seng302.model.ClientYacht;
@@ -23,7 +24,7 @@ import seng302.model.mark.CompoundMark;
 import seng302.model.mark.Corner;
 import seng302.model.stream.xml.parser.RaceXMLData;
 import seng302.utilities.Sounds;
-import seng302.visualiser.GameView;
+import seng302.visualiser.MapPreview;
 import seng302.visualiser.controllers.cells.PlayerCell;
 import seng302.visualiser.controllers.dialogs.BoatCustomizeController;
 
@@ -33,10 +34,12 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.ResourceBundle;
-import seng302.visualiser.fxObjects.assets_3D.BoatMeshType;
 
 public class LobbyController implements Initializable {
 
+    private final double INITIAL_MAP_HEIGHT = 770d;
+    private final double INITIAL_MAP_WIDTH = 574d;
+
     //--------FXML BEGIN--------//
     @FXML
     private VBox playerListVBox;
@@ -51,19 +54,21 @@ public class LobbyController implements Initializable {
     @FXML
     private Label mapName;
     @FXML
-    private Pane serverMap;
+    private AnchorPane serverMap;
+    @FXML
+    private Label roomLabel;
     //---------FXML END---------//
 
     private RaceState raceState;
     private JFXDialog customizationDialog;
     public Color playersColor;
     private Map<Integer, ClientYacht> playerBoats;
-    private Double mapWidth, mapHeight;
-    private GameView gameView;
+    private Double mapWidth = INITIAL_MAP_WIDTH, mapHeight = INITIAL_MAP_HEIGHT;
+    private MapPreview mapPreview;
 
     @Override
     public void initialize(URL location, ResourceBundle resources) {
-
+        roomLabel.setText("");
         this.playerBoats = ViewManager.getInstance().getGameClient().getAllBoatsMap();
 
         if (this.playersColor == null) {
@@ -86,6 +91,21 @@ public class LobbyController implements Initializable {
             serverName.setText(ViewManager.getInstance().getProperty("serverName"));
             mapName.setText(ViewManager.getInstance().getProperty("mapName"));
 
+            int tries = 0;
+
+            while (DiscoveryServerClient.getRoomCode() == null && tries <= 10){
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                tries ++;
+            }
+
+            if (DiscoveryServerClient.getRoomCode() != null){
+                setRoomCode(DiscoveryServerClient.getRoomCode());
+            }
+
             ViewManager.getInstance().getPlayerList().addListener((ListChangeListener<String>) c -> Platform.runLater(this::refreshPlayerList));
 
             ViewManager.getInstance().getPlayerList().setAll(ViewManager.getInstance().getPlayerList().sorted());
@@ -112,13 +132,13 @@ public class LobbyController implements Initializable {
 
     private JFXDialog createCustomizeDialog() {
         FXMLLoader dialog = new FXMLLoader(
-            getClass().getResource("/views/dialogs/BoatCustomizeDialog.fxml"));
+                getClass().getResource("/views/dialogs/BoatCustomizeDialog.fxml"));
 
         JFXDialog customizationDialog = null;
 
         try {
             customizationDialog = new JFXDialog(serverListMainStackPane, dialog.load(),
-                JFXDialog.DialogTransition.CENTER);
+                    JFXDialog.DialogTransition.CENTER);
         } catch (IOException e) {
             e.printStackTrace();
         }
@@ -136,44 +156,30 @@ public class LobbyController implements Initializable {
         return customizationDialog;
     }
 
-    /**
-     *
-     */
-    private void refreshMapView(){
-        RaceXMLData raceData = ViewManager.getInstance().getGameClient().getCourseData();
-        List<Limit> border = raceData.getCourseLimit();
-        List<CompoundMark> marks = new ArrayList<CompoundMark>(raceData.getCompoundMarks().values());
-        List<Corner> corners = raceData.getMarkSequence();
-
-        gameView.setSize(mapWidth, mapHeight);
-
-        // Update game view
-        gameView.updateBorder(border);
-        gameView.updateCourse(marks, corners);
-    }
 
     /**
      * Initializes a top down preview of the race course map.
      */
     private void initMapPreview() {
-        gameView = new GameView();
-        gameView.setHorizontalBuffer(330d);
+        RaceXMLData raceData = ViewManager.getInstance().getGameClient().getCourseData();
+        List<Limit> border = raceData.getCourseLimit();
+        List<CompoundMark> marks = new ArrayList<>(raceData.getCompoundMarks().values());
+        List<Corner> corners = raceData.getMarkSequence();
 
-        mapWidth = 770d;
-        mapHeight = 574d;
-
-        // Add game view
+        mapPreview = new MapPreview(marks, corners, border);
         serverMap.getChildren().clear();
-        serverMap.getChildren().add(gameView);
+        serverMap.getChildren().add(mapPreview.getAssets());
+
+        mapPreview.setSize(mapWidth, mapHeight);
 
         serverMap.widthProperty().addListener((observable, oldValue, newValue) -> {
             mapWidth = newValue.doubleValue();
-            refreshMapView();
+            mapPreview.setSize(mapWidth, mapHeight);
         });
-
+//
         serverMap.heightProperty().addListener((observable, oldValue, newValue) -> {
             mapHeight = newValue.doubleValue();
-            refreshMapView();
+            mapPreview.setSize(mapWidth, mapHeight);
         });
     }
 
@@ -245,4 +251,8 @@ public class LobbyController implements Initializable {
     public void closeCustomizationDialog() {
         customizationDialog.close();
     }
+
+    public void setRoomCode(String roomCode) {
+        roomLabel.setText("Room: " + roomCode);
+    }
 }

src/main/java/seng302/visualiser/controllers/RaceViewController.java

@@ -9,11 +9,10 @@ import java.util.Map;
 import java.util.Timer;
 import java.util.TimerTask;
 import java.util.concurrent.TimeUnit;
+import javafx.animation.RotateTransition;
 import javafx.animation.Timeline;
 import javafx.application.Platform;
 import javafx.beans.property.ReadOnlyBooleanProperty;
-import javafx.beans.value.ChangeListener;
-import javafx.beans.value.ObservableValue;
 import javafx.collections.FXCollections;
 import javafx.collections.ListChangeListener;
 import javafx.collections.ObservableList;
@@ -24,8 +23,6 @@ import javafx.scene.Scene;
 import javafx.scene.SubScene;
 import javafx.scene.chart.LineChart;
 import javafx.scene.chart.NumberAxis;
-import javafx.scene.chart.XYChart;
-import javafx.scene.chart.XYChart.Data;
 import javafx.scene.chart.XYChart.Series;
 import javafx.scene.control.Button;
 import javafx.scene.control.CheckBox;
@@ -33,6 +30,7 @@ import javafx.scene.control.ComboBox;
 import javafx.scene.control.Label;
 import javafx.scene.control.Slider;
 import javafx.scene.control.TextField;
+import javafx.scene.image.Image;
 import javafx.scene.image.ImageView;
 import javafx.scene.layout.AnchorPane;
 import javafx.scene.layout.GridPane;
@@ -46,11 +44,13 @@ import javafx.scene.shape.Polyline;
 import javafx.scene.text.Text;
 import javafx.stage.Stage;
 import javafx.stage.StageStyle;
+import javafx.util.Duration;
 import seng302.model.ClientYacht;
 import seng302.model.RaceState;
 import seng302.model.mark.CompoundMark;
 import seng302.model.mark.Mark;
 import seng302.model.stream.xml.parser.RaceXMLData;
+import seng302.model.token.TokenType;
 import seng302.utilities.Sounds;
 import seng302.visualiser.GameView3D;
 import seng302.visualiser.controllers.annotations.ImportantAnnotationController;
@@ -67,7 +67,13 @@ import seng302.visualiser.fxObjects.assets_3D.BoatObject;
 public class RaceViewController extends Thread implements ImportantAnnotationDelegate {
 
     private final int CHAT_LIMIT = 128;
+    private static final Double ICON_BLINK_TIMEOUT_RATIO = 0.6;
+    private static final Integer ICON_BLINK_PERIOD = 500;
 
+    @FXML
+    private AnchorPane loadingScreenPane;
+    @FXML
+    private ImageView loadingScreen;
     @FXML
     private Pane basePane;
     @FXML
@@ -110,6 +116,8 @@ public class RaceViewController extends Thread implements ImportantAnnotationDel
     private Label windSpeedLabel;
     @FXML
     private Label positionLabel, boatSpeedLabel, boatHeadingLabel;
+    @FXML
+    private ImageView velocityIcon, handlingIcon, windWalkerIcon, bumperIcon, badRandomIcon;
 
     //Race Data
     private Map<Integer, ClientYacht> participants;
@@ -130,36 +138,34 @@ public class RaceViewController extends Thread implements ImportantAnnotationDel
     private JFXDialog finishScreenDialog;
     private FinishDialogController finishDialogController;
 
+    //Icon stuff
+    private Timer blinkingTimer = new Timer();
+    private ImageView iconToDisplay;
+
+    private Double lastWindDirection;
+
     public void initialize() {
+        contentStackPane.setVisible(false);
+        Image loadingImage = new Image("PP.png");
+        loadingScreen.setImage(loadingImage);
+        //Centers the Image within the image view
+        double w = 0;
+        double h = 0;
+        double ratioX = loadingScreen.getFitWidth() / loadingImage.getWidth();
+        double ratioY = loadingScreen.getFitHeight() / loadingImage.getHeight();
+        double reduceRatio = 0;
+        if(ratioX >= ratioY) {
+            reduceRatio = ratioY;
+        } else {
+            reduceRatio = ratioX;
+        }
+        w = loadingImage.getWidth() * reduceRatio;
+        h = loadingImage.getHeight() * reduceRatio;
+        loadingScreen.setX((loadingScreen.getFitWidth() - w) / 2);
+        loadingScreen.setY((loadingScreen.getFitHeight() - h) / 2);
         Sounds.stopMusic();
         Sounds.playRaceMusic();
 
-        // Load a default important annotation state
-        //importantAnnotations = new ImportantAnnotationsState();
-
-        //Formatting the y axis of the sparkline
-//        raceSparkLine.getYAxis().setRotate(180);
-//        raceSparkLine.getYAxis().setTickLabelRotation(180);
-//        raceSparkLine.getYAxis().setTranslateX(-5);
-        //raceSparkLine.visibleProperty().setValue(false);
-        //raceSparkLine.getYAxis().setAutoRanging(false);
-        //sparklineYAxis.setTickMarkVisible(false);
-
-        //positionVbox.getStylesheets().add(getClass().getResource("/css/master.css").toString());
-//        raceSparkLine.visibleProperty().setValue(false);
-//        raceSparkLine.getYAxis().setAutoRanging(false);
-//        sparklineYAxis.setTickMarkVisible(false);
-//        positionVbox.getStylesheets().add(getClass().getResource("/css/master.css").toString());
-
-        //selectAnnotationBtn.setOnAction(event -> loadSelectAnnotationView());
-//        rvAnchorPane.prefWidthProperty().bind(ViewManager.getInstance().getDecorator().widthProperty());
-//        rvAnchorPane.prefHeightProperty().bind(ViewManager.getInstance().getDecorator().heightProperty());
-//        selectAnnotationBtn.setOnAction(event -> loadSelectAnnotationView());
-//        windArrowHolder.getChildren().addAll(windArrow);
-//        windArrow.setLayoutX(windArrowHolder.getWidth() / 2);
-//        windArrow.setLayoutY(windArrowHolder.getHeight() / 2);
-
-//        selectAnnotationBtn.setOnAction(event -> loadSelectAnnotationView());
         chatInput.lengthProperty().addListener((obs, oldLen, newLen) -> {
             if (newLen.intValue() > CHAT_LIMIT) {
                 chatInput.setText(chatInput.getText().substring(0, CHAT_LIMIT));
@@ -173,28 +179,21 @@ public class RaceViewController extends Thread implements ImportantAnnotationDel
         chatHistory.prefHeightProperty().bind(
             chatHistoryHolder.heightProperty()
         );
-//        chatHistory.setFitToWidth(true);
-//        chatHistory.setFitToHeight(true);
-//        chatHistory.textProperty().addListener((obs, oldValue, newValue) -> {
-//            chatHistory.setScrollTop(Double.MAX_VALUE);
-//        });
 
         contentStackPane.setOnMouseClicked(event -> {
             contentStackPane.requestFocus();
         });
-
+        Platform.runLater(contentStackPane::requestFocus);
         //Makes the chat history non transparent when clicked on
-        chatInput.focusedProperty().addListener(new ChangeListener<Boolean>() {
-            @Override
-            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue,
-                Boolean newValue) {
-                if (newValue) {
-                    chatHistory.increaseOpacity();
-                } else {
-                    chatHistory.decreaseOpacity();
-                }
+        chatInput.focusedProperty().addListener((observable, oldValue, newValue) -> {
+            if (newValue) {
+                chatHistory.increaseOpacity();
+            } else {
+                chatHistory.decreaseOpacity();
             }
         });
+
+        lastWindDirection = 0d;
     }
 
     public void showFinishDialog(ArrayList<ClientYacht> finishedBoats) {
@@ -202,6 +201,18 @@ public class RaceViewController extends Thread implements ImportantAnnotationDel
         createFinishDialog(finishedBoats);
     }
 
+    public void showView(){
+        loadingScreenPane.setVisible(false);
+        contentStackPane.setVisible(true);
+
+        Platform.runLater(new Runnable() {
+            @Override
+            public void run() {
+                contentStackPane.requestFocus();
+            }
+        });
+    }
+
     /**
      * Create finishScreenDialog and set up finishDialogController.
      */
@@ -222,6 +233,7 @@ public class RaceViewController extends Thread implements ImportantAnnotationDel
         });
     }
 
+
     public void loadRace (
         Map<Integer, ClientYacht> participants, RaceXMLData raceData, RaceState raceState,
         ClientYacht player) {
@@ -236,14 +248,15 @@ public class RaceViewController extends Thread implements ImportantAnnotationDel
             while (c.next()) {
                 if (c.wasPermutated()) {
                     updateOrder(raceState.getPlayerPositions());
-                    updateSparkLine();
                 }
             }
         });
 
+        player.addPowerUpListener(this::displayPowerUpIcon);
+        player.addPowerDownListener(this::removeIcon);
+
         updateOrder(raceState.getPlayerPositions());
         gameView = new GameView3D();
-//        gameView.setFrameRateFXText(fpsDisplay);
         Platform.runLater(() -> {
             contentStackPane.getChildren().add(0, gameView.getAssets());
             ((SubScene) gameView.getAssets()).widthProperty()
@@ -257,11 +270,10 @@ public class RaceViewController extends Thread implements ImportantAnnotationDel
         gameView.updateCourse(
             new ArrayList<>(raceData.getCompoundMarks().values()), raceData.getMarkSequence()
         );
-//        gameView.enableZoom();
         gameView.setBoatAsPlayer(player);
-//        gameView.startRace();
 
 //        raceState.addCollisionListener(gameView::drawCollision);
+
         raceState.windDirectionProperty().addListener((obs, oldDirection, newDirection) -> {
             gameView.setWindDir(newDirection.doubleValue());
             Platform.runLater(() -> updateWindDirection(newDirection.doubleValue()));
@@ -274,11 +286,71 @@ public class RaceViewController extends Thread implements ImportantAnnotationDel
             updateWindSpeed(raceState.getWindSpeed());
         });
         gameView.setWindDir(raceState.windDirectionProperty().doubleValue());
-        Platform.runLater(() -> {
-            initializeUpdateTimer();
-        });
+        Platform.runLater(this::initializeUpdateTimer);
     }
 
+    /**
+     * Displays the relevant icon, starts blinking it when it is close to turning off and then
+     * switches it off after the tokens time out
+     *
+     * @param yacht The yacht only for which we are displaying the icon
+     * @param tokenType The type of token, indicating what icon needs to be displayed
+     */
+    private void displayPowerUpIcon(ClientYacht yacht, TokenType tokenType) {
+        if (yacht == player) {
+            if (iconToDisplay != null) {
+                iconToDisplay.setVisible(false);
+            }
+
+            switch (tokenType) {
+                case BOOST:
+                    iconToDisplay = velocityIcon;
+                    break;
+                case HANDLING:
+                    iconToDisplay = handlingIcon;
+                    break;
+                case WIND_WALKER:
+                    iconToDisplay = windWalkerIcon;
+                    break;
+                case BUMPER:
+                    iconToDisplay = bumperIcon;
+                    break;
+                case RANDOM:
+                    iconToDisplay = badRandomIcon;
+                    break;
+                default:
+                    iconToDisplay = velocityIcon;
+            }
+
+            //Turn icon on
+            iconToDisplay.setVisible(true);
+
+            //Start blinking icon towards end
+            if (blinkingTimer != null) {
+                blinkingTimer.cancel();
+            }
+            blinkingTimer = new Timer("Blinking Timer");
+            blinkingTimer.schedule(new TimerTask() {
+                Boolean isVisible = true;
+
+                @Override
+                public void run() {
+                    isVisible = !isVisible;
+                    iconToDisplay.setVisible(isVisible);
+                }
+            }, (int) (tokenType.getTimeout() * ICON_BLINK_TIMEOUT_RATIO), ICON_BLINK_PERIOD);
+        }
+    }
+
+    public void removeIcon(ClientYacht yacht) {
+        if (yacht == player) {
+            blinkingTimer.cancel();
+            iconToDisplay.setVisible(false);
+            iconToDisplay = null;
+        }
+    }
+
+
     /**
      * The important annotations have been changed, update this view
      *
@@ -317,137 +389,6 @@ public class RaceViewController extends Thread implements ImportantAnnotationDel
         }
     }
 
-    private void initialiseFPSCheckBox() {
-//        toggleFps.selectedProperty().addListener((obs, oldVal, newVal) ->
-//            gameView.setFPSVisibility(toggleFps.isSelected())
-//        );
-    }
-
-    private void initialiseAnnotationSlider() {
-//        annotationSlider.setLabelFormatter(new StringConverter<Double>() {
-//            @Override
-//            public String toString(Double n) {
-//                if (n == 0) {
-//                    return "None";
-//                }
-//                if (n == 1) {
-//                    return "Important";
-//                }
-//                if (n == 2) {
-//                    return "All";
-//                }
-//                return "All";
-//            }
-//
-//            @Override
-//            public Double fromString(String s) {
-//                switch (s) {
-//                    case "None":
-//                        return 0d;
-//                    case "Important":
-//                        return 1d;
-//                    case "All":
-//                        return 2d;
-//
-//                    default:
-//                        return 2d;
-//                }
-//            }
-//        });
-//        annotationSlider.setValue(2);
-//        annotationSlider.valueProperty().addListener((obs, oldVal, newVal) ->
-//            setAnnotations((int) annotationSlider.getValue())
-//        );
-    }
-
-
-    /**
-     * Used to add any new yachts into the race that may have started late or not have had data received yet
-     */
-    private void updateSparkLine(){
-//        // TODO: 2/08/17 there is about 0 chance of this working. Once we are keeping track of boat positions it can be fixed.
-//        // Collect the racing yachts that aren't already in the chart
-//        sparkLineData.clear();
-//        List<ClientYacht> sparkLineCandidates = new ArrayList<>(participants.values());
-//        // Create a new data series for new yachts
-//        sparkLineCandidates
-//            .stream()
-//            .filter(yacht -> yacht.getPosition() != null)
-//            .forEach(yacht -> {
-//                Series<String, Double> yachtData = new Series<>();
-//                yachtData.setName(yacht.getSourceId().toString());
-//                yachtData.getData().add(
-//                    new Data<>(
-//                        Integer.toString(yacht.getLegNumber()),
-//                        1.0 + participants.size() - yacht.getPosition()
-//                    )
-//                );
-//            sparkLineData.add(yachtData);
-//            });
-//
-//        // Lambda function to sort the series in order of leg (later legs shown more to the right)
-//        sparkLineData.sort((o1, o2) -> {
-//            Integer leg1 =  Integer.parseInt(o1.getData().get(o1.getData().size()-1).getXValue());
-//            Integer leg2 =  Integer.parseInt(o2.getData().get(o2.getData().size()-1).getXValue());
-//            if (leg2 < leg1){
-//                return 1;
-//            } else {
-//                return -1;
-//            }
-//        });
-//
-//        // Adds the new data series to the sparkline (and set the colour of the series)
-//        Platform.runLater(() -> {
-//            sparkLineData
-//                .stream()
-//                .filter(spark -> !raceSparkLine.getData().contains(spark))
-//                .forEach(spark -> {
-//                    raceSparkLine.getData().add(spark);
-//                    spark.getNode().lookup(".chart-series-line").setStyle("-fx-stroke:" + getBoatColorAsRGB(spark.getName()));
-//                });
-//        });
-    }
-
-    private void initialiseSparkLine() {
-//        sparklineYAxis.setUpperBound(participants.size() + 1);
-//        raceSparkLine.setCreateSymbols(false);
-    }
-
-    /**
-     * Updates the yachts sparkline of the desired yacht and using the new leg number
-     * @param yacht The yacht to be updated on the sparkline
-     * @param legNumber the leg number that the position will be assigned to
-     */
-    void updateYachtPositionSparkline(ClientYacht yacht, Integer legNumber){
-        for (XYChart.Series<String, Double> positionData : sparkLineData) {
-            positionData.getData().add(
-                new Data<>(
-                    Integer.toString(legNumber),
-                    1.0 + participants.size() - yacht.getPlacing()
-                )
-            );
-        }
-    }
-
-
-    /**
-     * gets the rgb string of the yachts colour to use for the chart via css
-     * @param yachtId id of yacht passed in to get the yachts colour
-     * @return the colour as an rgb string
-     */
-    private String getBoatColorAsRGB(String yachtId){
-        Color color = participants.get(Integer.valueOf(yachtId)).getColour();
-        if (color == null){
-            return String.format("#%02X%02X%02X",255,255,255);
-        }
-        return String.format( "#%02X%02X%02X",
-            (int)( color.getRed() * 255 ),
-            (int)( color.getGreen() * 255 ),
-            (int)( color.getBlue() * 255 )
-        );
-    }
-
-
     /**
      * Initialises a timer which updates elements of the RaceView such as wind direction, yacht
      * orderings etc.. which are dependent on the info from the stream parser constantly.
@@ -500,7 +441,13 @@ public class RaceViewController extends Thread implements ImportantAnnotationDel
      */
     private void updateWindDirection(double direction) {
         windDirectionLabel.setText(String.format("%.1f°", direction));
-        windImageView.setRotate(direction);
+        RotateTransition rt = new RotateTransition(Duration.millis(300), windImageView);
+        rt.setByAngle(direction - lastWindDirection);
+        rt.setCycleCount(3);
+        rt.setAutoReverse(true);
+        rt.play();
+        lastWindDirection = direction;
+//        windImageView.setRotate(direction);
     }
 
     /**

src/main/java/seng302/visualiser/controllers/ServerListController.java

@@ -7,6 +7,7 @@ import com.jfoenix.controls.JFXTextField;
 import com.jfoenix.validation.RequiredFieldValidator;
 import java.io.IOException;
 import java.net.URL;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.ResourceBundle;
@@ -22,11 +23,22 @@ import javafx.scene.layout.StackPane;
 import javafx.scene.layout.VBox;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import seng302.discoveryServer.DiscoveryServerClient;
+import seng302.discoveryServer.util.ServerListing;
 import seng302.gameServer.ServerDescription;
+import seng302.gameServer.messages.ServerRegistrationMessage;
 import seng302.utilities.Sounds;
 import seng302.visualiser.ServerListener;
 import seng302.visualiser.ServerListenerDelegate;
 import seng302.visualiser.controllers.cells.ServerCell;
+import seng302.visualiser.controllers.dialogs.DirectConnectController;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.Arrays;
+import java.util.List;
+import java.util.ResourceBundle;
+import seng302.visualiser.controllers.dialogs.ServerCreationController;
 import seng302.visualiser.validators.HostNameFieldValidator;
 import seng302.visualiser.validators.NumberRangeValidator;
 import seng302.visualiser.validators.ValidationTools;
@@ -46,15 +58,29 @@ public class ServerListController implements Initializable, ServerListenerDelega
     private JFXButton serverListHostButton;
     //Direct Connect
     @FXML
-    private JFXButton connectButton;
-    @FXML
-    private JFXTextField serverHostName;
+    private JFXButton directConnectButton;
     @FXML
     private JFXTextField serverPortNumber;
+    @FXML
+    private JFXButton roomConnectButton;
+    @FXML
+    private JFXTextField roomNumber;
+    @FXML
+    private JFXButton autoSelectGame;
     //---------FXML END---------//
 
     private Label noServersFound;
     private Logger logger = LoggerFactory.getLogger(ServerListController.class);
+    private JFXDialog directConnectDialog;
+
+    private JFXDialog serverCreationDialog;
+    private List<ServerCreationDialogListener> serverCreationDialogListeners = new ArrayList<>();
+
+    @FunctionalInterface
+    public interface ServerCreationDialogListener {
+
+        void notifyClosure();
+    }
 
     // TODO: 12/09/17 ajm412: break this method down, its way too long.
     @Override
@@ -62,13 +88,25 @@ public class ServerListController implements Initializable, ServerListenerDelega
         serverListVBox.minWidthProperty().bind(serverListScrollPane.widthProperty());
 
         // Set Event Bindings
-        connectButton.setOnMouseEntered(event -> Sounds.playHoverSound());
+        directConnectButton.setOnMouseEntered(event -> Sounds.playHoverSound());
         serverListHostButton.setOnMouseEntered(event -> Sounds.playHoverSound());
-        connectButton.setOnMouseReleased(event -> {
-            attemptToDirectConnect();
+
+
+
+        roomNumber.setOnKeyPressed(event -> {
+            if (event.getCode().equals(KeyCode.ENTER)) {
+                connectToRoomCode(roomNumber.getText());
+            }
+        });
+
+        directConnectButton.setOnMouseReleased(event -> {
+            directConnectDialog.show();
             Sounds.playButtonClick();
         });
-        for (JFXTextField textField : Arrays.asList(serverHostName, serverPortNumber)) {
+
+        directConnectDialog = createDirectConnectDialog();
+
+        for (JFXTextField textField : Arrays.asList(roomNumber)) {
             // Event for pressing enter to submit direct connection
             textField.setOnKeyPressed(event -> {
                 if (event.getCode().equals(KeyCode.ENTER)) {
@@ -82,15 +120,41 @@ public class ServerListController implements Initializable, ServerListenerDelega
             textField.getValidators().add(validator);
         }
 
+        autoSelectGame.setOnMouseReleased(e -> {
+            ServerListing listing;
+            DiscoveryServerClient client = new DiscoveryServerClient();
+
+            try {
+                listing = client.getRandomServer();
+            } catch (Exception e1) {
+                ViewManager.getInstance().showErrorSnackBar("Unable to connect to matchmaking server. Are you connected to the internet?");
+                return;
+            }
+
+            if (client.didFail()){
+                return;
+            }
+
+            if (listing == null || listing.equals(ServerRegistrationMessage.getEmptyRegistration())) {
+                ViewManager.getInstance().showErrorSnackBar("There are currently no servers available for you to connect to.");
+                return;
+            }
+
+            ViewManager.getInstance().getGameClient().runAsClient(listing.getAddress(), listing.getPortNumber());
+        });
+
+        /*
         // Validating the hostname
         HostNameFieldValidator hostNameValidator = new HostNameFieldValidator();
         hostNameValidator.setMessage("Host name incorrect");
-        serverHostName.getValidators().add(hostNameValidator);
+        roomCodeInput.getValidators().add(hostNameValidator);
 
         // Validating the port number
         NumberRangeValidator portNumberValidator = new NumberRangeValidator(1025, 65536);
         portNumberValidator.setMessage("Port number incorrect");
         serverPortNumber.getValidators().add(portNumberValidator);
+        TODO later
+        */
 
         // Start listening for servers on network
         try {
@@ -111,10 +175,17 @@ public class ServerListController implements Initializable, ServerListenerDelega
         );
         serverListVBox.getChildren().add(noServersFound);
 
+        roomConnectButton.setOnMouseReleased(e -> {
+            String roomCode = roomNumber.getText();
+            connectToRoomCode(roomCode);
+        });
+
         // Set up dialog for server creation
         serverListHostButton.setOnAction(action -> {
             showServerCreationDialog();
         });
+
+        addServerCreationDialogListener(this::closeServerCreationDialog);
     }
 
     /**
@@ -125,23 +196,48 @@ public class ServerListController implements Initializable, ServerListenerDelega
             FXMLLoader dialogContent = new FXMLLoader(getClass().getResource(
                 "/views/dialogs/ServerCreationDialog.fxml"));
             try {
-                JFXDialog dialog = new JFXDialog(serverListMainStackPane, dialogContent.load(),
+                serverCreationDialog = new JFXDialog(serverListMainStackPane, dialogContent.load(),
                     DialogTransition.CENTER);
-                dialog.show();
+                ServerCreationController serverCreationController = dialogContent.getController();
+                serverCreationController.setListener(serverCreationDialogListeners);
+                serverCreationDialog.show();
                 Sounds.playButtonClick();
             } catch (IOException e) {
+                e.printStackTrace();
                 logger.warn("Could not create Server Creation Dialog.");
             }
         });
     }
 
+    private JFXDialog createDirectConnectDialog() {
+        FXMLLoader dialog = new FXMLLoader(
+                getClass().getResource("/views/dialogs/DirectConnect.fxml"));
+
+        JFXDialog dcDialog = null;
+
+        try {
+            dcDialog = new JFXDialog(serverListMainStackPane, dialog.load(),
+                    JFXDialog.DialogTransition.CENTER);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        DirectConnectController controller = dialog.getController();
+
+        return dcDialog;
+    }
+
+    private void closeServerCreationDialog() {
+        serverCreationDialog.close();
+    }
+
     /**
      * Validates the connection and attempts to connect to a given hostname and port number.
      */
     private void attemptToDirectConnect() {
-        if (validateDirectConnection(serverHostName.getText(), serverPortNumber.getText())) {
+        /*if (validateDirectConnection(serverHostName.getText(), serverPortNumber.getText())) {
             DirectConnect();
-        }
+        }*/
     }
 
     /**
@@ -151,10 +247,40 @@ public class ServerListController implements Initializable, ServerListenerDelega
      * @return boolean value if host and port number are valid values
      */
     private Boolean validateDirectConnection(String hostName, String portNumber) {
-        Boolean hostNameValid = ValidationTools.validateTextField(serverHostName);
+        /*Boolean hostNameValid = ValidationTools.validateTextField(serverHostName);
+        *
         Boolean portNumberValid = ValidationTools.validateTextField(serverPortNumber);
 
-        return hostNameValid && portNumberValid;
+        return hostNameValid && portNumberValid;*/
+        return true;
+    }
+
+    private void connectToRoomCode(String roomCode){
+        DiscoveryServerClient client = new DiscoveryServerClient();
+        ServerListing serverListing;
+
+        if (client.didFail()){
+            return;
+        }
+
+        try {
+            serverListing = client.getServerForRoomCode(roomCode);
+        } catch (Exception e) {
+            ViewManager.getInstance().showErrorSnackBar("Error connecting to matchmaking server. Please try again later.");
+            return;
+        }
+
+        if (serverListing == null || serverListing.equals(new ServerListing("","","", 0, 0))){
+            ViewManager.getInstance().showErrorSnackBar("No servers could be found with that room code.");
+            return;
+        }
+
+        try {
+            ViewManager.getInstance().getGameClient().runAsClient(serverListing.getAddress(), serverListing.getPortNumber());
+        }
+        catch (Exception e) {
+            ViewManager.getInstance().showErrorSnackBar("Error connecting to matchmaking service.");
+        }
     }
 
     /**
@@ -162,7 +288,7 @@ public class ServerListController implements Initializable, ServerListenerDelega
      */
     private void DirectConnect() {
         Sounds.playButtonClick();
-        ViewManager.getInstance().getGameClient().runAsClient(serverHostName.getText(), Integer.parseInt(serverPortNumber.getText()));
+       // ViewManager.getInstance().getGameClient().runAsClient(serverHostName.getText(), Integer.parseInt(serverPortNumber.getText()));
     }
 
     /**
@@ -203,4 +329,14 @@ public class ServerListController implements Initializable, ServerListenerDelega
     public void serverDetected(ServerDescription serverDescription, List<ServerDescription> servers) {
         Platform.runLater(() -> refreshServers(servers));
     }
+
+    private void addServerCreationDialogListener(
+        ServerCreationDialogListener serverCreationDialogListener) {
+        serverCreationDialogListeners.add(serverCreationDialogListener);
+    }
+
+    private void removeServerCreationDialogListener(
+        ServerCreationDialogListener serverCreationDialogListener) {
+        serverCreationDialogListeners.remove(serverCreationDialogListener);
+    }
 }

src/main/java/seng302/visualiser/controllers/SplashScreenController.java

@@ -0,0 +1,58 @@
+package seng302.visualiser.controllers;
+
+import com.jfoenix.controls.JFXDecorator;
+import com.jfoenix.controls.JFXSnackbar;
+import javafx.application.Platform;
+import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.fxml.Initializable;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.SceneAntialiasing;
+import javafx.scene.image.Image;
+import javafx.scene.layout.StackPane;
+import javafx.stage.Stage;
+import seng302.gameServer.ServerAdvertiser;
+import seng302.utilities.Sounds;
+import seng302.visualiser.GameClient;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.ResourceBundle;
+
+/**
+ * Created by Kusal on 26-Sep-17.
+ */
+public class SplashScreenController implements Initializable{
+
+    @FXML
+    private StackPane rootPane;
+
+    @Override
+    public void initialize(URL location, ResourceBundle resources) {
+        new SplashScreen().start();
+    }
+
+
+    class SplashScreen extends Thread {
+        public void run(){
+            try {
+                Thread.sleep(2000);
+                Platform.runLater(new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            Stage stage = new Stage();
+                            ViewManager.getInstance().initialStartView(stage);
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                        }
+                        rootPane.getScene().getWindow().hide();
+                    }
+                });
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}

src/main/java/seng302/visualiser/controllers/StartScreenController.java

@@ -59,7 +59,7 @@ public class StartScreenController implements Initializable{
     /**
      * Changes the view to the Server Browser.
      */
-    private void goToServerBrowser() {
+    public void goToServerBrowser() {
         try {
             ViewManager.getInstance().setScene(serverList);
         } catch (Exception e) {

src/main/java/seng302/visualiser/controllers/ViewManager.java

@@ -6,28 +6,26 @@ import com.jfoenix.controls.JFXDialog;
 import com.jfoenix.controls.JFXDialog.DialogTransition;
 import com.jfoenix.controls.JFXSnackbar;
 import com.jfoenix.svg.SVGGlyph;
-import java.io.IOException;
-import java.util.HashMap;
 import javafx.application.Platform;
 import javafx.collections.ObservableList;
 import javafx.fxml.FXMLLoader;
-import javafx.scene.Cursor;
-import javafx.scene.Node;
-import javafx.scene.Parent;
-import javafx.scene.Scene;
-import javafx.scene.SceneAntialiasing;
+import javafx.scene.*;
 import javafx.scene.image.Image;
 import javafx.scene.layout.HBox;
 import javafx.scene.layout.StackPane;
 import javafx.scene.paint.Color;
 import javafx.stage.Stage;
+import javafx.stage.StageStyle;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import seng302.gameServer.ServerAdvertiser;
-import seng302.utilities.BonjourInstallChecker;
 import seng302.utilities.Sounds;
 import seng302.visualiser.GameClient;
 import seng302.visualiser.controllers.dialogs.KeyBindingDialogController;
+import seng302.visualiser.controllers.dialogs.PopupDialogController;
+
+import java.io.IOException;
+import java.util.HashMap;
 
 public class ViewManager {
 
@@ -55,10 +53,20 @@ public class ViewManager {
         if (instance == null) {
             instance = new ViewManager();
         }
-
         return instance;
     }
 
+    public void initialiseSplashScreen(Stage stage) throws IOException {
+        this.stage = stage;
+        Parent root = FXMLLoader.load(getClass().getResource("/views/SplashScreen.fxml"));
+        Scene scene = new Scene(root);
+        stage.setTitle("Party Parrots At Sea");
+        stage.getIcons().add(new Image(getClass().getResourceAsStream("/PP.png")));
+        stage.setScene(scene);
+        stage.initStyle(StageStyle.UNDECORATED);
+        stage.show();
+    }
+
     /**
      * Initialize the start view in the given stage.
      */
@@ -66,7 +74,6 @@ public class ViewManager {
         this.stage = stage;
         Parent root = FXMLLoader.load(getClass().getResource("/views/StartScreenView.fxml"));
         stage.setTitle("Party Parrots At Sea");
-
         JFXDecorator decorator = new JFXDecorator(stage, root, false, true, true);
         decorator.setCustomMaximize(true);
         decorator.applyCss();
@@ -101,8 +108,6 @@ public class ViewManager {
             gameClient.stopGame();
             System.exit(0);
         });
-
-        jfxSnackbar = new JFXSnackbar(decorator);
     }
 
     /**
@@ -187,6 +192,7 @@ public class ViewManager {
             }
         });
 
+        jfxSnackbar = new JFXSnackbar(decorator);
     }
 
     /**
@@ -220,6 +226,7 @@ public class ViewManager {
                     .getController();
                 keyBindingDialogController.setGameClient(this.gameClient);
                 keyBindingDialog.show();
+                decorator.requestFocus();
                 Sounds.playButtonClick();
             }
         }
@@ -229,6 +236,26 @@ public class ViewManager {
         keyBindingDialog.close();
     }
 
+    public PopupDialogController showPopupDialog() {
+        FXMLLoader dialogContent = new FXMLLoader(
+            getClass().getResource("/views/dialogs/PopupDialog.fxml"));
+        for (Node node : decorator.getChildren()) {
+            if (node instanceof StackPane) {
+                try {
+                    JFXDialog dialog = new JFXDialog((StackPane) node, dialogContent.load(),
+                        DialogTransition.CENTER);
+                    PopupDialogController popupDialogController = dialogContent.getController();
+                    popupDialogController.setPopupDialog(dialog);
+                    dialog.show();
+                    return popupDialogController;
+                } catch (IOException e) {
+                    logger.error("Cannot load Popup dialog");
+                }
+            }
+        }
+        return null;
+    }
+
     /**
      * Show a snackbar at the bottom of the app for 1 second.
      *
@@ -246,16 +273,9 @@ public class ViewManager {
         jfxSnackbar.show(snackbarText, 1500);
     }
 
-    /**
-     * Determines if a PC has compatibility with the bonjour protocol for server detection.
-     */
-    private void checkCompatibility() {
-        if (BonjourInstallChecker.isBonjourSupported()) {
-            BonjourInstallChecker.openInstallUrl();
-        }
-    }
-
     private void closeAll() {
+        if (stage!= null) stage.close();
+
         try {
             ServerAdvertiser.getInstance().unregister();
         } catch (IOException e1) {
@@ -321,8 +341,9 @@ public class ViewManager {
             logger.error("Could not load lobby view");
         }
 
+        LobbyController lobbyController = loader.getController();
+
         if (disableReadyButton) {
-            LobbyController lobbyController = loader.getController();
             lobbyController.disableReadyButton();
         }
 
@@ -334,7 +355,6 @@ public class ViewManager {
      *
      * @return A RaceViewController for the race view screen.
      */
-
     public RaceViewController loadRaceView() {
         FXMLLoader loader = loadFxml("/views/RaceView.fxml");
         // have to create a new stage and set the race view maximized as JFoenix decorator has
@@ -379,6 +399,14 @@ public class ViewManager {
         return loader.getController();
     }
 
+    public void showErrorSnackBar(String msg){
+        decorator.getStylesheets()
+                .add(getClass().getResource("/css/dialogs/Snackbar.css").toExternalForm());
+
+        JFXSnackbar bar = new JFXSnackbar(decorator);
+        bar.enqueue(new JFXSnackbar.SnackbarEvent(msg));
+    }
+
     public Stage getStage() {
         return stage;
     }

src/main/java/seng302/visualiser/controllers/dialogs/DirectConnectController.java

@@ -0,0 +1,70 @@
+package seng302.visualiser.controllers.dialogs;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXSlider;
+import com.jfoenix.controls.JFXTextField;
+import com.jfoenix.validation.RequiredFieldValidator;
+import java.net.URL;
+import java.util.ResourceBundle;
+import javafx.application.Platform;
+import javafx.fxml.FXML;
+import javafx.fxml.Initializable;
+import javafx.scene.control.Label;
+import javafx.scene.input.MouseEvent;
+import seng302.gameServer.ServerDescription;
+import seng302.utilities.Sounds;
+import seng302.visualiser.controllers.ViewManager;
+import seng302.visualiser.validators.FieldLengthValidator;
+import seng302.visualiser.validators.ValidationTools;
+
+public class DirectConnectController implements Initializable {
+
+    //--------FXML BEGIN--------//
+    @FXML
+    private JFXTextField serverAddress;
+    @FXML
+    private JFXTextField portNumber;
+    @FXML
+    private JFXButton submitBtn;
+    //---------FXML END---------//
+
+    public void initialize(URL location, ResourceBundle resources) {
+        FieldLengthValidator fieldLengthValidator = new FieldLengthValidator(40);
+        fieldLengthValidator.setMessage("Too long.");
+
+        RequiredFieldValidator fieldRequiredValidator = new RequiredFieldValidator();
+        fieldRequiredValidator.setMessage("Required.");
+
+        serverAddress.setValidators(fieldLengthValidator, fieldRequiredValidator);
+        portNumber.setValidators(fieldLengthValidator, fieldRequiredValidator);
+
+        submitBtn.setOnMouseReleased(event -> {
+            Sounds.playButtonClick();
+            connectToServer();
+        });
+
+    }
+
+    /**
+     * connects to the server
+     */
+    private void connectToServer() {
+        //TODO fix port number validation
+
+        try{
+            Integer.parseInt(portNumber.getText());
+        }
+        catch (NumberFormatException e){
+            ViewManager.getInstance().showErrorSnackBar("You need to enter a valid port number");
+            return;
+        }
+
+        ViewManager.getInstance().getGameClient()
+                .runAsClient(serverAddress.getText(), Integer.parseInt(portNumber.getText()));
+    }
+
+    public void playButtonHoverSound(MouseEvent mouseEvent) {
+        Sounds.playHoverSound();
+    }
+
+}

src/main/java/seng302/visualiser/controllers/dialogs/KeyBindingDialogController.java

@@ -48,6 +48,16 @@ public class KeyBindingDialogController implements Initializable {
     private Label downwindLabel;
     @FXML
     private JFXToggleButton turningToggle;
+    @FXML
+    private JFXButton viewButton;
+    @FXML
+    private JFXButton rightButton;
+    @FXML
+    private JFXButton leftButton;
+    @FXML
+    private JFXButton forwardButton;
+    @FXML
+    private JFXButton backwardButton;
     //---------FXML END---------//
 
     private GameKeyBind gameKeyBind;
@@ -60,7 +70,8 @@ public class KeyBindingDialogController implements Initializable {
         gameKeyBind = GameKeyBind.getInstance();
         buttons = new ArrayList<>();
         Collections.addAll(buttons,
-            zoomInbtn, zoomOutBtn, vmgBtn, sailInOutBtn, tackGybeBtn, upwindBtn, downwindBtn);
+            zoomInbtn, zoomOutBtn, vmgBtn, sailInOutBtn, tackGybeBtn, upwindBtn, downwindBtn,
+            viewButton, rightButton, leftButton, forwardButton, backwardButton);
         bindButtonWithAction();
         loadKeyBind();
 
@@ -76,12 +87,10 @@ public class KeyBindingDialogController implements Initializable {
         resetBtn.setOnMouseClicked(event -> {
             gameKeyBind.setToDefault();
             loadKeyBind();
+            showSnackBar("All keys reset!", false);
         });
 
         closeLabel.setOnMouseClicked(event -> ViewManager.getInstance().closeKeyBindingDialog());
-
-        keyBindingDialogHeader.setFocusTraversable(true);
-        keyBindingDialogHeader.requestFocus();
     }
 
     /**
@@ -106,7 +115,7 @@ public class KeyBindingDialogController implements Initializable {
      */
     private void bindButtonWithAction() {
         buttonActionMap = new HashMap<>();
-        for (int i = 0; i < 7; i++) {
+        for (int i = 0; i < 12; i++) {
             buttonActionMap.put(buttons.get(i), KeyAction.getType(i + 1));
         }
     }
@@ -149,6 +158,7 @@ public class KeyBindingDialogController implements Initializable {
             + "-fx-background-color: -fx-pp-front-color; "
             + "-fx-text-fill: -fx-pp-theme-color; "
             + "-fx-font-size: 13;");
+        keyBindingDialogHeader.requestFocus();
     }
 
     /**

src/main/java/seng302/visualiser/controllers/dialogs/PopupDialogController.java

@@ -0,0 +1,56 @@
+package seng302.visualiser.controllers.dialogs;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXDialog;
+import java.net.URL;
+import java.util.ResourceBundle;
+import javafx.event.EventHandler;
+import javafx.fxml.FXML;
+import javafx.fxml.Initializable;
+import javafx.scene.control.Label;
+import javafx.scene.input.MouseEvent;
+
+public class PopupDialogController implements Initializable {
+
+    @FXML
+    private Label headerLabel;
+    @FXML
+    private Label contentLabel;
+    @FXML
+    private Label closeLabel;
+    @FXML
+    private JFXButton optionButton;
+
+    @FXML
+    private JFXDialog popupDialog;
+
+    @Override
+    public void initialize(URL location, ResourceBundle resources) {
+
+    }
+
+    public void setContent(String content) {
+        this.contentLabel.setText(content);
+    }
+
+    public void setHeader(String header) {
+        this.headerLabel.setText(header);
+    }
+
+    public void setOptionButton(JFXButton jfxButton) {
+        this.optionButton = jfxButton;
+    }
+
+    public void setOptionButtonText(String text) {
+        this.optionButton.setText(text);
+    }
+
+    public void setOptionButtonEventHandler(EventHandler<? super MouseEvent> eventHandler) {
+        this.optionButton.setOnMouseClicked(eventHandler);
+    }
+
+    public void setPopupDialog(JFXDialog popupDialog) {
+        this.popupDialog = popupDialog;
+        this.closeLabel.setOnMouseClicked(event -> this.popupDialog.close());
+    }
+}

src/main/java/seng302/visualiser/controllers/dialogs/ServerCreationController.java

@@ -1,18 +1,21 @@
 package seng302.visualiser.controllers.dialogs;
 
 import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXCheckBox;
 import com.jfoenix.controls.JFXSlider;
 import com.jfoenix.controls.JFXTextField;
 import com.jfoenix.validation.RequiredFieldValidator;
 import java.net.URL;
+import java.util.List;
 import java.util.ResourceBundle;
-import javafx.application.Platform;
 import javafx.fxml.FXML;
 import javafx.fxml.Initializable;
 import javafx.scene.control.Label;
-import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.AnchorPane;
 import seng302.gameServer.ServerDescription;
 import seng302.utilities.Sounds;
+import seng302.visualiser.MapMaker;
+import seng302.visualiser.controllers.ServerListController.ServerCreationDialogListener;
 import seng302.visualiser.controllers.ViewManager;
 import seng302.visualiser.validators.FieldLengthValidator;
 import seng302.visualiser.validators.ValidationTools;
@@ -28,13 +31,44 @@ public class ServerCreationController implements Initializable {
     private Label maxPlayersLabel;
     @FXML
     private JFXButton submitBtn;
+    @FXML
+    private Label closeLabel;
+    @FXML
+    private JFXButton nextMapButton;
+    @FXML
+    private JFXButton lastMapButton;
+    @FXML
+    private Label mapNameLabel;
+    @FXML
+    private JFXSlider legsSlider;
+    @FXML
+    private Label legsSliderLabel;
+    @FXML
+    private JFXCheckBox pickupsCheckBox;
+    @FXML
+    private AnchorPane mapHolder;
+
+    private MapMaker mapMaker = MapMaker.getInstance();
+
     //---------FXML END---------//
 
+    private List<ServerCreationDialogListener> serverCreationDialogListeners;
+
     public void initialize(URL location, ResourceBundle resources) {
+
+        maxPlayersSlider.valueProperty().addListener(
+            (observable, oldValue, newValue) -> updateMaxPlayerLabel()
+        );
+        maxPlayersSlider.setMax(mapMaker.getMaxPlayers());
+        maxPlayersSlider.setValue(mapMaker.getMaxPlayers());
+
+        legsSlider.valueProperty().addListener(
+            (obs, oldVal, newVal) -> updateLegSliderLabel()
+        );
+        legsSlider.setMax(10);
+
         updateMaxPlayerLabel();
-        maxPlayersSlider.valueProperty().addListener((observable, oldValue, newValue) -> {
-            updateMaxPlayerLabel();
-        });
+        updateLegSliderLabel();
 
         FieldLengthValidator fieldLengthValidator = new FieldLengthValidator(40);
         fieldLengthValidator.setMessage("Server name too long.");
@@ -49,6 +83,20 @@ public class ServerCreationController implements Initializable {
             validateServerSettings();
         });
 
+        nextMapButton.setOnMouseReleased(event -> {
+            Sounds.playButtonClick();
+            nextMap();
+        });
+
+        lastMapButton.setOnMouseReleased(event -> {
+            Sounds.playButtonClick();
+            lastMap();
+        });
+
+        mapHolder.getChildren().setAll(mapMaker.getCurrentGameView());
+        mapNameLabel.setText(mapMaker.getCurrentRegatta().getCourseName());
+        pickupsCheckBox.setSelected(true);
+        //closeLabel.setOnMouseClicked(event -> notifyListeners());
     }
 
     /**
@@ -69,7 +117,13 @@ public class ServerCreationController implements Initializable {
     private void createServer() {
         ServerDescription serverDescription = ViewManager.getInstance().getGameClient()
             .runAsHost("localhost", 4941, serverName.getText(), (int) maxPlayersSlider
-                .getValue());
+                .getValue(), mapMaker.getCurrentRacePath(), (int) legsSlider.getValue(), pickupsCheckBox.isSelected());
+
+        if (serverDescription == null){
+            ViewManager.getInstance().getGameClient().getServerThread().closeSocket();
+            ViewManager.getInstance().getGameClient().stopGame();
+            return;
+        }
 
         ViewManager.getInstance().setProperty("serverName", serverDescription.getName());
         ViewManager.getInstance().setProperty("mapName", serverDescription.getMapName());
@@ -80,11 +134,46 @@ public class ServerCreationController implements Initializable {
      */
     private void updateMaxPlayerLabel() {
         maxPlayersSlider.setValue(Math.floor(maxPlayersSlider.getValue()));
-        maxPlayersLabel.setText(String.format("YOU SELECTED: %.0f", maxPlayersSlider.getValue()));
+        maxPlayersLabel.setText(String.format("Max players: %.0f", maxPlayersSlider.getValue()));
     }
 
-    public void playButtonHoverSound(MouseEvent mouseEvent) {
+    private void updateLegSliderLabel() {
+        legsSlider.setValue(Math.floor(legsSlider.getValue()));
+        legsSliderLabel.setText(
+            String.format("A section of the race will repeat %.0f times", legsSlider.getValue())
+        );
+
+    }
+
+    public void playButtonHoverSound() {
         Sounds.playHoverSound();
     }
 
+    private void nextMap() {
+        mapMaker.next();
+        updateMap();
+    }
+
+    private void lastMap() {
+        mapMaker.previous();
+        updateMap();
+    }
+
+    private void updateMap() {
+        mapHolder.getChildren().setAll(mapMaker.getCurrentGameView());
+        mapNameLabel.setText(mapMaker.getCurrentRegatta().getCourseName());
+        maxPlayersSlider.setMax(mapMaker.getMaxPlayers());
+        maxPlayersSlider.setValue(mapMaker.getMaxPlayers());
+    }
+
+    public void setListener(List<ServerCreationDialogListener> serverCreationDialogListeners) {
+        this.serverCreationDialogListeners = serverCreationDialogListeners;
+    }
+
+    public void notifyListeners() {
+        for (ServerCreationDialogListener serverCreationDialogListener : serverCreationDialogListeners) {
+            serverCreationDialogListener.notifyClosure();
+        }
+    }
+
 }

src/main/java/seng302/visualiser/fxObjects/assets_3D/BoatMeshType.java

@@ -11,7 +11,9 @@ public enum BoatMeshType {
     CATAMARAN("catamaran_hull.stl", "catamaran_mast.stl", 0.997, "catamaran_sail.stl",
         0.997, null, false, 1.0, 1.4, 2.0),
     PIRATE_SHIP("pirateship_hull.stl", "pirateship_mast.stl", -0.5415, "pirateship_mainsail.stl",
-        -0.5415, "pirateship_frontsail.stl", true, 1.2, 1.6, 1.2);
+        -0.5415, "pirateship_frontsail.stl", true, 1.2, 1.6, 1.2),
+    DUCKY("ducky_hull.stl", "ducky_mast.stl", -2.18539, "ducky_sail.stl", -2.18539, "ducky_eyes.stl", false, 1.2, 1.1, 1.4),
+    PARROT("parrot_hull.stl", null, 0, "parrot_sail.stl", 0, "parrot_features.stl", true, 1, 1, 1);
 
     final String hullFile, mastFile, sailFile, jibFile;
     final double mastOffset, sailOffset;
@@ -19,7 +21,7 @@ public enum BoatMeshType {
     public final double accelerationMultiplier;
     public final double turnStep;
     final boolean fixedSail;
-    final static BoatMeshType[] boatTypes = new BoatMeshType[]{DINGHY, CATAMARAN, PIRATE_SHIP};
+    final static BoatMeshType[] boatTypes = new BoatMeshType[]{DINGHY, CATAMARAN, PIRATE_SHIP, DUCKY, PARROT};
 
     BoatMeshType(String hullFile, String mastFile, double mastOffset, String sailFile,
         double sailOffset, String jibFile, boolean fixedSail, double maxSpeedMultiplier, double accelerationMultiplier, double turnStep) {

src/main/java/seng302/visualiser/fxObjects/assets_3D/BoatObject.java

@@ -3,10 +3,15 @@ package seng302.visualiser.fxObjects.assets_3D;
 import java.util.ArrayList;
 import java.util.List;
 import javafx.application.Platform;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.geometry.Point2D;
 import javafx.geometry.Point3D;
 import javafx.scene.Group;
 import javafx.scene.paint.Color;
+import javafx.scene.paint.PhongMaterial;
+import javafx.scene.shape.MeshView;
 import javafx.scene.transform.Rotate;
+import javafx.scene.transform.Translate;
 
 /**
  * BoatGroup is a javafx group that by default contains a graphical objects for representing a 2
@@ -30,12 +35,18 @@ public class BoatObject extends Group {
     private Boolean isSelected = false;
     private Rotate rotation = new Rotate(0, new Point3D(0,0,1));
 
+    // This stuff only matters to the players boat object.
+    private MeshView markIndicator;
+    private MeshView playerIndicator;
+    private ReadOnlyDoubleWrapper rotationProperty;
+
     private List<SelectedBoatListener> selectedBoatListenerListeners = new ArrayList<>();
 
     /**
      * Creates a BoatGroup with the default triangular boat polygon.
      */
     public BoatObject(BoatMeshType boatMeshType) {
+        rotationProperty = new ReadOnlyDoubleWrapper(0.0);
         boatAssets = ModelFactory.boatGameView(boatMeshType, colour);
         boatAssets.hideSail();
         boatAssets.getAssets().getTransforms().addAll(
@@ -75,6 +86,19 @@ public class BoatObject extends Group {
         });
     }
 
+    public void updateMarkIndicator(Point2D markPoint) {
+        Point2D boatLoc = new Point2D(this.getLayoutX(), this.getLayoutY());
+        Double angle = Math.toDegrees(
+            Math.atan2(boatLoc.getY() - markPoint.getY(), boatLoc.getX() - markPoint.getX())) - 90;
+
+        Double radius = 0.5;
+        markIndicator.getTransforms().clear();
+        markIndicator.getTransforms().addAll(
+            new Rotate(angle, new Point3D(0, 0, 1)),
+            new Translate(0, -radius, 0)
+        );
+    }
+
     private Double normalizeHeading(double heading, double windDirection) {
         Double normalizedHeading = heading - windDirection;
         normalizedHeading = (double) Math.floorMod(normalizedHeading.longValue(), 360L);
@@ -83,6 +107,7 @@ public class BoatObject extends Group {
 
 
     private void rotateTo(double heading, boolean sailsIn, double windDir) {
+        rotationProperty.set(heading);
         rotation.setAngle(heading);
         wake.getTransforms().setAll(new Rotate(heading, new Point3D(0,0,1)));
         if (sailsIn) {
@@ -113,6 +138,26 @@ public class BoatObject extends Group {
         }
     }
 
+    public void setMarkIndicator(MeshView indicator) {
+        this.markIndicator = indicator;
+        this.getChildren().add(markIndicator);
+        createPlayerIndicator();
+        setIndicatorColor();
+    }
+
+    private void createPlayerIndicator() {
+        MeshView torus = ModelFactory.importSTL("player_circle.stl");
+        playerIndicator = torus;
+        this.getChildren().add(torus);
+    }
+
+    public void setIndicatorColor() {
+        Platform.runLater(() -> {
+            markIndicator.setMaterial(new PhongMaterial(Color.DARKORANGE));
+            playerIndicator.setMaterial(new PhongMaterial(colour));
+        });
+    }
+
     public Group getWake () {
         return wake;
     }
@@ -130,4 +175,8 @@ public class BoatObject extends Group {
     public void addSelectedBoatListener(SelectedBoatListener sbl) {
         selectedBoatListenerListeners.add(sbl);
     }
+
+    public ReadOnlyDoubleWrapper getRotationProperty() {
+        return rotationProperty;
+    }
 }

src/main/java/seng302/visualiser/fxObjects/assets_3D/ModelFactory.java

@@ -7,7 +7,6 @@ import javafx.geometry.Point3D;
 import javafx.scene.AmbientLight;
 import javafx.scene.CacheHint;
 import javafx.scene.Group;
-import javafx.scene.PointLight;
 import javafx.scene.paint.Color;
 import javafx.scene.paint.PhongMaterial;
 import javafx.scene.shape.Circle;
@@ -116,27 +115,39 @@ public class ModelFactory {
     private static Group getUnmodifiedBoatModel(BoatMeshType boatType, Color primaryColour) {
 
         Group boatAssets = new Group();
-        MeshView hull = importSTL(boatType.hullFile);
+        MeshView hull = importBoatSTL(boatType.hullFile);
         hull.setMaterial(new PhongMaterial(primaryColour));
-        MeshView mast = importSTL(boatType.mastFile);
-        mast.setMaterial(new PhongMaterial(primaryColour));
-        MeshView sail = importSTL(boatType.sailFile);
-        sail.setMaterial(new PhongMaterial(Color.WHITE));
+        MeshView sail = importBoatSTL(boatType.sailFile);
+        sail.setMaterial(
+            new PhongMaterial(boatType == BoatMeshType.PARROT ? Color.BLACK : Color.WHITE)
+        );
+
+        boatAssets.getChildren().addAll(hull, sail);
+
+        if (boatType.mastFile != null) {
+            MeshView mast = importBoatSTL(boatType.mastFile);
+            mast.setMaterial(new PhongMaterial(primaryColour));
+            boatAssets.getChildren().add(mast);
+        }
 
         if (boatType.jibFile != null) {
-            MeshView jib = importSTL(boatType.jibFile);
-            sail.setMaterial(new PhongMaterial(Color.WHITE));
-            boatAssets.getChildren().addAll(hull, mast, sail, jib);
-        } else {
-            boatAssets.getChildren().addAll(hull, mast, sail);
+            MeshView jib = importBoatSTL(boatType.jibFile);
+            sail.setMaterial(
+                new PhongMaterial(boatType == BoatMeshType.PARROT ? Color.DARKGRAY : Color.WHITE)
+            );
+            boatAssets.getChildren().add(jib);
         }
 
         return boatAssets;
     }
 
-    private static MeshView importSTL(String fileName) {
+    private static MeshView importBoatSTL(String fileName) {
+        return importSTL("boatSTLs/" + fileName);
+    }
+
+    public static MeshView importSTL(String fileName) {
         StlMeshImporter importer = new StlMeshImporter();
-        importer.read(ModelFactory.class.getResource("/meshes/boatSTLs/" + fileName));
+        importer.read(ModelFactory.class.getResource("/meshes/" + fileName));
         MeshView importedFile = new MeshView(importer.getImport());
         importedFile.setCache(true);
         importedFile.setCacheHint(CacheHint.SCALE_AND_ROTATE);
@@ -155,8 +166,16 @@ public class ModelFactory {
             assets.setCacheHint(CacheHint.SCALE_AND_ROTATE);
         }
         switch (tokenType) {
+            case PLAYER_IDENTIFIER_TORUS:
+                return makeIdentifierTorus(assets);
+            case NEXT_MARK_INDICATOR:
+                return makeNextMarkIndicator(assets);
             case VELOCITY_PICKUP:
-                return makeCoinPickup(assets);
+            case BUMPER_PICKUP:
+            case RANDOM_PICKUP:
+            case HANDLING_PICKUP:
+            case WIND_WALKER_PICKUP:
+                return makeTokenPickup(assets);
             case FINISH_MARKER:
             case PLAIN_MARKER:
             case START_MARKER:
@@ -185,24 +204,32 @@ public class ModelFactory {
         }
     }
 
-    private static Model makeCoinPickup(Group assets){
-        assets.setRotationAxis(new Point3D(1,0,0));
-        assets.setRotate(90);
-        assets.setTranslateX(0.2);
-        assets.setTranslateY(1);
+    private static Model makeIdentifierTorus(Group assets) {
+//        assets.getChildren().add(new AmbientLight());
+        return new Model(new Group(assets), null);
+    }
+
+    private static Model makeNextMarkIndicator(Group assets) {
+//        assets.getChildren().add(new AmbientLight());
+        return new Model(new Group(assets), null);
+    }
+
+    private static Model makeTokenPickup(Group assets) {
+        Rotate animationRotate = new Rotate(0, new Point3D(0, 0, 1));
         assets.getTransforms().addAll(
-            new Translate(0,-1,0),
-            new Rotate(0 ,new Point3D(1,1,1))
+            animationRotate,
+            new Translate(0, 0, -1)
         );
+
         return new Model(new Group(assets), new AnimationTimer() {
 
             private double rotation = 0;
-            private Group group = assets;
+            private Rotate rotate = animationRotate;
 
             @Override
             public void handle(long now) {
                 rotation += 1;
-                ((Rotate) group.getTransforms().get(1)).setAngle(rotation);
+                rotate.setAngle(rotation);
             }
         });
     }

src/main/java/seng302/visualiser/fxObjects/assets_3D/ModelType.java

@@ -7,6 +7,10 @@ package seng302.visualiser.fxObjects.assets_3D;
 public enum ModelType {
 
     VELOCITY_PICKUP("velocity_pickup.dae"),
+    HANDLING_PICKUP("turning_pickup.dae"),
+    WIND_WALKER_PICKUP("wind_walker_pickup.dae"),
+    BUMPER_PICKUP("bumper_pickup.dae"),
+    RANDOM_PICKUP("random_pickup.dae"),
     FINISH_MARKER ("finish_marker.dae"),
     START_MARKER ("start_marker.dae"),
     PLAIN_MARKER ("plain_marker.dae"),
@@ -22,7 +26,11 @@ public enum ModelType {
     PLAYER_IDENTIFIER ("player_identifier.dae"),
     PLAIN_ARROW ("arrow.dae"),
     START_ARROW ("start_arrow.dae"),
-    FINISH_ARROW ("finish_arrow.dae");
+    FINISH_ARROW ("finish_arrow.dae"),
+    LAND("land.dae"),
+    LAND_SMOOTH("land_smooth.dae"),
+    NEXT_MARK_INDICATOR("indicator_arrow.dae"),
+    PLAYER_IDENTIFIER_TORUS("torus.dae");
 
     final String filename;
 

src/main/resources/config/config.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" ?>
-
-<configurations>
-    <race-name>AC35</race-name>
-    <race-size>6</race-size>
-    <time-scale>10.0</time-scale>
-    <windDir-direction>135</windDir-direction>
-</configurations>
-

src/main/resources/config/course.xml

@@ -1,80 +0,0 @@
-<?xml version="1.0" ?>
-
-<markers>
-    <marks>
-        <gate>
-            <name type="start-line">Start</name>
-            <mark>
-                <name>Start1</name>
-                <latitude>57.6703330</latitude>
-                <longitude>11.8278330</longitude>
-                <id>122</id>
-            </mark>
-            <mark>
-                <name>Start2</name>
-                <latitude>57.6703330</latitude>
-                <longitude>11.8271333</longitude>
-                <id>123</id>
-            </mark>
-        </gate>
-        <mark>
-            <name>Mid Mark</name>
-            <latitude>57.6675700</latitude>
-            <longitude>11.8359880</longitude>
-            <id>131</id>
-        </mark>
-        <gate>
-            <name>Leeward Gate</name>
-            <mark>
-                <name>Leeward Gate1</name>
-                <latitude>57.6708220</latitude>
-                <longitude>11.8433900</longitude>
-                <id>124</id>
-            </mark>
-            <mark>
-                <name>Leeward Gate2</name>
-                <latitude>57.6711220</latitude>
-                <longitude>11.8436900</longitude>
-                <id>125</id>
-            </mark>
-        </gate>
-        <gate>
-            <name>Windward Gate</name>
-            <mark>
-                <name>Windward Gate1</name>
-                <latitude>57.6650170</latitude>
-                <longitude>11.8279170</longitude>
-                <id>126</id>
-            </mark>
-            <mark>
-                <name>Windward Gate2</name>
-                <latitude>57.6653170</latitude>
-                <longitude>11.8282170</longitude>
-                <id>127</id>
-            </mark>
-        </gate>
-        <gate type="finish-line">
-            <name>Finish</name>
-            <mark>
-                <name>Finish1</name>
-                <latitude>57.6715240</latitude>
-                <longitude>11.8444950</longitude>
-                <id>128</id>
-            </mark>
-            <mark>
-                <name>Finish2</name>
-                <latitude>57.6718240</latitude>
-                <longitude>11.8447950</longitude>
-                <id>129</id>
-            </mark>
-        </gate>
-    </marks>
-    <order>
-        <one>Start</one>
-        <two>Mid Mark</two>
-        <three>Leeward Gate</three>
-        <four>Windward Gate</four>
-        <five>Leeward Gate</five>
-        <six>Finish</six>
-    </order>
-</markers>

src/main/resources/config/courseAlt.xml

@@ -1,72 +0,0 @@
-<?xml version="1.0" ?>
-
-<course>
-    <marks>
-        <gate>
-            <name type="start-line">Start</name>
-            <mark>
-                <name>Start1</name>
-                <latitude>32.296577</latitude>
-                <longitude>-64.854304</longitude>
-            </mark>
-            <mark>
-                <name>Start2</name>
-                <latitude>32.293771</latitude>
-                <longitude>-64.855242</longitude>
-            </mark>
-        </gate>
-        <mark>
-            <name>Mid Mark</name>
-            <latitude>32.293039</latitude>
-            <longitude>-64.843983</longitude>
-        </mark>
-        <gate>
-            <name>Leeward Gate</name>
-            <mark>
-                <name>Leeward Gate1</name>
-                <latitude>32.284680</latitude>
-                <longitude>-64.850045</longitude>
-            </mark>
-            <mark>
-                <name>Leeward Gate2</name>
-                <latitude>32.280164</latitude>
-                <longitude>-64.847591</longitude>
-            </mark>
-        </gate>
-        <gate>
-            <name>Windward Gate</name>
-            <mark>
-                <name>Windward Gate1</name>
-                <latitude>32.309693</latitude>
-                <longitude>-64.835249</longitude>
-            </mark>
-            <mark>
-                <name>Windward Gate2</name>
-                <latitude>32.308046</latitude>
-                <longitude>-64.831785</longitude>
-            </mark>
-        </gate>
-        <gate type="finish-line">
-            <name>Finish</name>
-            <mark>
-                <name>Finish1</name>
-                <latitude>32.317379</latitude>
-                <longitude>-64.839291</longitude>
-            </mark>
-            <mark>
-                <name>Finish2</name>
-                <latitude>32.317257</latitude>
-                <longitude>-64.836260</longitude>
-            </mark>
-        </gate>
-    </marks>
-    <order>
-        <one>Start</one>
-        <two>Mid Mark</two>
-        <three>Leeward Gate</three>
-        <four>Windward Gate</four>
-        <five>Leeward Gate</five>
-        <six>Finish</six>
-    </order>
-</course>
-

src/main/resources/config/teams.xml

@@ -1,40 +0,0 @@
-<?xml version="1.0" ?>
-
-<teams>
-    <team>
-        <name>Oracle Team USA</name>
-        <alias>USA</alias>
-        <currentVelocity>0.0</currentVelocity>
-        <id>102</id>
-    </team>
-    <team>
-        <name>Artemis Racing</name>
-        <alias>ART</alias>
-        <currentVelocity>0.0</currentVelocity>
-        <id>101</id>
-    </team>
-    <team>
-        <name>Emirates Team New Zealand</name>
-        <alias>NZL</alias>
-        <currentVelocity>0.0</currentVelocity>
-        <id>103</id>
-    </team>
-    <team>
-        <name>Land Rover BAR</name>
-        <alias>BAR</alias>
-        <currentVelocity>0.0</currentVelocity>
-        <id>104</id>
-    </team>
-    <team>
-        <name>SoftBank Team Japan</name>
-        <alias>JAP</alias>
-        <currentVelocity>0.0</currentVelocity>
-        <id>105</id>
-    </team>
-    <team>
-        <name>Groupama Team France</name>
-        <alias>FRC</alias>
-        <currentVelocity>0.0</currentVelocity>
-        <id>106</id>
-    </team>
-</teams>

src/main/resources/css/Master.css

@@ -51,6 +51,11 @@
 
 /********* customised scroll bar for scroll pane ***********/
 
+.scroll-pane {
+    -fx-focus-traversable: false;
+    -fx-border-style: none;
+}
+
 /* The main scrollbar **track** CSS class  */
 .scroll-bar:horizontal .track,
 .scroll-bar:vertical .track {

src/main/resources/css/ServerListView.css

@@ -38,30 +38,31 @@
     -fx-font-size: 23px;
 }
 
-#connectButton {
+#connectButton, #roomConnectButton, #directConnectButton, #autoSelectGame {
     -fx-background-color: -fx-pp-light-text-color; /* inverted */
     -fx-text-fill: -fx-pp-theme-color; /* inverted */
     -fx-font-size: 20px;
-    -fx-pref-height: 65px;
+    -fx-pref-height: 45px;
+    -fx-effect: -fx-pp-dropshadow-dark;
 }
 
-#connectButton:hover {
-    -fx-font-size: 23px;
+#connectButton:hover, #roomConnectButton:hover, #directConnectButton:hover, #autoSelectGame:hover {
+    -fx-font-size: 21px;
 }
 
-#connectLabel, #serverPortNumber, #serverHostName {
+#connectLabel, #connectLabel1, #serverPortNumber, #roomNumber, #serverHostName {
     -fx-text-fill: -fx-pp-light-text-color;
     -fx-font-size: 18px;
 }
 
-#serverHostName, #serverPortNumber {
+#serverHostName, #serverPortNumber, #roomNumber {
     -jfx-focus-color: -fx-pp-light-text-color;
     -jfx-unfocus-color: -fx-pp-light-text-color;
     -fx-prompt-text-fill: -fx-pp-light-text-color;
 }
 
 
-#serverHostName .error-label, #serverPortNumber .error-label {
+#serverHostName .error-label, #serverPortNumber .error-label, #roomNumber .error-label {
     -fx-font-size: 12px;
     -fx-text-fill: lightblue;
 }

src/main/resources/css/SplashScreenView.css

@@ -0,0 +1,10 @@
+#background {
+    -fx-background-color: #E7F1F8;
+}
+
+#headText {
+    -fx-background-color: transparent;
+    -fx-font-size: 52px;
+    -fx-text-fill: -fx-pp-light-text-color;
+    -fx-effect: -fx-pp-dropshadow-headers;
+}

src/main/resources/css/dialogs/DirectConnect.css

@@ -0,0 +1,47 @@
+#maxPlayersGridPane VBox * {
+    -fx-font-family: monospace !important;
+}
+
+#submitBtn {
+    -fx-background-color: -fx-pp-theme-color;
+    -fx-text-fill: -fx-pp-light-text-color;
+    -fx-font-size: 20px;
+    -fx-effect: -fx-pp-dropshadow-dark;
+}
+
+.jfx-rippler {
+    -jfx-rippler-fill: -fx-pp-light-theme-color; /* set rippler color for button */
+}
+
+#submitBtn:hover {
+    -fx-font-size: 23px;
+    -fx-background-color: -fx-pp-light-theme-color;
+}
+
+#hostDialogHeader {
+    -fx-font-size: 30px;
+    -fx-text-fill: -fx-pp-dark-text-color;
+}
+
+
+#serverName {
+    -jfx-focus-color: -fx-pp-dark-text-color;
+    -jfx-unfocus-color: -fx-pp-dark-text-color;
+    -fx-text-fill: -fx-pp-dark-text-color;
+    -fx-prompt-text-fill: -fx-pp-dark-text-color;
+    -fx-font-size: 16px;
+}
+
+#maxPlayersLabel {
+    -fx-text-fill: -fx-pp-dark-text-color;
+    -fx-font-size: 16px;
+}
+
+#maxPlayerPromptLabel {
+    -fx-text-fill: -fx-pp-dark-text-color;
+    -fx-font-size: 16px;
+}
+
+.maxPlayers {
+    -fx-font-size: 13px;
+}

src/main/resources/css/dialogs/KeyBindingDialog.css

@@ -9,8 +9,13 @@
 }
 
 #closeLabel:hover {
-    -fx-text-fill: -fx-pp-theme-color;
-    -fx-font-size: 33;
+    -fx-text-fill: red;
+    -fx-font-size: 33px;
+}
+
+.sectionLabel {
+    -fx-text-fill: -fx-pp-dark-text-color;
+    -fx-font-size: 20px;
 }
 
 JFXButton {

src/main/resources/css/dialogs/Popup.css

@@ -0,0 +1,33 @@
+#headerLabel {
+    -fx-font-size: 20px;
+    -fx-text-fill: -fx-pp-dark-text-color;
+}
+
+#closeLabel {
+    -fx-font-size: 22px;
+    -fx-text-fill: -fx-pp-dark-text-color;
+}
+
+#closeLabel:hover {
+    -fx-font-size: 24px;
+    -fx-text-fill: red;
+}
+
+#contentLabel {
+    -fx-font-size: 22px;
+    -fx-text-fill: -fx-pp-dark-text-color;
+}
+
+#optionButton {
+    -fx-background-color: -fx-pp-theme-color;
+    -fx-text-fill: -fx-pp-light-text-color;
+    -fx-font-size: 18px;
+    -fx-effect: -fx-pp-dropshadow-light;
+    -fx-max-height: 55;
+    -fx-focus-traversable: false;
+}
+
+#optionButton:hover {
+    -fx-font-size: 20px !important;
+    -fx-background-color: -fx-pp-light-theme-color;
+}

src/main/resources/css/dialogs/ServerCreation.css

@@ -45,3 +45,13 @@
 .maxPlayers {
     -fx-font-size: 13px;
 }
+
+#closeLabel {
+    -fx-font-size: 30;
+    -fx-text-fill: -fx-pp-dark-text-color;
+}
+
+#closeLabel:hover {
+    -fx-text-fill: red;
+    -fx-font-size: 33px;
+}

src/main/resources/css/dialogs/Snackbar.css

@@ -1,4 +1,4 @@
 /* a separate file to dynamically change snackbar's color */
 .jfx-snackbar-toast {
-    -fx-text-fill: red !important;
+    -fx-text-fill: black !important;
 }

src/main/resources/maps/default.xml

@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RaceDefinition>
+
+  <CourseName> El Classico </CourseName>
+
+  <CentralLat> 57.6679590 </CentralLat>
+  <CentralLng> 11.8503233 </CentralLng>
+
+  <MaxPlayers> 10 </MaxPlayers>
+
+  <Marks>
+    <CompoundMark CompoundMarkID="1">
+      <Mark Lat="57.670603" Lng="11.828262"/>
+      <Mark Lat="57.669445" Lng="11.826413"/>
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="2">
+      <Mark Lat="57.6675700" Lng="11.8359880"/>
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="3">
+      <Mark Lat="57.6708220" Lng="11.8433900"/>
+      <Mark Lat="57.671629" Lng="11.840951"/>
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="4">
+      <Mark Lat="57.664190" Lng="11.829576"/>
+      <Mark Lat="57.665316" Lng="11.827184"/>
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="5">
+      <Mark Lat="57.672350" Lng="11.842535"/>
+      <Mark Lat="57.6715240" Lng="11.8444950"/>
+    </CompoundMark>
+  </Marks>
+
+  <Course>
+    <OpeningSegment>
+      <Corner CompoundMarkID="1" Rounding="PS"/>
+      <Corner CompoundMarkID="2" Rounding="P"/>
+    </OpeningSegment>
+
+    <RepeatingSegment>
+      <Corner CompoundMarkID="3" Rounding="SP"/>
+      <Corner CompoundMarkID="4" Rounding="PS"/>
+    </RepeatingSegment>
+
+    <ClosingSegment>
+      <Corner CompoundMarkID="5" Rounding="PS"/>
+    </ClosingSegment>
+  </Course>
+
+  <CourseLimit>
+    <Limit Lat="57.6739450" Lng="11.8417100" />
+    <Limit Lat="57.6709520" Lng="11.8485010" />
+    <Limit Lat="57.6690260" Lng="11.8472790" />
+    <Limit Lat="57.6693140" Lng="11.8457610" />
+    <Limit Lat="57.6665370" Lng="11.8432910" />
+    <Limit Lat="57.6641400" Lng="11.8385840" />
+    <Limit Lat="57.6629430" Lng="11.8332030" />
+    <Limit Lat="57.6629480" Lng="11.8249660" />
+    <Limit Lat="57.6686890" Lng="11.8250920" />
+    <Limit Lat="57.6692230" Lng="11.8231430" />
+    <Limit Lat="57.6725370" Lng="11.8272480" />
+    <Limit Lat="57.6708220" Lng="11.8321340" />
+  </CourseLimit>
+
+</RaceDefinition>

src/main/resources/maps/horseshoe.xml

@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RaceDefinition>
+
+  <CourseName> HorseShoe </CourseName>
+
+  <CentralLat> -14.6457 </CentralLat>
+  <CentralLng> 47.612855 </CentralLng>
+
+  <MaxPlayers> 5 </MaxPlayers>
+
+  <Marks>
+    <CompoundMark CompoundMarkID="1">
+      <Mark Lat="-14.071412" Lng="47.05756"/>
+      <Mark Lat="-14.069914" Lng="47.058541"/>
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="2">
+      <Mark Lat="-14.067194" Lng="47.053818" />
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="3">
+      <Mark Lat="-14.061248" Lng="47.058556" />
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="4">
+      <Mark Lat="-14.060584" Lng="47.063088"/>
+      <Mark Lat="-14.060617" Lng="47.06374" />
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="5">
+      <Mark Lat="-14.064637" Lng="47.060307"/>
+      <Mark Lat="-14.06477" Lng="47.061165"/>
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="6">
+      <Mark Lat="-14.063839" Lng="47.06762"/>
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="7">
+      <Mark Lat="-14.068954" Lng="47.066349"/>
+    </CompoundMark>
+    <CompoundMark CompoundMarkID="8">
+      <Mark Lat="-14.07025" Lng="47.060238"/>
+      <Mark Lat="-14.071047" Lng="47.060307"/>
+    </CompoundMark>
+  </Marks>
+
+  <Course>
+
+    <OpeningSegment>
+      <Corner CompoundMarkID="1" Rounding="PS"/>
+      <Corner CompoundMarkID="2" Rounding="S"/>
+      <Corner CompoundMarkID="3" Rounding="S"/>
+      <Corner CompoundMarkID="4" Rounding="SP"/>
+    </OpeningSegment>
+
+    <RepeatingSegment>
+      <Corner CompoundMarkID="5" Rounding="SP"/>
+      <Corner CompoundMarkID="4" Rounding="PS"/>
+    </RepeatingSegment>
+
+    <ClosingSegment>
+      <Corner CompoundMarkID="6" Rounding="S"/>
+      <Corner CompoundMarkID="7" Rounding="S"/>
+      <Corner CompoundMarkID="8" Rounding="SP" />
+    </ClosingSegment>
+
+  </Course>
+
+  <CourseLimit>
+    <Limit Lat="-14.073371" Lng="47.058213" />
+    <Limit Lat="-14.06453" Lng="47.050003" />
+    <Limit Lat="-14.059022" Lng="47.057286" />
+    <Limit Lat="-14.058723" Lng="47.064358" />
+    <Limit Lat="-14.06261" Lng="47.071293" />
+    <Limit Lat="-14.070814" Lng="47.06762" />
+    <Limit Lat="-14.072773" Lng="47.059689" />
+    <Limit Lat="-14.068323" Lng="47.059449" />
+    <Limit Lat="-14.064969" Lng="47.065113" />
+    <Limit Lat="-14.066131" Lng="47.05986" />
+    <Limit Lat="-14.063441" Lng="47.058419" />
+    <Limit Lat="-14.068091" Lng="47.059174" />
+  </CourseLimit>
+
+</RaceDefinition>

src/main/resources/meshes/indicator_arrow.dae

@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="utf-8"?>
+<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <asset>
+    <contributor>
+      <author>Blender User</author>
+      <authoring_tool>Blender 2.79.0 commit date:2017-09-11, commit time:10:43, hash:5bd8ac9</authoring_tool>
+    </contributor>
+    <created>2017-09-28T01:59:46</created>
+    <modified>2017-09-28T01:59:46</modified>
+    <unit name="meter" meter="1"/>
+    <up_axis>Z_UP</up_axis>
+  </asset>
+  <library_images/>
+  <library_effects>
+    <effect id="Material_001-effect">
+      <profile_COMMON>
+        <technique sid="common">
+          <phong>
+            <emission>
+              <color sid="emission">0 0 0 1</color>
+            </emission>
+            <ambient>
+              <color sid="ambient">0 0 0 1</color>
+            </ambient>
+            <diffuse>
+              <color sid="diffuse">0 0.3215737 0.002428917 1</color>
+            </diffuse>
+            <specular>
+              <color sid="specular">0.1614584 0.1614584 0.1614584 1</color>
+            </specular>
+            <shininess>
+              <float sid="shininess">50</float>
+            </shininess>
+            <index_of_refraction>
+              <float sid="index_of_refraction">1</float>
+            </index_of_refraction>
+          </phong>
+        </technique>
+      </profile_COMMON>
+    </effect>
+  </library_effects>
+  <library_materials>
+    <material id="Material_001-material" name="Material_001">
+      <instance_effect url="#Material_001-effect"/>
+    </material>
+  </library_materials>
+  <library_geometries>
+    <geometry id="Cone-mesh" name="Cone">
+      <mesh>
+        <source id="Cone-mesh-positions">
+          <float_array id="Cone-mesh-positions-array" count="99">0 1 -1 0 0 1 0.1950902 0.9807853 -1 0.3826835 0.9238795 -1 0.5555703 0.8314696 -1 0.7071068 0.7071068 -1 0.8314697 0.5555702 -1 0.9238795 0.3826834 -1 0.9807853 0.1950902 -1 1 0 -1 0.9807853 -0.1950902 -1 0.9238796 -0.3826833 -1 0.8314697 -0.5555702 -1 0.7071068 -0.7071068 -1 0.5555702 -0.8314697 -1 0.3826833 -0.9238796 -1 0.1950901 -0.9807853 -1 -3.25841e-7 -1 -1 -0.1950907 -0.9807852 -1 -0.3826839 -0.9238793 -1 -0.5555707 -0.8314693 -1 -0.7071073 -0.7071064 -1 -0.83147 -0.5555697 -1 -0.9238799 -0.3826827 -1 -0.9807854 -0.1950893 -1 -1 9.65599e-7 -1 -0.9807851 0.1950913 -1 -0.9238791 0.3826845 -1 -0.8314689 0.5555713 -1 -0.7071059 0.7071077 -1 -0.5555691 0.8314704 -1 -0.3826821 0.9238801 -1 -0.1950888 0.9807856 -1</float_array>
+          <technique_common>
+            <accessor source="#Cone-mesh-positions-array" count="33" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Cone-mesh-normals">
+          <float_array id="Cone-mesh-normals-array" count="117">0.08775347 0.8909768 0.4454884 0.2598883 0.8567371 0.4454883 0.4220357 0.7895733 0.4454883 0.5679644 0.6920669 0.4454883 0.6920669 0.5679644 0.4454883 0.7895736 0.4220353 0.4454883 0.8567369 0.2598885 0.4454883 0.8909768 0.08775347 0.4454884 0.8909768 -0.08775347 0.4454884 0.8567371 -0.2598881 0.4454883 0.7895734 -0.4220355 0.4454884 0.6920669 -0.5679644 0.4454883 0.5679644 -0.6920669 0.4454883 0.4220356 -0.7895734 0.4454883 0.2598879 -0.8567371 0.4454885 0.08775335 -0.8909768 0.4454884 -0.08775389 -0.8909767 0.4454883 -0.2598887 -0.8567368 0.4454883 -0.4220361 -0.7895731 0.4454884 -0.5679646 -0.6920668 0.4454883 -0.6920675 -0.5679637 0.4454884 -0.7895734 -0.4220355 0.4454884 -0.8567374 -0.2598869 0.4454883 -0.8909769 -0.08775287 0.4454884 -0.8909766 0.08775418 0.4454883 -0.8567367 0.2598895 0.4454884 -0.7895728 0.4220367 0.4454883 -0.6920663 0.5679652 0.4454883 -0.5679636 0.6920676 0.4454884 -0.4220345 0.789574 0.4454885 -0.259887 0.8567373 0.4454883 -0.08775269 0.8909768 0.4454884 0 0 -1 -3.97508e-6 0 -1 3.97512e-6 0 -1 3.88859e-7 0 -1 -1.36853e-6 0 -1 1.36853e-6 0 -1 -3.88857e-7 0 -1</float_array>
+          <technique_common>
+            <accessor source="#Cone-mesh-normals-array" count="39" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="Cone-mesh-vertices">
+          <input semantic="POSITION" source="#Cone-mesh-positions"/>
+        </vertices>
+        <triangles material="Material_001-material" count="62">
+          <input semantic="VERTEX" source="#Cone-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#Cone-mesh-normals" offset="1"/>
+          <p>0 0 1 0 2 0 2 1 1 1 3 1 3 2 1 2 4 2 4 3 1 3 5 3 5 4 1 4 6 4 6 5 1 5 7 5 7 6 1 6 8 6 8 7 1 7 9 7 9 8 1 8 10 8 10 9 1 9 11 9 11 10 1 10 12 10 12 11 1 11 13 11 13 12 1 12 14 12 14 13 1 13 15 13 15 14 1 14 16 14 16 15 1 15 17 15 17 16 1 16 18 16 18 17 1 17 19 17 19 18 1 18 20 18 20 19 1 19 21 19 21 20 1 20 22 20 22 21 1 21 23 21 23 22 1 22 24 22 24 23 1 23 25 23 25 24 1 24 26 24 26 25 1 25 27 25 27 26 1 26 28 26 28 27 1 27 29 27 29 28 1 28 30 28 30 29 1 29 31 29 31 30 1 30 32 30 32 31 1 31 0 31 16 32 24 32 8 32 32 32 0 32 2 32 2 32 3 32 4 32 4 32 5 32 6 32 6 32 7 32 4 32 8 32 9 32 10 32 10 32 11 32 8 32 12 32 13 32 16 32 14 32 15 32 16 32 16 32 17 32 18 32 18 32 19 32 20 32 20 32 21 32 22 32 22 33 23 33 24 33 24 34 25 34 26 34 26 32 27 32 28 32 28 32 29 32 32 32 30 32 31 32 32 32 32 35 2 35 8 35 4 36 7 36 8 36 8 37 11 37 12 37 13 32 14 32 16 32 16 32 18 32 24 32 20 32 22 32 24 32 24 38 26 38 32 38 29 32 30 32 32 32 2 32 4 32 8 32 8 32 12 32 16 32 18 32 20 32 24 32 26 32 28 32 32 32 32 32 8 32 24 32</p>
+        </triangles>
+      </mesh>
+    </geometry>
+  </library_geometries>
+  <library_controllers/>
+  <library_visual_scenes>
+    <visual_scene id="Scene" name="Scene">
+      <node id="Cone" name="Cone" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 1.015816 0 0 0 1</matrix>
+        <instance_geometry url="#Cone-mesh" name="Cone">
+          <bind_material>
+            <technique_common>
+              <instance_material symbol="Material_001-material" target="#Material_001-material"/>
+            </technique_common>
+          </bind_material>
+        </instance_geometry>
+      </node>
+    </visual_scene>
+  </library_visual_scenes>
+  <scene>
+    <instance_visual_scene url="#Scene"/>
+  </scene>
+</COLLADA>