Renamed sharedModel module to racevisionGame - this is intended to be our single module program.

Moved Boat/MockBoat/VisualiserBoat into it. Moved Polars, polarParser, VMG, and polar exception. Moved the networking stuff into it. Moved angle, azimuth, bearing into it. Moved gpscoordinate into it. Moved mark/compoundMark into it. Moved leg into it. Moved trackpoint into it.
2017-07-04 15:53:17 +12:00
parent 93c1199392
commit bbbb1f2eb0
50 changed files with 5594 additions and 15 deletions
@@ -0,0 +1,55 @@
+package network.MessageDecoders;
+
+import seng302.Networking.Messages.AverageWind;
+import seng302.Networking.Utils.ByteConverter;
+
+import java.util.Arrays;
+
+/**
+ * Created by hba56 on 23/04/17.
+ */
+public class AverageWindDecoder {
+    byte messageVersionNumber;
+    byte[] byteTime;
+    byte[] byteRawPeriod;
+    byte[] byteRawSpeed;
+    byte[] bytePeriod2;
+    byte[] byteSpeed2;
+    byte[] bytePeriod3;
+    byte[] byteSpeed3;
+    byte[] bytePeriod4;
+    byte[] byteSpeed4;
+
+    AverageWind averageWind;
+
+    public AverageWindDecoder(byte[] encodedAverageWind) {
+        messageVersionNumber = encodedAverageWind[0];
+        byteTime = Arrays.copyOfRange(encodedAverageWind, 1, 7);
+        byteRawPeriod = Arrays.copyOfRange(encodedAverageWind, 7, 9);
+        byteRawSpeed = Arrays.copyOfRange(encodedAverageWind, 9, 11);
+        bytePeriod2 = Arrays.copyOfRange(encodedAverageWind, 11, 13);
+        byteSpeed2 = Arrays.copyOfRange(encodedAverageWind, 13, 15);
+        bytePeriod3 = Arrays.copyOfRange(encodedAverageWind, 15, 17);
+        byteSpeed3 = Arrays.copyOfRange(encodedAverageWind, 17, 19);
+        bytePeriod4 = Arrays.copyOfRange(encodedAverageWind, 19, 21);
+        byteSpeed4 = Arrays.copyOfRange(encodedAverageWind, 21, 23);
+
+        int msgNum = ByteConverter.bytesToInt(messageVersionNumber);
+        long lngTime = ByteConverter.bytesToLong(byteTime);
+        int intRawPeriod = ByteConverter.bytesToInt(byteRawPeriod);
+        int intRawSpeed = ByteConverter.bytesToInt(byteRawSpeed);
+        int intPeriod2 = ByteConverter.bytesToInt(bytePeriod2);
+        int intSpeed2 = ByteConverter.bytesToInt(byteSpeed2);
+        int intPeriod3 = ByteConverter.bytesToInt(bytePeriod3);
+        int intSpeed3 = ByteConverter.bytesToInt(byteSpeed3);
+        int intPeriod4 = ByteConverter.bytesToInt(bytePeriod4);
+        int intSpeed4 = ByteConverter.bytesToInt(byteSpeed4);
+
+        this.averageWind = new AverageWind(msgNum, lngTime, intRawPeriod, intRawSpeed, intPeriod2, intSpeed2, intPeriod3, intSpeed3, intPeriod4, intSpeed4);
+
+    }
+
+    public AverageWind getAverageWind() {
+        return averageWind;
+    }
+}
@@ -0,0 +1,139 @@
+package network.MessageDecoders;
+
+import seng302.Networking.Messages.BoatLocation;
+
+import java.util.Arrays;
+
+import static seng302.Networking.Utils.ByteConverter.*;
+
+/**
+ * Created by hba56 on 21/04/17.
+ */
+public class BoatLocationDecoder {
+    private byte messageVersionNumber;
+    private byte[] time;
+    private byte[] sourceID;
+    private byte[] seqNum;
+    private byte deviceType;
+    private byte[] latitude;
+    private byte[] longitude;
+    private byte[] altitude;
+    private byte[] heading;
+    private byte[] pitch;
+    private byte[] roll;
+    private byte[] boatSpeed;
+    private byte[] cog;
+    private byte[] sog;
+    private byte[] apparentWindSpeed;
+    private byte[] apparentWindAngle;
+    private byte[] trueWindSpeed;
+    private byte[] trueWindDirection;
+    private byte[] trueWindAngle;
+    private byte[] currentDrift;
+    private byte[] currentSet;
+    private byte[] rudderAngle;
+
+    private BoatLocation message;
+
+    public BoatLocationDecoder(byte[] encodedBoatLocation) {
+        byte numMessageVersionNumber = 0;
+        long numTime = 0;
+        int numSourceID = 0;
+        int numSeqNum = 0;
+        byte numDeviceType = 0;
+        int numLatitude = 0;
+        int numLongitude = 0;
+        int numAltitude = 0;
+        int numHeading = 0;
+        short numPitch = 0;
+        short numRoll = 0;
+        int numBoatSpeed = 0;
+        int numCog = 0;
+        int numSog = 0;
+        int numApparentWindSpeed = 0;
+        short numApparentWindAngle = 0;
+        int numTrueWindSpeed = 0;
+        short numTrueWindDirection = 0;
+        short numTrueWindAngle = 0;
+        int numCurrentDrift = 0;
+        int numCurrentSet = 0;
+        short numRudderAngle = 0;
+
+        try {
+            messageVersionNumber = encodedBoatLocation[0];
+            numMessageVersionNumber = messageVersionNumber;
+            time = Arrays.copyOfRange(encodedBoatLocation, 1, 7);
+            numTime = bytesToLong(time);
+            sourceID = Arrays.copyOfRange(encodedBoatLocation, 7, 11);
+            numSourceID = bytesToInt(sourceID);
+            seqNum = Arrays.copyOfRange(encodedBoatLocation, 11, 15);
+            numSeqNum = bytesToInt(seqNum);
+            deviceType = encodedBoatLocation[15];
+            numDeviceType = deviceType;
+            latitude = Arrays.copyOfRange(encodedBoatLocation, 16, 20);
+            numLatitude = bytesToInt(latitude);
+            longitude = Arrays.copyOfRange(encodedBoatLocation, 20, 24);
+            numLongitude = bytesToInt(longitude);
+            altitude = Arrays.copyOfRange(encodedBoatLocation, 24, 28);
+            numAltitude = bytesToInt(altitude);
+            heading = Arrays.copyOfRange(encodedBoatLocation, 28, 30);
+            numHeading = bytesToInt(heading);
+            pitch = Arrays.copyOfRange(encodedBoatLocation, 30, 32);
+            numPitch = bytesToShort(pitch);
+            roll = Arrays.copyOfRange(encodedBoatLocation, 32, 34);
+            numRoll = bytesToShort(roll);
+            boatSpeed = Arrays.copyOfRange(encodedBoatLocation, 34, 36);
+            numBoatSpeed = bytesToInt(boatSpeed);
+            cog = Arrays.copyOfRange(encodedBoatLocation, 36, 38);
+            numCog = bytesToInt(cog);
+            sog = Arrays.copyOfRange(encodedBoatLocation, 38, 40);
+            numSog = bytesToInt(sog);
+            apparentWindSpeed = Arrays.copyOfRange(encodedBoatLocation, 40, 42);
+            numApparentWindSpeed = bytesToInt(apparentWindSpeed);
+            apparentWindAngle = Arrays.copyOfRange(encodedBoatLocation, 42, 44);
+            numApparentWindAngle = bytesToShort(apparentWindAngle);
+            trueWindSpeed = Arrays.copyOfRange(encodedBoatLocation, 44, 46);
+            numTrueWindSpeed = bytesToInt(trueWindSpeed);
+            trueWindDirection = Arrays.copyOfRange(encodedBoatLocation, 46, 48);
+            numTrueWindDirection = bytesToShort(trueWindDirection);
+            trueWindAngle = Arrays.copyOfRange(encodedBoatLocation, 48, 50);
+            numTrueWindAngle = bytesToShort(trueWindAngle);
+            currentDrift = Arrays.copyOfRange(encodedBoatLocation, 50, 52);
+            numCurrentDrift = bytesToInt(currentDrift);
+            currentSet = Arrays.copyOfRange(encodedBoatLocation, 52, 54);
+            numCurrentSet = bytesToShort(currentSet);
+            rudderAngle = Arrays.copyOfRange(encodedBoatLocation, 54, 56);
+            numRudderAngle = bytesToShort(rudderAngle);
+        } catch(ArrayIndexOutOfBoundsException e){
+
+        }
+
+        message = new BoatLocation(numMessageVersionNumber, numTime,
+                numSourceID, numSeqNum, numDeviceType, numLatitude,
+                numLongitude, numAltitude, numHeading, numPitch,
+                numRoll, numBoatSpeed, numCog, numSog, numApparentWindSpeed,
+                numApparentWindAngle, numTrueWindSpeed, numTrueWindDirection,
+                numTrueWindAngle, numCurrentDrift, numCurrentSet, numRudderAngle
+        );/*
+        message = new BoatLocation(messageVersionNumber, bytesToLong(time),
+                bytesToInt(sourceID), bytesToInt(seqNum),
+                deviceType, bytesToInt(latitude),
+                bytesToInt(longitude), bytesToInt(altitude),
+                bytesToInt(heading), bytesToShort(pitch),
+                bytesToShort(roll), bytesToInt(boatSpeed),
+                bytesToInt(cog), bytesToInt(sog),
+                bytesToInt(apparentWindSpeed), bytesToShort(apparentWindAngle),
+                bytesToInt(trueWindSpeed), bytesToShort(trueWindDirection),
+                bytesToShort(trueWindAngle), bytesToInt(currentDrift),
+                bytesToInt(currentSet), bytesToShort(rudderAngle)
+        );*/
+
+//        System.out.println(bytesToInt(sourceID));
+//        System.out.println(bytesToInt(boatSpeed));
+    }
+
+
+    public BoatLocation getMessage() {
+        return message;
+    }
+}
@@ -0,0 +1,61 @@
+package network.MessageDecoders;
+
+import seng302.Networking.Messages.CourseWind;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import static seng302.Networking.Utils.ByteConverter.*;
+
+/**
+ * Created by hba56 on 23/04/17.
+ */
+public class CourseWindDecoder {
+    byte messageVersionNumber;
+    byte byteWindID;
+    byte loopCount;
+    ArrayList<CourseWind> loopMessages = new ArrayList();
+
+    public CourseWindDecoder(byte[] encodedCourseWind) {
+        final int lengthInBytesOfMessages = 20;
+
+        messageVersionNumber = encodedCourseWind[0];
+        byteWindID = encodedCourseWind[1];
+        loopCount = encodedCourseWind[2];
+        byte[] loopMessagesBytes = Arrays.copyOfRange(encodedCourseWind, 3, lengthInBytesOfMessages*loopCount+3);
+        int messageLoopIndex = 0;
+
+        for (int i=0; i < loopCount; i++) {
+            byte[] messageBytes = Arrays.copyOfRange(loopMessagesBytes, messageLoopIndex, messageLoopIndex+20);
+            ArrayList test = new ArrayList();
+            byte[] windId = Arrays.copyOfRange(messageBytes, 0, 1);
+            byte[] time = Arrays.copyOfRange(messageBytes, 1, 7);
+            byte[] raceID = Arrays.copyOfRange(messageBytes, 7, 11);
+            byte[] windDirection = Arrays.copyOfRange(messageBytes, 11, 13);
+            byte[] windSpeed = Arrays.copyOfRange(messageBytes, 13, 15);
+            byte[] bestUpwindAngle = Arrays.copyOfRange(messageBytes, 15, 17);
+            byte[] bestDownwindAngle = Arrays.copyOfRange(messageBytes, 17, 19);
+            byte[] flags = Arrays.copyOfRange(messageBytes, 19, 20);
+
+            CourseWind message = new CourseWind(windId[0], bytesToLong(time),
+                    bytesToInt(raceID), bytesToInt(windDirection),
+                    bytesToInt(windSpeed), bytesToInt(bestUpwindAngle),
+                    bytesToInt(bestDownwindAngle), flags[0]);
+
+            loopMessages.add(message);
+            messageLoopIndex += 20;
+        }
+    }
+
+    public ArrayList<CourseWind> getLoopMessages() {
+        return loopMessages;
+    }
+
+    public byte getMessageVersionNumber() {
+        return messageVersionNumber;
+    }
+
+    public byte getByteWindID() {
+        return byteWindID;
+    }
+}
@@ -0,0 +1,51 @@
+package network.MessageDecoders;
+
+import seng302.Networking.Messages.MarkRounding;
+import seng302.Networking.Utils.ByteConverter;
+
+import java.util.Arrays;
+
+/**
+ * Created by hba56 on 23/04/17.
+ */
+public class MarkRoundingDecoder {
+    byte messageVersionNumber;
+    byte[] byteTime;
+    byte[] byteAck;
+    byte[] byteRaceID;
+    byte[] byteSourceID;
+    byte byteBoatStatus;
+    byte byteRoundingSide;
+    byte byteMarkType;
+    byte byteMarkID;
+
+    MarkRounding markRounding;
+
+    public MarkRoundingDecoder(byte[] encodedMarkRounding) {
+        messageVersionNumber = encodedMarkRounding[0];
+        byteTime = Arrays.copyOfRange(encodedMarkRounding, 1, 7);
+        byteAck = Arrays.copyOfRange(encodedMarkRounding, 7, 9);
+        byteRaceID = Arrays.copyOfRange(encodedMarkRounding, 9, 13);
+        byteSourceID = Arrays.copyOfRange(encodedMarkRounding, 13, 17);
+        byteBoatStatus = encodedMarkRounding[17];
+        byteRoundingSide = encodedMarkRounding[18];
+        byteMarkType = encodedMarkRounding[19];
+        byteMarkID = encodedMarkRounding[20];
+
+        int intMsgVer = ByteConverter.bytesToInt(messageVersionNumber);
+        long lngTime = ByteConverter.bytesToLong(byteTime);
+        int intAck = ByteConverter.bytesToInt(byteAck);
+        int intRaceID = ByteConverter.bytesToInt(byteRaceID);
+        int intSourceID = ByteConverter.bytesToInt(byteSourceID);
+        int intBoatState = ByteConverter.bytesToInt(byteBoatStatus);
+        int intRoundingSide = ByteConverter.bytesToInt(byteRoundingSide);
+        int intMarkType = ByteConverter.bytesToInt(byteMarkType);
+        int intMarkID = ByteConverter.bytesToInt(byteMarkID);
+
+        markRounding = new MarkRounding(intMsgVer, lngTime, intAck, intRaceID, intSourceID, intBoatState, intRoundingSide, intMarkType, intMarkID);
+    }
+
+    public MarkRounding getMarkRounding() {
+        return markRounding;
+    }
+}
@@ -0,0 +1,65 @@
+package network.MessageDecoders;
+
+
+import java.util.Arrays;
+
+import static seng302.Networking.Utils.ByteConverter.*;
+
+/**
+ * Created by hba56 on 21/04/17.
+ */
+public class RaceStartStatusDecoder {
+    private byte messageVersion;
+    private byte[] timestamp;
+    private byte[] ackNumber;
+    private byte[] raceStartTime;
+    private byte[] raceIdentifier;
+    private byte notificationType;
+
+    private long time;
+    private short ack;
+    private long startTime;
+    private int raceID;
+    private char notification;
+
+
+    public RaceStartStatusDecoder(byte[] encodedRaceStartStatus) {
+        messageVersion = encodedRaceStartStatus[0];
+        timestamp = Arrays.copyOfRange(encodedRaceStartStatus, 1, 7);
+        ackNumber = Arrays.copyOfRange(encodedRaceStartStatus, 7, 9);
+        raceStartTime = Arrays.copyOfRange(encodedRaceStartStatus, 9, 15);
+        raceIdentifier = Arrays.copyOfRange(encodedRaceStartStatus, 15, 19);
+        notificationType = encodedRaceStartStatus[19];
+
+        time = bytesToLong(timestamp);
+        ack = bytesToShort(ackNumber);
+        startTime = bytesToLong(raceStartTime);
+        raceID = bytesToInt(raceIdentifier);
+        notification = bytesToChar(notificationType);
+    }
+
+
+    public byte getMessageVersion() {
+        return messageVersion;
+    }
+
+    public long getTime() {
+        return time;
+    }
+
+    public short getAck() {
+        return ack;
+    }
+
+    public long getStartTime() {
+        return startTime;
+    }
+
+    public int getRaceID() {
+        return raceID;
+    }
+
+    public char getNotification() {
+        return notification;
+    }
+}
@@ -0,0 +1,117 @@
+package network.MessageDecoders;
+
+import seng302.Networking.Messages.BoatStatus;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import static seng302.Networking.Utils.ByteConverter.*;
+
+/**
+ * Created by hba56 on 21/04/17.
+ */
+public class RaceStatusDecoder {
+    private byte versionNum;
+    private byte[] timeBytes;
+    private byte[] raceID;
+    private byte raceStatus;
+    private byte[] expectedStart;
+    private byte[] raceWind;
+    private byte[] windSpeed;
+    private byte numBoats;
+    private byte bytesRaceType;
+    private byte[] boatsBytes;
+
+    private long time;
+    private int race;
+    private int raceState;
+    private long startTime;
+    private int raceWindDir;
+    private short raceWindSpeed;
+    private int numberOfBoats;
+    private int raceType;
+    private ArrayList<BoatStatus> boats = new ArrayList<>();
+
+
+    public RaceStatusDecoder(byte[] encodedRaceStatus){
+        versionNum = encodedRaceStatus[0];
+        timeBytes = Arrays.copyOfRange(encodedRaceStatus, 1, 7);
+        raceID = Arrays.copyOfRange(encodedRaceStatus, 7, 11);
+        raceStatus = encodedRaceStatus[11];
+        expectedStart = Arrays.copyOfRange(encodedRaceStatus, 12, 18);
+        raceWind = Arrays.copyOfRange(encodedRaceStatus, 18, 20);
+        windSpeed = Arrays.copyOfRange(encodedRaceStatus, 20, 22);
+        numBoats = encodedRaceStatus[22];
+        bytesRaceType = encodedRaceStatus[23];
+        boatsBytes = Arrays.copyOfRange(encodedRaceStatus, 24, 25+20*this.numBoats);
+
+        time = bytesToLong(timeBytes);
+        race = bytesToInt(raceID);
+        raceState = bytesToInt(raceStatus);
+        startTime = bytesToLong(expectedStart);
+        raceWindDir = bytesToInt(raceWind);
+        raceWindSpeed = bytesToShort(windSpeed);
+        numberOfBoats = bytesToInt(numBoats);
+
+        int boatLoopIndex = 0;
+
+        for (int i=0; i < numberOfBoats; i++) {
+            byte[] boatBytes = Arrays.copyOfRange(boatsBytes, boatLoopIndex, boatLoopIndex+20);
+
+            byte[] sourceID = Arrays.copyOfRange(boatBytes, 0, 3);
+            byte boatStatus = boatBytes[4];
+            byte legNumber = boatBytes[5];
+            byte numPenaltiesAwarded = boatBytes[6];
+            byte numPenaltiesServed = boatBytes[7];
+            byte[] estTimeAtNextMark = Arrays.copyOfRange(boatBytes, 8, 14);
+            byte[] estTimeAtFinish = Arrays.copyOfRange(boatBytes, 14, 20);
+
+            BoatStatus boat = new BoatStatus(bytesToInt(sourceID),boatStatus,
+                    legNumber, numPenaltiesAwarded, numPenaltiesServed,
+                    bytesToLong(estTimeAtNextMark), bytesToLong(estTimeAtFinish));
+
+            boats.add(boat);
+            boatLoopIndex += 20;
+        }
+    }
+
+    public byte getVersionNum() {
+        return versionNum;
+    }
+
+    public long getTime() {
+        return time;
+    }
+
+    public int getRace() {
+        return race;
+    }
+
+    public int getRaceState() {
+        return raceState;
+    }
+
+    public long getStartTime() {
+        return startTime;
+    }
+
+    public int getRaceWindDir() {
+        return raceWindDir;
+    }
+
+    public short getRaceWindSpeed() {
+        return raceWindSpeed;
+    }
+
+    public int getNumberOfBoats() {
+        return numberOfBoats;
+    }
+
+    public int getRaceType() {
+        return raceType;
+    }
+
+    public ArrayList<BoatStatus> getBoats() {
+        return boats;
+    }
+}
@@ -0,0 +1,81 @@
+package network.MessageDecoders;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+import static seng302.Networking.Utils.ByteConverter.bytesToLong;
+import static seng302.Networking.Utils.ByteConverter.bytesToShort;
+
+/**
+ * Created by hba56 on 20/04/17.
+ */
+public class XMLMessageDecoder {
+    private byte messageVersionNumber;
+    private short ackNumber;
+    private long timeStamp;
+    private byte xmlMsgSubType;
+    private short sequenceNumber;
+    private short xmlMsgLength;
+    private String xmlMessage;
+
+    private byte[] bytes;
+
+    public XMLMessageDecoder(byte[] bytes) {
+        this.bytes = bytes;
+    }
+
+    public void decode(){
+        byte[] ackNumberBytes = Arrays.copyOfRange(bytes, 1, 3);
+        byte[] timeStampBytes = Arrays.copyOfRange(bytes, 3, 9);
+        byte[] sequenceNumberBytes = Arrays.copyOfRange(bytes, 10, 12);
+        byte[] xmlMsgLengthBytes = Arrays.copyOfRange(bytes, 12, 14);
+        byte[] xmlMessagebytes = Arrays.copyOfRange(bytes, 14, bytes.length);
+
+        this.xmlMsgSubType = bytes[9];
+        this.messageVersionNumber = bytes[0];
+        this.ackNumber = bytesToShort(ackNumberBytes);
+
+        this.timeStamp = bytesToLong(timeStampBytes);
+
+        this.sequenceNumber = bytesToShort(sequenceNumberBytes);
+        this.xmlMsgLength = bytesToShort(xmlMsgLengthBytes);
+        this.xmlMessage = new String(xmlMessagebytes);
+    }
+
+    public byte getMessageVersionNumber() {
+        return messageVersionNumber;
+    }
+
+    public short getAckNumber() {
+        return ackNumber;
+    }
+
+    public long getTimeStamp() {
+        return timeStamp;
+    }
+
+    public byte getXmlMsgSubType() {
+        return xmlMsgSubType;
+    }
+
+    public short getSequenceNumber() {
+        return sequenceNumber;
+    }
+
+    public short getXmlMsgLength() {
+        return xmlMsgLength;
+    }
+
+    /**
+     * this will be used latter for the vis
+     * @return xml string as inputsource
+     */
+    public InputStream getXmlMessageInputStream() {
+        InputStream is =  new ByteArrayInputStream(xmlMessage.trim().getBytes(StandardCharsets.UTF_8));
+//        InputSource is = new InputSource(new StringReader(xmlMessage.trim()));
+        return is;
+    }
+
+}