Copied remaining files into appropriate package. These need to be refactored and put into the shared package.

racevisionGame/src/main/java/mock/app/App.java

@@ -0,0 +1,73 @@
+package mock.app;
+
+
+import javafx.application.Application;
+import javafx.stage.Stage;
+import mock.dataInput.PolarParser;
+import mock.model.Polars;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.TransformerException;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+public class App extends Application {
+
+    /**
+     * Entry point for running the programme
+     *
+     * @param args for starting the programme
+     */
+    public static void main(String[] args) {
+        launch(args);
+    }
+
+    @Override
+    public void start(Stage primaryStage) {
+        try {
+            Polars boatPolars = PolarParser.parse("polars/acc_polars.csv");
+
+            String regattaXML = readFile("mockXML/regattaTest.xml", StandardCharsets.UTF_8);
+            String raceXML = readFile("mockXML/raceTest.xml", StandardCharsets.UTF_8);
+            String boatXML = readFile("mockXML/boatTest.xml", StandardCharsets.UTF_8);
+
+            Event raceEvent = new Event(raceXML, regattaXML, boatXML, boatPolars);
+            raceEvent.start();
+
+        } catch (Exception e) {
+            //Catch all exceptions, print, and exit.
+            e.printStackTrace();
+            System.exit(1);
+        }
+    }
+
+    /**
+     * Reads the Initial Race XML files that are necessary to run the mock.
+     * @param path path of the XML
+     * @param encoding encoding of the xml
+     * @return
+     * @throws IOException No file etc
+     * @throws ParserConfigurationException Issue with the XML formatting
+     * @throws SAXException Issue with XML formatting
+     * @throws TransformerException Issue with the XML format
+     */
+    private String readFile(String path, Charset encoding) throws IOException, ParserConfigurationException, SAXException, TransformerException {
+
+        InputSource fXmlFile = new InputSource(getClass().getClassLoader().getResourceAsStream(path));
+
+        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
+        DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
+        Document doc = dBuilder.parse(fXmlFile);
+        doc.getDocumentElement().normalize();
+
+        return XMLReader.getContents(doc);
+
+    }
+
+}

racevisionGame/src/main/java/mock/app/Event.java

@@ -0,0 +1,80 @@
+package mock.app;
+
+import mock.model.Polars;
+import network.Messages.Enums.MessageType;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.IOException;
+import java.text.ParseException;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+
+
+/**
+ * A Race Event, this holds all of the race's information as well as handling the connection to its clients.
+ */
+public class Event {
+
+    String raceXML;
+    String regattaXML;
+    String boatXML;
+    Polars boatPolars;
+    MockOutput mockOutput;
+
+    public Event(String raceXML, String regattaXML, String boatXML, Polars boatPolars) {
+
+        this.raceXML = getRaceXMLAtCurrentTime(raceXML);
+        this.boatXML = boatXML;
+        this.regattaXML = regattaXML;
+        this.boatPolars = boatPolars;
+        try {
+            mockOutput = new MockOutput();
+            new Thread(mockOutput).start();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Sends the initial race data and then begins race simulation
+     */
+    public void start() {
+        try {
+            sendXMLs();
+            Race newRace = new Race(new RaceXMLReader(this.raceXML, new BoatXMLReader(boatXML, this.boatPolars)), mockOutput);
+            new Thread((newRace)).start();
+
+        } catch (ParserConfigurationException | IOException | SAXException | ParseException | StreamedCourseXMLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Sends out each xml string, via the mock output
+     */
+    private void sendXMLs() {
+
+        mockOutput.setRegattaXml(regattaXML);
+        mockOutput.parseXMLString(regattaXML, MessageType.XMLMESSAGE.getValue());
+
+        mockOutput.setRaceXml(raceXML);
+        mockOutput.parseXMLString(raceXML, MessageType.XMLMESSAGE.getValue());
+
+        mockOutput.setBoatsXml(boatXML);
+        mockOutput.parseXMLString(boatXML, MessageType.XMLMESSAGE.getValue());
+    }
+
+    /**
+     * Sets the xml description of the race to show the race was created now, and starts in 3 minutes
+     * @param raceXML
+     * @return String containing edited xml
+     */
+    private String getRaceXMLAtCurrentTime(String raceXML) {
+        DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssZ");
+        ZonedDateTime creationTime = ZonedDateTime.now();
+        return raceXML.replace("CREATION_TIME", dateFormat.format(creationTime))
+                .replace("START_TIME", dateFormat.format(creationTime.plusMinutes(3)));
+    }
+
+}

racevisionGame/src/main/java/mock/app/MockOutput.java

@@ -0,0 +1,254 @@
+package mock.app;
+
+
+
+import network.BinaryMessageEncoder;
+import network.MessageEncoders.RaceVisionByteEncoder;
+import network.MessageEncoders.XMLMessageEncoder;
+import network.Messages.BoatLocation;
+import network.Messages.Enums.MessageType;
+import network.Messages.RaceStatus;
+import network.Messages.XMLMessage;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+import java.util.concurrent.ArrayBlockingQueue;
+
+/**
+ * TCP server to send race information to connected clients.
+ */
+public class MockOutput implements Runnable
+{
+    ///Timestamp of the last sent heartbeat message.
+    private long lastHeartbeatTime;
+
+    ///Period for the heartbeat - that is, how often we send it.
+    private double heartbeatPeriod = 5.0;
+
+    ///Port to expose server on.
+    private int serverPort = 4942;
+    ///Socket used to listen for clients on.
+    private ServerSocket serverSocket;
+    ///Socket used to communicate with a client.
+    private Socket mockSocket;
+    ///Output stream which wraps around mockSocket outstream.
+    private DataOutputStream outToVisualiser;
+
+    ///A queue that contains items that are waiting to be sent.
+    private ArrayBlockingQueue<byte[]> messagesToSendQueue = new ArrayBlockingQueue<>(99999999);
+
+    ///Sequence numbers used in messages.
+    private short messageNumber = 1;
+    private short xmlSequenceNumber = 1;
+    private int heartbeatSequenceNum = 1;
+    private int boatLocationSequenceNumber = 1;
+    private int raceStatusSequenceNumber = 1;
+
+    ///Strings containing XML data as strings.
+    private String raceXml;
+    private String regattaXml;
+    private String boatsXml;
+
+    private boolean stop = false; //whether or not hte thread keeps running
+
+    /**
+     * Ctor.
+     * @throws IOException if server socket cannot be opened.
+     */
+    public MockOutput() throws  IOException {
+        lastHeartbeatTime = System.currentTimeMillis();
+        serverSocket = new ServerSocket(serverPort);
+
+    }
+    /**
+     * Calculates the time since last heartbeat message, in seconds.
+     * @return Time since last heartbeat message, in seconds.
+     */
+    private double timeSinceHeartbeat() {
+        long now = System.currentTimeMillis();
+        return (now - lastHeartbeatTime) / 1000.0;
+    }
+
+    //returns the heartbeat message
+
+    /**
+     * Increment the heartbeat value
+     * @return message for heartbeat data
+     */
+    private byte[] heartbeat(){
+        byte[] heartbeatMessage = RaceVisionByteEncoder.heartBeat(heartbeatSequenceNum);
+        heartbeatSequenceNum++;
+        BinaryMessageEncoder binaryMessageEncoder = new BinaryMessageEncoder(MessageType.HEARTBEAT, System.currentTimeMillis(), messageNumber, (short)heartbeatMessage.length, heartbeatMessage);
+        messageNumber++;
+        return binaryMessageEncoder.getFullMessage();
+    }
+
+    /**
+     * Used to give the mockOutput an xml string to be made into a message and sent
+     * @param xmlString the xml string to send
+     * @param messageType the kind of xml string, values given in AC35 spec (5 regatta, 6 race, 7 boat)
+     */
+    public synchronized void parseXMLString(String xmlString, int messageType){
+        XMLMessageEncoder encoder = new XMLMessageEncoder(messageNumber, System.currentTimeMillis(), messageType, xmlSequenceNumber,(short) xmlString.length(), xmlString);
+        //iterates the sequence numbers
+        xmlSequenceNumber++;
+        byte[] encodedXML = encoder.encode();
+
+        BinaryMessageEncoder binaryMessageEncoder = new BinaryMessageEncoder(MessageType.XMLMESSAGE, System.currentTimeMillis(), messageNumber, (short)encodedXML.length, encodedXML);
+        //iterates the message number
+        messageNumber++;
+
+        addMessageToBufferToSend(binaryMessageEncoder.getFullMessage());
+    }
+
+    /**
+     * Used to give the mocOutput information about boat location to be made into a message and sent
+     * @param sourceID id of the boat
+     * @param lat latitude of boat
+     * @param lon longitude of boat
+     * @param heading heading of boat
+     * @param speed speed of boat
+     * @param time historical time of race
+     */
+    public synchronized void parseBoatLocation(int sourceID, double lat, double lon, double heading, double speed, long time){
+
+        BoatLocation boatLocation = new BoatLocation(sourceID, lat, lon, boatLocationSequenceNumber, heading, speed, time);
+        //iterates the sequence number
+        boatLocationSequenceNumber++;
+
+        //encodeds the messages
+        byte[] encodedBoatLoc = RaceVisionByteEncoder.boatLocation(boatLocation);
+
+        //encodeds the full message with header
+        BinaryMessageEncoder binaryMessageEncoder = new BinaryMessageEncoder(MessageType.BOATLOCATION, System.currentTimeMillis(), messageNumber, (short)encodedBoatLoc.length,
+                encodedBoatLoc);
+
+        //iterates the message number
+        messageNumber++;
+
+        addMessageToBufferToSend(binaryMessageEncoder.getFullMessage());
+    }
+
+    /**
+     * Parse the race status data and add it to the buffer to be sent
+     * @param raceStatus race status to parses
+     */
+    public synchronized void parseRaceStatus(RaceStatus raceStatus){
+
+        //iterates the sequence number
+        raceStatusSequenceNumber++;
+
+        //encodeds the messages
+        byte[] encodedRaceStatus = RaceVisionByteEncoder.raceStatus(raceStatus);
+
+        //encodeds the full message with header
+        BinaryMessageEncoder binaryMessageEncoder = new BinaryMessageEncoder(MessageType.RACESTATUS, System.currentTimeMillis(), messageNumber, (short)encodedRaceStatus.length,
+                encodedRaceStatus);
+
+        //iterates the message number
+        messageNumber++;
+
+        addMessageToBufferToSend(binaryMessageEncoder.getFullMessage());
+
+    }
+
+    /**
+     * Add a message to the buffer to be sent
+     * @param messagesToSendBuffer message to add to the buffer
+     */
+    private synchronized void addMessageToBufferToSend(byte[] messagesToSendBuffer) {
+        this.messagesToSendQueue.add(messagesToSendBuffer);
+    }
+
+    /**
+     * Sending loop of the Server
+     */
+    public void run() {
+
+        try {
+            while (!stop){
+                System.out.println("Waiting for a connection...");//TEMP DEBUG REMOVE
+                mockSocket = serverSocket.accept();
+
+                outToVisualiser = new DataOutputStream(mockSocket.getOutputStream());
+
+                if (boatsXml == null || regattaXml == null || raceXml == null){
+                    try {
+                        Thread.sleep(500);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    continue;
+                }
+
+                parseXMLString(raceXml, XMLMessage.XMLTypeRace);
+                parseXMLString(regattaXml, XMLMessage.XMLTypeRegatta);
+                parseXMLString(boatsXml, XMLMessage.XMLTypeBoat);
+
+
+                while(true) {
+                    try {
+                        //Sends a heartbeat every so often.
+                        if (timeSinceHeartbeat() >= heartbeatPeriod) {
+                            outToVisualiser.write(heartbeat());
+                            lastHeartbeatTime = System.currentTimeMillis();
+                        }
+
+                        //Checks the buffer to see if there is anything to send.
+                        while (messagesToSendQueue.size() > 0) {
+                            //Grabs message from head of queue.
+                            byte[] binaryMessage = messagesToSendQueue.remove();
+
+                            //sends the message to the visualiser
+                            outToVisualiser.write(binaryMessage);
+
+                        }
+                    }catch(SocketException e){
+                        break;
+                    }
+
+                }
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void stop(){
+        stop = true;
+    }
+
+    /**
+     * Sets the Race XML to send
+     * @param raceXml XML to send to the CLient
+     */
+    public void setRaceXml(String raceXml) {
+        this.raceXml = raceXml;
+    }
+
+    /**
+     * Sets the Regatta XMl to send
+     * @param regattaXml XML to send to CLient
+     */
+    public void setRegattaXml(String regattaXml) {
+        this.regattaXml = regattaXml;
+    }
+
+    /**
+     * Sets the Boats XML to send
+     * @param boatsXml XMl to send to the CLient
+     */
+    public void setBoatsXml(String boatsXml) {
+        this.boatsXml = boatsXml;
+    }
+
+    public static void main(String argv[]) throws Exception
+    {
+        MockOutput client = new MockOutput();
+        client.run();
+    }
+
+}

racevisionGame/src/main/java/mock/dataInput/BoatDataSource.java

@@ -0,0 +1,14 @@
+package mock.dataInput;
+
+import seng302.Model.Boat;
+import seng302.Model.Mark;
+
+import java.util.Map;
+
+/**
+ * Boats Data
+ */
+public interface BoatDataSource {
+    Map<Integer, Boat> getBoats();
+    Map<Integer, Mark> getMarkerBoats();
+}

racevisionGame/src/main/java/mock/dataInput/BoatXMLReader.java

@@ -0,0 +1,149 @@
+package mock.dataInput;
+
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.xml.sax.SAXException;
+import seng302.Model.Boat;
+import seng302.Model.GPSCoordinate;
+import seng302.Model.Mark;
+import seng302.Model.Polars;
+
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Xml Reader class for Boat XML used for the race
+ */
+public class BoatXMLReader extends XMLReader implements BoatDataSource {
+
+    private final Map<Integer, Boat> boatMap = new HashMap<>();
+    private final Map<Integer, Mark> markerMap = new HashMap<>();
+
+    /**
+     * Polars table to assign to each boat.
+     */
+    Polars boatPolars;
+
+
+    /**
+     * Constructor for Boat XML
+     *
+     * @param filePath Name/path of file to read. Read as a resource.
+     * @param boatPolars polars used by the boats
+     * @throws IOException                  error
+     * @throws SAXException                 error
+     * @throws ParserConfigurationException error
+     */
+    public BoatXMLReader(String filePath, Polars boatPolars) throws IOException, SAXException, ParserConfigurationException {
+        super(filePath);
+        this.boatPolars = boatPolars;
+        read();
+    }
+
+    /**
+     * Read the XML
+     */
+    public void read() {
+        readSettings();
+        readShapes();
+        readBoats();
+    }
+
+    /**
+     * Read the Boats
+     */
+    private void readBoats() {
+        Element nBoats = (Element) doc.getElementsByTagName("Boats").item(0);
+        for (int i = 0; i < nBoats.getChildNodes().getLength(); i++) {
+            Node boat = nBoats.getChildNodes().item(i);
+            if (boat.getNodeName().equals("Boat")) {
+                readBoatNode(boat);
+            }
+        }
+    }
+
+    /**
+     * Ignored data
+     */
+    private void readShapes() {
+
+    }
+
+    /**
+     * Ignored data
+     */
+    private void readSettings() {
+
+    }
+
+    /**
+     * Checks if the node (XMl data node) is a Yacht or not
+     * @param boatNode Node from the XML
+     * @return Whether the node is a yacht node or not
+     */
+    private boolean isYachtNode(Node boatNode) {
+        return boatNode.getAttributes().getNamedItem("Type").getTextContent().toLowerCase().equals("yacht");
+    }
+
+    /**
+     * Reads the information about one boat
+     * Ignored values: ShapeID, StoweName, HullNum, Skipper, Type
+     */
+    private void readBoatNode(Node boatNode) {
+        int sourceID = Integer.parseInt(boatNode.getAttributes().getNamedItem("SourceID").getTextContent());
+        String name = boatNode.getAttributes().getNamedItem("BoatName").getTextContent();
+
+        if (isYachtNode(boatNode)) readYacht(boatNode, sourceID, name);
+        else readMark(boatNode, sourceID, name);
+    }
+
+    /**
+     * Read a Yacht Node
+     * @param boatNode Node to be read
+     * @param sourceID Source ID of the Yacht
+     * @param name Name of the Boat
+     */
+    private void readYacht(Node boatNode, int sourceID, String name) {
+        String shortName = boatNode.getAttributes().getNamedItem("ShortName").getTextContent();
+        if (exists(boatNode, "Country")) {
+            String country = boatNode.getAttributes().getNamedItem("Country").getTextContent();
+            boatMap.put(sourceID, new Boat(sourceID, name, country, this.boatPolars));
+        } else {
+            boatMap.put(sourceID, new Boat(sourceID, name, shortName, this.boatPolars));
+        }
+    }
+
+    /**
+     * Read Marker Boats
+     * @param boatNode Node to be read
+     * @param sourceID Source ID of the boat
+     * @param name Name of the Marker Boat
+     */
+    private void readMark(Node boatNode, int sourceID, String name) {
+        Node nCoord = ((Element)boatNode).getElementsByTagName("GPSposition").item(0);
+        double x = Double.parseDouble(nCoord.getAttributes().getNamedItem("X").getTextContent());
+        double y = Double.parseDouble(nCoord.getAttributes().getNamedItem("Y").getTextContent());
+        Mark mark = new Mark(sourceID, name, new GPSCoordinate(y,x));
+        markerMap.put(sourceID, mark);
+    }
+
+    /**
+     * Get the boats that are going to participate in this race
+     * @return Dictionary of boats that are to participate in this race indexed by SourceID
+     */
+    @Override
+    public Map<Integer, Boat> getBoats() {
+        return boatMap;
+    }
+
+    /**
+     * Get the marker BOats that are participating in this race
+     * @return Dictionary of the Markers BOats that are in this race indexed by their Source ID.
+     */
+    @Override
+    public Map<Integer, Mark> getMarkerBoats() {
+        return markerMap;
+    }
+}

racevisionGame/src/main/java/mock/dataInput/RaceDataSource.java

@@ -0,0 +1,32 @@
+package mock.dataInput;
+
+import seng302.Model.Boat;
+import seng302.Model.CompoundMark;
+import seng302.Model.GPSCoordinate;
+import seng302.Model.Leg;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+
+/**
+ * Data Class for a Race
+ */
+public interface RaceDataSource {
+    List<Boat> getBoats();
+
+    List<Leg> getLegs();
+
+    List<GPSCoordinate> getBoundary();
+
+    List<CompoundMark> getCompoundMarks();
+
+    int getRaceId();
+
+    String getRaceType();
+
+    ZonedDateTime getZonedDateTime();
+
+    GPSCoordinate getMapTopLeft();
+
+    GPSCoordinate getMapBottomRight();
+}

racevisionGame/src/main/java/mock/dataInput/RaceXMLReader.java

@@ -0,0 +1,287 @@
+package mock.dataInput;
+
+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.Exceptions.StreamedCourseXMLException;
+
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.IOException;
+import java.text.ParseException;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+
+/**
+ * XML Reader that reads in the race data required for this race
+ */
+public class RaceXMLReader extends XMLReader implements RaceDataSource {
+    private static final double COORDINATEPADDING = 0.000;
+    private GPSCoordinate mapTopLeft, mapBottomRight;
+    private final List<GPSCoordinate> boundary = new ArrayList<>();
+    private final Map<Integer,Element> compoundMarkMap = new HashMap<>();
+    private final Map<Integer, Boat> participants = new HashMap<>();
+    private final List<Leg> legs = new ArrayList<>();
+    private final List<CompoundMark> compoundMarks = new ArrayList<>();
+    private ZonedDateTime creationTimeDate;
+    private ZonedDateTime raceStartTime;
+    private int raceID;
+    private String raceType;
+    private boolean postpone;
+
+    private Map<Integer, Boat> boats;
+    private Map<Integer, Mark> marks;
+
+    /**
+     * Constructor for Streamed Race XML
+     * @param filePath path of the file
+     * @param boatData data for boats in race
+     * @throws IOException error
+     * @throws SAXException error
+     * @throws ParserConfigurationException error
+     * @throws ParseException error
+     * @throws StreamedCourseXMLException error
+     */
+    public RaceXMLReader(String filePath, BoatDataSource boatData) throws IOException, SAXException, ParserConfigurationException, ParseException, StreamedCourseXMLException {
+        this(filePath, boatData, true);
+    }
+
+
+
+    /**
+     * Constructor for Streamed Race XML
+     * @param filePath file path to read
+     * @param boatData data of the boats in race
+     * @param read whether or not to read and store the files straight away.
+     * @throws IOException error
+     * @throws SAXException error
+     * @throws ParserConfigurationException error
+     * @throws ParseException error
+     * @throws StreamedCourseXMLException error
+     */
+    public RaceXMLReader(String filePath, BoatDataSource boatData, boolean read) throws IOException, SAXException, ParserConfigurationException, ParseException, StreamedCourseXMLException {
+        super(filePath);
+        this.boats = boatData.getBoats();
+        this.marks = boatData.getMarkerBoats();
+        if (read) {
+            read();
+        }
+    }
+
+    /**
+     * reads
+     * @throws StreamedCourseXMLException error
+     */
+    private void read() throws StreamedCourseXMLException {
+        readRace();
+        readParticipants();
+        readCourse();
+    }
+
+    /**
+     * reads a race
+     */
+    private void readRace() {
+        DateTimeFormatter dateFormat = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
+        Element settings = (Element) doc.getElementsByTagName("Race").item(0);
+        NamedNodeMap raceTimeTag = doc.getElementsByTagName("RaceStartTime").item(0).getAttributes();
+
+        if (raceTimeTag.getNamedItem("Time") != null) dateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssZ");
+
+
+        raceID = Integer.parseInt(getTextValueOfNode(settings, "RaceID"));
+        raceType = getTextValueOfNode(settings, "RaceType");
+
+        creationTimeDate = ZonedDateTime.parse(getTextValueOfNode(settings, "CreationTimeDate"), dateFormat);
+
+        if (raceTimeTag.getNamedItem("Time") != null) raceStartTime = ZonedDateTime.parse(raceTimeTag.getNamedItem("Time").getTextContent(), dateFormat);
+        else raceStartTime = ZonedDateTime.parse(raceTimeTag.getNamedItem("Start").getTextContent(), dateFormat);
+
+        postpone = Boolean.parseBoolean(raceTimeTag.getNamedItem("Postpone").getTextContent());
+    }
+
+    /**
+     * Reads in the participants for htis race
+     */
+    private void readParticipants() {
+        Element nParticipants = (Element) doc.getElementsByTagName("Participants").item(0);
+        nParticipants.getChildNodes().getLength();
+        for (int i = 0; i < nParticipants.getChildNodes().getLength(); i++) {
+            int sourceID;
+            Node yacht = nParticipants.getChildNodes().item(i);
+            if (yacht.getNodeName().equals("Yacht")) {
+                if (exists(yacht, "SourceID")) {
+                    sourceID = Integer.parseInt(yacht.getAttributes().getNamedItem("SourceID").getTextContent());
+                    participants.put(sourceID, boats.get(sourceID));
+                }
+            }
+        }
+    }
+
+    /**
+     * reads a course
+     * @throws StreamedCourseXMLException error
+     */
+    private void readCourse() throws StreamedCourseXMLException {
+        readCompoundMarks();
+        readCompoundMarkSequence();
+        readCourseLimit();
+    }
+
+    /**
+     * Indexes CompoundMark elements by their ID for use in generating the course, and populates list of Markers.
+     * @see CompoundMark
+     */
+    private void readCompoundMarks() throws StreamedCourseXMLException {
+        Element nCourse = (Element) doc.getElementsByTagName("Course").item(0);
+        for(int i = 0; i < nCourse.getChildNodes().getLength(); i++) {
+            Node compoundMark = nCourse.getChildNodes().item(i);
+            if(compoundMark.getNodeName().equals("CompoundMark")) {
+                int compoundMarkID = getCompoundMarkID((Element) compoundMark);
+                compoundMarkMap.put(compoundMarkID, (Element)compoundMark);
+                compoundMarks.add(getCompoundMark(compoundMarkID));
+            }
+        }
+    }
+
+    /**
+     * Generates a CompoundMark from the CompoundMark element with given ID.
+     * @param compoundMarkID index of required CompoundMark element
+     * @return generated CompoundMark
+     * @throws StreamedCourseXMLException if CompoundMark element contains unhandled number of compoundMarks
+     * @see CompoundMark
+     */
+    private CompoundMark getCompoundMark(int compoundMarkID) throws StreamedCourseXMLException {
+        Element compoundMark = compoundMarkMap.get(compoundMarkID);
+        NodeList nMarks = compoundMark.getElementsByTagName("Mark");
+        CompoundMark marker;
+
+        switch(nMarks.getLength()) {
+            case 1: marker = new CompoundMark(getMark((Element)nMarks.item(0)));
+            break;
+            case 2: marker = new CompoundMark(getMark((Element)nMarks.item(0)), getMark((Element)nMarks.item(1))); break;
+            default: throw new StreamedCourseXMLException();
+        }
+
+        return marker;
+    }
+
+    /**
+     * Gets a mark from an Element
+     * @param mark Element the mark is suppose to be part of
+     * @return a Mark that existed in the element
+     */
+    private Mark getMark(Element mark) {
+        int sourceID = Integer.parseInt(mark.getAttribute("SourceID"));
+        return marks.get(sourceID);
+    }
+
+    /**
+     * Reads "compoundMarkID" attribute of CompoundMark or Corner element
+     * @param element with "compoundMarkID" attribute
+     * @return value of "compoundMarkID" attribute
+     */
+    private int getCompoundMarkID(Element element) {
+        return Integer.parseInt(element.getAttribute("CompoundMarkID"));
+    }
+
+    /**
+     * Reads "name" attribute of CompoundMark element with corresponding CompoundMarkID
+     * @param compoundMarkID unique ID for CompoundMark element
+     * @return value of "name" attribute
+     */
+    private String getCompoundMarkName(int compoundMarkID) {
+        return compoundMarkMap.get(compoundMarkID).getAttribute("Name");
+    }
+
+    /**
+     * Populates list of legs given CompoundMarkSequence element and referenced CompoundMark elements.
+     * @throws StreamedCourseXMLException if compoundMarks cannot be resolved from CompoundMark
+     */
+    private void readCompoundMarkSequence() throws StreamedCourseXMLException {
+        Element nCompoundMarkSequence = (Element) doc.getElementsByTagName("CompoundMarkSequence").item(0);
+        NodeList nCorners = nCompoundMarkSequence.getElementsByTagName("Corner");
+        Element markXML = (Element)nCorners.item(0);
+        CompoundMark lastCompoundMark = getCompoundMark(getCompoundMarkID(markXML));
+        String legName = getCompoundMarkName(getCompoundMarkID(markXML));
+        for(int i = 1; i < nCorners.getLength(); i++) {
+            markXML = (Element)nCorners.item(i);
+            CompoundMark currentCompoundMark = getCompoundMark(getCompoundMarkID(markXML));
+            legs.add(new Leg(legName, lastCompoundMark, currentCompoundMark, i-1));
+            lastCompoundMark = currentCompoundMark;
+            legName = getCompoundMarkName(getCompoundMarkID(markXML));
+        }
+
+    }
+
+    /**
+     * Reads the boundary limits of the course
+     */
+    private void readCourseLimit() {
+        Element nCourseLimit = (Element) doc.getElementsByTagName("CourseLimit").item(0);
+        for(int i = 0; i < nCourseLimit.getChildNodes().getLength(); i++) {
+            Node limit = nCourseLimit.getChildNodes().item(i);
+            if (limit.getNodeName().equals("Limit")) {
+                double lat = Double.parseDouble(limit.getAttributes().getNamedItem("Lat").getTextContent());
+                double lon = Double.parseDouble(limit.getAttributes().getNamedItem("Lon").getTextContent());
+                boundary.add(new GPSCoordinate(lat, lon));
+            }
+        }
+
+        double maxLatitude = boundary.stream().max(Comparator.comparingDouble(GPSCoordinate::getLatitude)).get().getLatitude() + COORDINATEPADDING;
+        double maxLongitude = boundary.stream().max(Comparator.comparingDouble(GPSCoordinate::getLongitude)).get().getLongitude() + COORDINATEPADDING;
+        double minLatitude = boundary.stream().min(Comparator.comparingDouble(GPSCoordinate::getLatitude)).get().getLatitude() + COORDINATEPADDING;
+        double minLongitude = boundary.stream().min(Comparator.comparingDouble(GPSCoordinate::getLongitude)).get().getLongitude() + COORDINATEPADDING;
+
+        mapTopLeft = new GPSCoordinate(minLatitude, minLongitude);
+        mapBottomRight = new GPSCoordinate(maxLatitude, maxLongitude);
+    }
+
+    public List<GPSCoordinate> getBoundary() {
+        return boundary;
+    }
+
+    public GPSCoordinate getMapTopLeft() {
+        return mapTopLeft;
+    }
+
+    public GPSCoordinate getMapBottomRight() {
+        return mapBottomRight;
+    }
+
+    public List<Leg> getLegs() {
+        return legs;
+    }
+
+    public List<CompoundMark> getCompoundMarks() { return compoundMarks; }
+
+    public Double getPadding() {
+        return COORDINATEPADDING;
+    }
+
+    public ZonedDateTime getCreationTimeDate() {
+        return creationTimeDate;
+    }
+
+    public ZonedDateTime getZonedDateTime() {
+        return raceStartTime;
+    }
+
+    public int getRaceId() {
+        return raceID;
+    }
+
+    public String getRaceType() {
+        return raceType;
+    }
+
+    public boolean isPostpone() {
+        return postpone;
+    }
+
+    public List<Boat> getBoats() {
+        return new ArrayList<>(participants.values());
+    }
+}

racevisionGame/src/main/java/mock/dataInput/XMLReader.java

@@ -0,0 +1,115 @@
+package mock.dataInput;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.StringWriter;
+
+/**
+ * Base Reader for XML Files
+ */
+public abstract class XMLReader {
+
+    protected Document doc;
+
+    /**
+     * Read in XML file
+     * @param filePath filepath for XML file
+     * @throws ParserConfigurationException If a document builder cannot be created.
+     * @throws IOException If any IO errors occur while parsing the XML file.
+     * @throws SAXException If any parse error occurs while parsing.
+     */
+    public XMLReader(String filePath) throws ParserConfigurationException, IOException, SAXException {
+
+        InputSource fXmlFile;
+        if (filePath.contains("<")) {
+            fXmlFile = new InputSource();
+            fXmlFile.setCharacterStream(new StringReader(filePath));
+
+        } else {
+            fXmlFile = new InputSource(getClass().getClassLoader().getResourceAsStream(filePath));
+        }
+
+        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
+        DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
+        doc = dBuilder.parse(fXmlFile);
+        doc.getDocumentElement().normalize();
+    }
+
+    /**
+     * Alternate constructor
+     * @param xmlFile File to be read
+     * @param isWholeFile boolean value whether entire file is being passed
+     */
+    public XMLReader(String xmlFile, Boolean isWholeFile) {
+
+    }
+
+    /**
+     * Return Document data of the read-in XML
+     * @return XML document
+     */
+    public Document getDocument() {
+        return doc;
+    }
+
+    /**
+     * Get content of a tag in an element
+     * @param n Element to read tags from
+     * @param tagName Name of the tag
+     * @return Content of the tag
+     */
+    public String getTextValueOfNode(Element n, String tagName) {
+        return n.getElementsByTagName(tagName).item(0).getTextContent();
+    }
+
+    /**
+     * Get attributes for an element
+     * @param n Element to read attributes from
+     * @param attr Attributes of element
+     * @return Attributes of element
+     */
+    public String getAttribute(Element n, String attr) {
+        return n.getAttribute(attr);
+    }
+
+    protected boolean exists(Node node, String attribute) {
+        return node.getAttributes().getNamedItem(attribute) != null;
+    }
+
+    /**
+     * Get the contents of the XML FILe.
+     * @param document holds all xml information
+     * @return String representation of document
+     * @throws TransformerException when document is malformed, and cannot be turned into a string
+     */
+    public static String getContents(Document document) throws TransformerException {
+        DOMSource source = new DOMSource(document);
+
+        TransformerFactory transformerFactory = TransformerFactory.newInstance();
+        Transformer transformer = transformerFactory.newTransformer();
+        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+        transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
+
+        StringWriter stringWriter = new StringWriter();
+        StreamResult result = new StreamResult(stringWriter);
+        transformer.transform(source, result);
+
+        return stringWriter.toString();
+    }
+
+}

racevisionGame/src/main/java/mock/exceptions/InvalidBoatDataException.java

@@ -0,0 +1,14 @@
+package mock.exceptions;
+
+/**
+ * An exception thrown when we cannot generate Boats.xml and send an XML message.
+ */
+public class InvalidBoatDataException extends RuntimeException {
+
+    public InvalidBoatDataException() {
+    }
+
+    public InvalidBoatDataException(String message) {
+        super(message);
+    }
+}

racevisionGame/src/main/java/mock/exceptions/InvalidRaceDataException.java

@@ -0,0 +1,13 @@
+package mock.exceptions;
+
+/**
+ * Exception thrown when we cannot generate Race.xml data, and send an XML message.
+ */
+public class InvalidRaceDataException extends RuntimeException {
+    public InvalidRaceDataException() {
+    }
+
+    public InvalidRaceDataException(String message) {
+        super(message);
+    }
+}

racevisionGame/src/main/java/mock/exceptions/StreamedCourseXMLException.java

@@ -0,0 +1,7 @@
+package mock.exceptions;
+
+/**
+ * Created by cbt24 on 25/04/17.
+ */
+public class StreamedCourseXMLException extends Throwable {
+}