Merge remote-tracking branch 'origin/story1275_host_customization' into 1273_Skybox

# Conflicts:
#	src/main/java/seng302/gameServer/GameState.java
#	src/main/java/seng302/gameServer/MainServerThread.java
#	src/main/java/seng302/gameServer/ServerToClientThread.java
#	src/main/java/seng302/visualiser/ClientToServerThread.java
#	src/main/java/seng302/visualiser/GameView.java
#	src/main/java/seng302/visualiser/GameView3D.java
#	src/main/java/seng302/visualiser/controllers/dialogs/ServerCreationController.java

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

@@ -1,5 +1,13 @@
 package seng302.gameServer;
 
+import java.io.IOException;
+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 org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import seng302.gameServer.messages.Message;
@@ -7,7 +15,6 @@ 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;
@@ -39,6 +46,7 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
     private static Integer capacity;
     private RaceXMLData raceXMLData;
     private RegattaXMLData regattaXMLData;
+    private boolean serverStarted = false;
 
     private void startAdvertisingServer() {
         Integer capacity = GameState.getCapacity();
@@ -268,9 +276,9 @@ public class MainServerThread implements Runnable, ClientConnectionDelegate {
         }, 0, 500);
 
 
-        if (GameState.getCurrentStage() == GameStages.LOBBYING) {
+//        if (GameState.getCurrentStage() == GameStages.LOBBYING) {
-            sendSetupMessages();
+//            sendSetupMessages();
-        }
+//        }
     }
 
     public void terminate() {
@@ -281,39 +289,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);
+//        CompoundMark cm = GameState.getMarkOrder().getMarkOrder().get(0);
-        GeoPoint startMark1 = cm.getSubMark(1);
+//        GeoPoint startMark1 = cm.getSubMark(1);
-        GeoPoint startMark2 = cm.getSubMark(2);
+//        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
+//        final double SEPARATION = 50.0;  // distance apart in meters
-        Double perpendicularAngle = GeoUtility.getBearing(startMark1, startMark2);
+//
-        Double length = GeoUtility.getDistance(startMark1, startMark2);
+//        //Reverse of the angle from start to first mark
-        GeoPoint midpoint = GeoUtility.getGeoCoordinate(startMark1, perpendicularAngle, length / 2);
+//        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
+        final double DISTANCE_TO_START = 75d;
-        double DISTANCE_FACTOR = 50.0;  // distance apart in meters
+        final double YACHT_SEPARATION = 20d;
-        int boatIndex = 0;
-        for (ServerYacht yacht : GameState.getYachts().values()) {
-            int distanceApart = boatIndex / 2;
 
-            if (boatIndex % 2 == 1 && boatIndex != 0) {
+        //Length of start line
-                distanceApart++;
+        double startLineLength = GeoUtility.getDistance(
-                distanceApart *= -1;
+            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
+            startingPoint = GeoUtility.getGeoCoordinate(
-                .getGeoCoordinate(midpoint, perpendicularAngle, distanceApart * DISTANCE_FACTOR);
+                startingPoint, angleToStart, DISTANCE_TO_START
-
+            );
-            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++;
         }
     }
 }

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

@@ -64,7 +64,8 @@ public class MessageFactory {
                 new ArrayList<>(),
                 race.getMarkSequence(),
                 race.getCourseLimit(),
-                new ArrayList<>(race.getCompoundMarks().values())
+                new ArrayList<>(race.getCompoundMarks().values()),
+                GameState.getCapacity(), true
             )
         );
         String xmlStr = xmlGenerator.getRaceAsXml();
@@ -76,6 +77,9 @@ public class MessageFactory {
     }
 
     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());

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

@@ -5,6 +5,14 @@ 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;
+import seng302.gameServer.messages.CustomizeRequestType;
+import seng302.gameServer.messages.Message;
+import seng302.gameServer.messages.RegistrationResponseMessage;
+import seng302.gameServer.messages.RegistrationResponseStatus;
 import seng302.model.Player;
 import seng302.model.ServerYacht;
 import seng302.model.stream.packets.PacketType;
@@ -190,12 +198,11 @@ public class ServerToClientThread implements Runnable {
                                 // TODO: 17/08/2017 ajm412: Send a response packet here, not really necessary until we do shapes.
                                 break;
                             case RACE_XML:
-                                System.out.println("Got raceXML from client");
+                                Document document = StreamParser.extractXmlMessage(packet);
                                 raceXMLProperty.set(
-                                    XMLParser.parseRace(
+                                    XMLParser.parseRace(document)
-                                        StreamParser.extractXmlMessage(packet)
-                                    )
                                 );
+                                GameState.setMaxPlayers(XMLParser.getMaxPlayers(document));
                                 break;
                             case REGATTA_XML:
                                 regattaXMLProperty.set(

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

@@ -20,15 +20,19 @@ public class RaceXMLTemplate {
     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, List<Corner> roundings,
-        List<Limit> limit, List<CompoundMark> course) {
+        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;
     }
 
     /**
@@ -83,4 +87,12 @@ public class RaceXMLTemplate {
     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/utilities/StreamParser.java

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

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

@@ -13,6 +13,7 @@ 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;
@@ -35,6 +36,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.
      *
@@ -45,7 +48,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;
         }
@@ -77,7 +80,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;
         }
@@ -195,6 +198,31 @@ public class XMLParser {
         );
     }
 
+    public static Boolean tokensEnabled(Document doc) {
+        Element docEle = doc.getDocumentElement();
+        try {
+            Node tokenNode = docEle.getAttributeNode("Tokens");
+            return Boolean.valueOf(XMLParser.getNodeAttributeString(tokenNode, "Enabled"));
+        } catch (NullPointerException npe) {
+            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
      *
@@ -350,9 +378,13 @@ public class XMLParser {
      * @param url the location of the race def file
      * @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<String, String> parseRaceDef(String url, String serverName, int repetitions) {
+    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;
@@ -369,16 +401,25 @@ public class XMLParser {
             XMLParser.getElementDouble(docEle, "CentralLat"),
             XMLParser.getElementDouble(docEle, "CentralLng")
         );
+
         XMLGenerator xmlGenerator = new XMLGenerator();
         xmlGenerator.setRegattaTemplate(regattaXMLTemplate);
 
-        RaceXMLTemplate raceXMLTemplate = new RaceXMLTemplate(new ArrayList<>(), new ArrayList<>(),
+        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)
+            XMLParser.extractCompoundMarksRaceDef(docEle),
+            maxPlayers, tokensEnabled
         );
         xmlGenerator.setRaceTemplate(raceXMLTemplate);
-        return new Pair<>(xmlGenerator.getRegattaAsXml(), xmlGenerator.getRaceAsXml());
+        return new Pair<>(regattaXMLTemplate, raceXMLTemplate);
     }
 
     private static List<Corner> extractMarkOrderRaceDef(Element docEle, int repitions){

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

@@ -17,6 +17,26 @@ import java.util.*;
 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;
+import seng302.gameServer.messages.BoatActionMessage;
+import seng302.gameServer.messages.ChatterMessage;
+import seng302.gameServer.messages.ClientType;
+import seng302.gameServer.messages.CustomizeRequestMessage;
+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;
 
 /**
  * A class describing a single connection to a Server for the purposes of sending and receiving on
@@ -367,18 +387,23 @@ public class ClientToServerThread implements Runnable {
         return clientId;
     }
 
-    public void sendXML(String path, String serverName, int legRepeats) {
+    public void sendXML(String path, String serverName, Integer legRepeats, Integer maxPlayers, Boolean tokensEnabled) {
-        Pair<String, String> regattaRace = XMLParser.parseRaceDef(path, serverName, legRepeats);
+        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(
-                regattaRace.getKey(), XMLMessageSubType.REGATTA, regattaRace.getKey().length()
+                regatta, XMLMessageSubType.REGATTA, regatta.length()
             ).getBuffer()
         );
-
         sendByteBuffer(
             new XMLMessage(
-                regattaRace.getValue(), XMLMessageSubType.RACE, regattaRace.getValue().length()
+                race, XMLMessageSubType.RACE, race.length()
             ).getBuffer()
         );
     }

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

@@ -131,18 +131,20 @@ public class GameClient {
      * @param ipAddress IP to connect to.
      * @param portNumber Port to connect to.
      */
-    public ServerDescription runAsHost(String ipAddress, Integer portNumber, String serverName, Integer maxPlayers, String race, Integer numLegs) {
+    public ServerDescription runAsHost(
+        String ipAddress, Integer portNumber, String serverName, Integer maxPlayers, String race,
+        Integer numLegs, Boolean tokensEnabled
+    ) {
         XMLGenerator.setDefaultRaceName(serverName);
 
         server = new MainServerThread();
-        GameState.setMaxPlayers(maxPlayers);
 
         try {
             startClientToServerThread(ipAddress, 4942);
         } catch (IOException e) {
             showConnectionError("Cannot connect to server as host");
         }
-        socketThread.sendXML(race, serverName, numLegs);
+        socketThread.sendXML(race, serverName, numLegs, maxPlayers, tokensEnabled);
         while (regattaData == null){
             try {
                 Thread.sleep(100);
@@ -222,6 +224,7 @@ public class GameClient {
                     break;
 
                 case RACE_XML:
+                    System.out.println("HEY I GOT A RACE MANG AND I AM CLIENT " + ((Boolean) (server==null)).toString());
                     RaceXMLData raceXMLData = XMLParser.parseRace(
                         StreamParser.extractXmlMessage(packet)
                     );

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

@@ -26,7 +26,6 @@ import org.fxyz3d.scene.Skybox;
 import seng302.gameServer.messages.RoundingSide;
 import seng302.model.ClientYacht;
 import seng302.model.GameKeyBind;
-import seng302.model.GeoPoint;
 import seng302.model.KeyAction;
 import seng302.model.Limit;
 import seng302.model.ScaledPoint;
@@ -62,6 +61,7 @@ public class GameView3D extends GameView{
     private SubScene view;
     private Group gameObjects;
 
+    private Group raceBorder = new Group();
     // Cameras
     private PerspectiveCamera isometricCam;
     private PerspectiveCamera topDownCam;
@@ -101,6 +101,8 @@ public class GameView3D extends GameView{
         topDownCam = new TopDownCamera();
         chaseCam = new ChaseCamera();
 
+        canvasWidth = canvasHeight = 300;
+
         for (PerspectiveCamera pc : Arrays.asList(isometricCam, topDownCam, chaseCam)) {
             pc.setFarClip(100000);
             pc.setNearClip(0.1);

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

@@ -13,8 +13,11 @@ 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;
 
 /**
@@ -26,8 +29,10 @@ public class MapMaker {
     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();
 
     public static MapMaker getInstance() {
         if (instance == null) {
@@ -41,32 +46,39 @@ public class MapMaker {
         File[] directoryListing = dir.listFiles();
         if (directoryListing != null) {
             for (File child : directoryListing) {
-                Pair<String, String> regattaRace = XMLParser.parseRaceDef(
+                Pair<RegattaXMLTemplate, RaceXMLTemplate> regattaRace = XMLParser.parseRaceDef(
-                    child.getAbsolutePath(), "", 1
+                    child.getAbsolutePath(), "", 1, null, false
                 );
                 filePaths.add(child.getAbsolutePath());
+                RegattaXMLTemplate regattaTemplate = regattaRace.getKey();
+                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(regattaRace.getKey())));
+                    doc = db.parse(new InputSource(new StringReader(xmlGenerator.getRaceAsXml())));
-                } catch (ParserConfigurationException | IOException | SAXException e) {
-                    e.printStackTrace();
-                }
-                regattas.add(XMLParser.parseRegatta(doc));
-                try {
-                    db = dbf.newDocumentBuilder();
-                    doc = db.parse(new InputSource(new StringReader(regattaRace.getValue())));
                 } catch (ParserConfigurationException | IOException | SAXException e) {
                     e.printStackTrace();
                 }
+
                 RaceXMLData race = XMLParser.parseRace(doc);
-                MapPreview mapPreview = new MapPreview(
+                maxPlayers.add(XMLParser.getMaxPlayers(doc));
+
+                mapPreviews.add(new MapPreview(
                     new ArrayList<>(race.getCompoundMarks().values()),
                     race.getMarkSequence(), race.getCourseLimit()
-                );
+                ));
-                mapPreviews.add(mapPreview);
                 races.add(race);
             }
         }
@@ -101,4 +113,8 @@ public class MapMaker {
     public String getCurrentRacePath() {
         return filePaths.get(index);
     }
+
+    public Integer getMaxPlayers() {
+        return maxPlayers.get(index);
+    }
 }

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

@@ -11,7 +11,6 @@ import java.util.ResourceBundle;
 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;
@@ -56,14 +55,18 @@ public class ServerCreationController implements Initializable {
     private List<ServerCreationDialogListener> serverCreationDialogListeners;
 
     public void initialize(URL location, ResourceBundle resources) {
-        legsSlider.setMax(10);
+
-        legsSlider.setValue(4);
         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();
         updateLegSliderLabel();
 
@@ -113,7 +116,7 @@ public class ServerCreationController implements Initializable {
     private void createServer() {
         ServerDescription serverDescription = ViewManager.getInstance().getGameClient()
             .runAsHost("localhost", 4941, serverName.getText(), (int) maxPlayersSlider
-                .getValue(), mapMaker.getCurrentRacePath(), (int) legsSlider.getValue());
+                .getValue(), mapMaker.getCurrentRacePath(), (int) legsSlider.getValue(), pickupsCheckBox.isSelected());
 
         ViewManager.getInstance().setProperty("serverName", serverDescription.getName());
         ViewManager.getInstance().setProperty("mapName", serverDescription.getMapName());
@@ -135,20 +138,25 @@ public class ServerCreationController implements Initializable {
 
     }
 
-    public void playButtonHoverSound(MouseEvent mouseEvent) {
+    public void playButtonHoverSound() {
         Sounds.playHoverSound();
     }
 
     private void nextMap() {
         mapMaker.next();
-        mapHolder.getChildren().setAll(mapMaker.getCurrentGameView());
+        updateMap();
-        mapNameLabel.setText(mapMaker.getCurrentRegatta().getCourseName());
     }
 
     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) {

src/main/resources/maps/default.xml

@@ -6,6 +6,8 @@
   <CentralLat> 57.6679590 </CentralLat>
   <CentralLng> 11.8503233 </CentralLng>
 
+  <MaxPlayers> 10 </MaxPlayers>
+
   <Marks>
     <CompoundMark CompoundMarkID="1">
       <Mark Lat="57.670603" Lng="11.828262"/>

src/main/resources/maps/horseshoe.xml

@@ -6,10 +6,12 @@
   <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.070814" Lng="47.058041"/>
+      <Mark Lat="-14.069914" Lng="47.058541"/>
     </CompoundMark>
     <CompoundMark CompoundMarkID="2">
       <Mark Lat="-14.067194" Lng="47.053818" />
@@ -61,7 +63,7 @@
 
   <CourseLimit>
     <Limit Lat="-14.073371" Lng="47.058213" />
-    <Limit Lat="-14.06653" Lng="47.051003" />
+    <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" />

src/main/resources/server_config/xml_templates/race.ftlh

@@ -5,13 +5,13 @@
     <RaceID>15082901</RaceID>
     <RaceType>Fleet</RaceType>
 
-    <Participants>
+    <Participants MaxPlayers="${maxPlayers}">
         <#list boats as boat>
             <Yacht SourceID="${boat.sourceId}"/>
         </#list>
     </Participants>
 
-    <Tokens>
+    <Tokens Enabled="${tokensEnabled}">
         <#list tokens as token>
             <Token TokenType="${token.tokenType}" TargetLat="${token.lat?c}" TargetLng="${token.lng?c}"/>
         </#list>

src/test/java/seng302/models/MarkOrderTest.java

@@ -4,14 +4,20 @@ import static junit.framework.TestCase.assertEquals;
 import static junit.framework.TestCase.assertFalse;
 import static junit.framework.TestCase.assertTrue;
 
+import java.io.IOException;
+import java.io.StringReader;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Test;
-import seng302.gameServer.messages.XMLMessageSubType;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
 import seng302.model.mark.CompoundMark;
 import seng302.model.mark.MarkOrder;
-import seng302.model.stream.packets.StreamPacket;
+import seng302.utilities.XMLGenerator;
-import seng302.utilities.StreamParser;
 import seng302.utilities.XMLParser;
 
 public class MarkOrderTest {
@@ -35,17 +41,22 @@ public class MarkOrderTest {
         ///-(    \'   \\
 
          */
-        markOrder = new MarkOrder(
+        XMLGenerator xmlGenerator = new XMLGenerator();
-            XMLParser.parseRace(
+        xmlGenerator.setRaceTemplate(
-                StreamParser.extractXmlMessage(
+            XMLParser.parseRaceDef(
-                    new StreamPacket(
+                "/maps/default.xml", "test", 2, null, false
-                        XMLMessageSubType.RACE.getType(),
+            ).getValue()
-                        XMLParser.parseRaceDef("/maps/default.xml", "test", 2).getValue().length(),
-                        0, XMLParser.parseRaceDef("/maps/default.xml", "test", 2).getValue().getBytes()
-                    )
-                )
-            )
         );
+        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();
+        }
+        markOrder = new MarkOrder(XMLParser.parseRace(doc));
         currentSeqID = 0;
     }