Merge branch '1273_Skybox' into 'develop'

1273 skybox Server Discovery: - Created server discovery server. - Implemented protocols to support matchmaking & room code connection - Improved error handling for server disconnections Skybox: - Added a skybox - Added a terrain mesh See merge request !79
2026-05-09 14:28:43 +00:00 · 2017-09-27 21:52:34 +13:00
parent cd199767ae 5cc4898ab5
commit ff4c2cd5b6
90 changed files with 4390 additions and 2137 deletions
@@ -1,29 +1,12 @@
 package seng302.gameServer;

-import java.util.ArrayList;
-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 java.io.IOException;
+import java.util.*;
+
 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;
-import seng302.gameServer.messages.CustomizeRequestType;
-import seng302.gameServer.messages.MarkRoundingMessage;
-import seng302.gameServer.messages.MarkType;
-import seng302.gameServer.messages.Message;
-import seng302.gameServer.messages.RoundingBoatStatus;
+import seng302.gameServer.messages.*;
 import seng302.model.GeoPoint;
 import seng302.model.Limit;
 import seng302.model.Player;
@@ -32,6 +15,7 @@ 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;
@@ -96,8 +80,8 @@ public class GameState implements Runnable {
    private static GameStages currentStage;
    private static MarkOrder markOrder;
    private static long startTime;
-    private static List<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> tokensInPlay;
@@ -106,46 +90,33 @@ public class GameState implements Runnable {
    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;
        serverSpeedMultiplier = 1.0;
        currentStage = GameStages.LOBBYING;
        previousUpdateTime = System.currentTimeMillis();
-        markOrder = new MarkOrder(); //This could be instantiated at some point with a select map?
        newMessageListeners = new ArrayList<>();
-        marks = new MarkOrder().getAllMarks();
-        randomSpawn = new RandomSpawn(markOrder.getOrderedUniqueCompoundMarks());

        resetStartTime();
-        setCourseLimit("/server_config/race.xml");
+        //setCourseLimit("/server_config/race.xml");
        new Thread(this, "GameState").start();   //Run the auto updates on the game state
    }

-    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();
-    }
-
-    public static String getHostIpAddress() {
-        return hostIpAddress;
+        randomSpawn = new RandomSpawn(markOrder.getOrderedUniqueCompoundMarks());
+        courseLimit = raceXMLData.getCourseLimit();
    }

    public static List<Player> getPlayers() {
@@ -156,6 +127,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()
@@ -266,8 +241,10 @@ public class GameState implements Runnable {
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
-                spawnNewToken();
-                notifyMessageListeners(MessageFactory.getRaceXML());
+                if (tokensEnabled) {
+                    spawnNewToken();
+                    notifyMessageListeners(MessageFactory.getRaceXML());
+                }
            }
        }, 0, TOKEN_SPAWN_TIME);
    }
@@ -353,6 +330,7 @@ public class GameState implements Runnable {
 //        token.assignType(TokenType.RANDOM);
        logger.debug("Spawned token of type " + token.getTokenType());
        tokensInPlay.add(token);
+        MessageFactory.updateTokens(tokensInPlay);
    }

    /**
@@ -399,6 +377,8 @@ public class GameState implements Runnable {
        if (collidedToken != null) {
            tokensInPlay.remove(collidedToken);
            powerUpYacht(yacht, collidedToken);
+            MessageFactory.updateTokens(tokensInPlay);
+            notifyMessageListeners(MessageFactory.getRaceXML());
        }

        checkPowerUpTimeout(yacht);
@@ -531,6 +511,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;
@@ -1043,6 +1024,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 () {
@@ -1053,4 +1040,8 @@ public class GameState implements Runnable {
    public static double getServerSpeedMultiplier() {
        return serverSpeedMultiplier;
    }
+
+    public static void setTokensEnabled (boolean tokensEnabled) {
+        GameState.tokensEnabled = tokensEnabled;
+    }
 }
@@ -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
@@ -42,29 +42,13 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
    private Thread thread;

    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;
@@ -76,31 +60,38 @@ 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");
        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() {

@@ -128,8 +119,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();
            }
@@ -171,6 +162,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());
@@ -192,16 +184,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);
    }

    /**
@@ -222,6 +241,7 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
                serverToClientThread.sendSetupMessages();
            }
        }
+
        serverToClientThreads.remove(closedConnection);

        try {
@@ -255,9 +275,9 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
        }, 0, 500);


-        if (GameState.getCurrentStage() == GameStages.LOBBYING) {
-            sendSetupMessages();
-        }
+//        if (GameState.getCurrentStage() == GameStages.LOBBYING) {
+//            sendSetupMessages();
+//        }
    }

    public void terminate() {
@@ -268,39 +288,166 @@ 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
+            );
        }
    }
 }
@@ -1,5 +1,6 @@
 package seng302.gameServer;

+import seng302.gameServer.messages.*;
 import java.util.ArrayList;
 import java.util.List;
 import seng302.gameServer.messages.BoatLocationMessage;
@@ -18,10 +19,15 @@ 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.
@@ -39,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() {
@@ -99,38 +150,15 @@ 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 new XMLMessage(
-            xmlGenerator.getBoatsAsXml(),
-            XMLMessageSubType.BOAT,
-            xmlGenerator.getBoatsAsXml().length());
+        return boats;
    }

    public static YachtEventCodeMessage makeCollisionMessage(ServerYacht serverYacht) {
@@ -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);
    }

    /**
@@ -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();
+    }
 }
@@ -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
@@ -80,6 +81,9 @@ public class ServerToClientThread implements Runnable {

    private Player player;

+    private SimpleObjectProperty<RaceXMLData> raceXMLProperty = new SimpleObjectProperty<>();
+    private SimpleObjectProperty<RegattaXMLData> regattaXMLProperty = new SimpleObjectProperty<>();
+
    public ServerToClientThread(Socket socket) {
        this.socket = socket;
        seqNo = 0;
@@ -100,9 +104,8 @@ public class ServerToClientThread implements Runnable {
    }

    private void setUpPlayer(){
-        String shortName = "p" + sourceId;
-        String longName = "player " + sourceId;
-
+        String shortName = "P" + sourceId;
+        String longName = "Player " + sourceId;

        ServerYacht yacht = new ServerYacht(
            BoatMeshType.DINGHY, sourceId, sourceId.toString(), shortName, longName, "NZ");
@@ -164,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);
@@ -211,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() {
@@ -319,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;
+    }
 }
@@ -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;
@@ -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();
+    }
+}
@@ -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();
+    }
+
+}