Merge branch 'story36_boundary_fix_attempt_2' into 'sprint4_master'

Fixes some issues with tacking/gybing.

Boats no longer go out of bounds, and only tack every 15 seconds.
Tested with all wind angles between [0,360] at 45 degree increments.
Also contains the visualiser wind scalar bug fix.

See merge request !12

mock/src/main/java/seng302/Constants.java

@@ -30,13 +30,13 @@ public class Constants {
     /**
      * The race pre-start time, in milliseconds. 3 minutes.
      */
-    public static final long RacePreStartTime = 1 * 60 * 1000;
+    public static final long RacePreStartTime = 3 * 60 * 1000;
 
 
     /**
      * The race preparatory time, in milliseconds. 1 minutes.
      */
-    public static final long RacePreparatoryTime = 3 * 60 * 1000;
+    public static final long RacePreparatoryTime = 1 * 60 * 1000;
 
 
     /**

mock/src/main/java/seng302/Model/Angle.java

@@ -54,9 +54,6 @@ public class Angle implements Comparable<Angle> {
         return this.degrees;
     }
 
-    public void setDegrees(double degrees) {
-        this.degrees = degrees;
-    }
 
     /**
      * Returns the value of this Angle object, in radians.

mock/src/main/java/seng302/Model/GPSCoordinate.java

@@ -1,10 +1,12 @@
 package seng302.Model;
 
+import javafx.util.Pair;
 import org.geotools.referencing.GeodeticCalculator;
 import org.opengis.geometry.DirectPosition;
 import seng302.Constants;
 
 import java.awt.geom.Point2D;
+import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 
@@ -292,5 +294,226 @@ public class GPSCoordinate {
 
     }
 
+
+    /**
+     * Takes a list of GPS coordinates describing a course boundary, and "shrinks" it inwards by 50m.
+     * @param boundary The boundary of course.
+     * @return A copy of the course boundary list, shrunk inwards by 50m.
+     */
+    public static List<GPSCoordinate> getShrinkBoundary(List<GPSCoordinate> boundary) {
+
+
+        double shrinkDistance = 50d;
+        List<GPSCoordinate> shrunkBoundary = new ArrayList<>(boundary.size());
+        //This is a list of edges that have been shrunk/shifted inwards.
+        List<Pair<GPSCoordinate, GPSCoordinate>> shrunkEdges = new ArrayList<>();
+
+
+        //We need to invert some of our opertations depending if the boundary is clockwise or anti-clockwise.
+        boolean isClockwise = GPSCoordinate.isClockwisePolygon(boundary);
+        double clockwiseScaleFactor = 0;
+
+        if (isClockwise) {
+            clockwiseScaleFactor = 1;
+        } else {
+            clockwiseScaleFactor = -1;
+        }
+
+
+        /**
+         * Starting at a vertex, face anti-clockwise along an adjacent edge.
+         Replace the edge with a new, parallel edge placed at distance d to the "left" of the old one.
+         Repeat for all edges.
+         Find the intersections of the new edges to get the new vertices.
+         Detect if you've become a crossed polynomial and decide what to do about it. Probably add a new vertex at the crossing-point and get rid of some old ones. I'm not sure whether there's a better way to detect this than just to compare every pair of non-adjacent edges to see if their intersection lies between both pairs of vertices.
+         */
+
+        //For the first (size-1) adjacent pairs.
+        for (int i = 0; i < (boundary.size() - 1); i++) {
+
+            //Get the points.
+            GPSCoordinate firstPoint = boundary.get(i);
+            GPSCoordinate secondPoint = boundary.get(i + 1);
+
+            //Get the bearing between two adjacent points.
+            Bearing bearing = GPSCoordinate.calculateBearing(firstPoint, secondPoint);
+
+            //Calculate angle perpendicular to bearing.
+            Bearing perpindicularBearing = Bearing.fromDegrees(bearing.degrees() + (90d * clockwiseScaleFactor));
+
+            //Translate both first and second point by 50m, using this bearing. These form our inwards shifted edge.
+            GPSCoordinate firstPointTranslated = GPSCoordinate.calculateNewPosition(firstPoint, shrinkDistance, Azimuth.fromBearing(perpindicularBearing));
+            GPSCoordinate secondPointTranslated = GPSCoordinate.calculateNewPosition(secondPoint, shrinkDistance, Azimuth.fromBearing(perpindicularBearing));
+
+            //Add edge to list.
+            shrunkEdges.add(new Pair<>(firstPointTranslated, secondPointTranslated));
+
+        }
+
+        //For the final adjacent pair, between the last and first point.
+        //Get the points.
+        GPSCoordinate firstPoint = boundary.get(boundary.size() - 1);
+        GPSCoordinate secondPoint = boundary.get(0);
+
+        //Get the bearing between two adjacent points.
+        Bearing bearing = GPSCoordinate.calculateBearing(firstPoint, secondPoint);
+
+        //Calculate angle perpendicular to bearing.
+        Bearing perpindicularBearing = Bearing.fromDegrees(bearing.degrees() + (90d * clockwiseScaleFactor));
+
+        //Translate both first and second point by 50m, using this bearing. These form our inwards shifted edge.
+        GPSCoordinate firstPointTranslated = GPSCoordinate.calculateNewPosition(firstPoint, shrinkDistance, Azimuth.fromBearing(perpindicularBearing));
+        GPSCoordinate secondPointTranslated = GPSCoordinate.calculateNewPosition(secondPoint, shrinkDistance, Azimuth.fromBearing(perpindicularBearing));
+
+        //Add edge to list.
+        shrunkEdges.add(new Pair<>(firstPointTranslated, secondPointTranslated));
+
+
+        //We now have a list of edges that have been shifted inwards.
+        //We need to find the intersections between adjacent vertices in our edge list. E.g., intersection between edge1-right, and edge2-left.
+
+        //For the first (size-1) adjacent pairs.
+        for (int i = 0; i < (shrunkEdges.size() - 1); i++) {
+
+            //Get the pair of adjacent edges.
+            Pair<GPSCoordinate, GPSCoordinate> edge1 = shrunkEdges.get(i);
+            Pair<GPSCoordinate, GPSCoordinate> edge2 = shrunkEdges.get(i + 1);
+
+            //Get the x and y coordinates of first edge.
+            double x1 = edge1.getKey().getLongitude();
+            double x2 = edge1.getValue().getLongitude();
+            double y1 = edge1.getKey().getLatitude();
+            double y2 = edge1.getValue().getLatitude();
+
+            //Get the x and y coordinates of second edge.
+            double x3 = edge2.getKey().getLongitude();
+            double x4 = edge2.getValue().getLongitude();
+            double y3 = edge2.getKey().getLatitude();
+            double y4 = edge2.getValue().getLatitude();
+
+            //Find the equations for both edges.
+            // y = a*x + b
+            //First equation.
+            double a1 = (y2 - y1) / (x2 - x1);
+            double b1 = y1 - a1 * x1;
+
+            //Second equation.
+            double a2 = (y4 - y3) / (x4 - x3);
+            double b2 = y3 - a2 * x3;
+
+
+            //Find intersecting x coordinate.
+            // a1 * x + b1 = a2 * x + b2
+            double x0 = -(b1 - b2) / (a1 - a2);
+            //Find intersecting y coordinate.
+            double y0 = x0 * a1 + b1;
+
+            //Add this to shrunk boundary list.
+            GPSCoordinate coordinate = new GPSCoordinate(y0, x0);
+            shrunkBoundary.add(coordinate);
+
+        }
+
+
+        //For the final adjacent pair, between the last and first point.
+        //Get the pair of adjacent edges.
+        Pair<GPSCoordinate, GPSCoordinate> edge1 = shrunkEdges.get(shrunkEdges.size() - 1);
+        Pair<GPSCoordinate, GPSCoordinate> edge2 = shrunkEdges.get(0);
+
+        //Get the x and y coordinates of first edge.
+        double x1 = edge1.getKey().getLongitude();
+        double x2 = edge1.getValue().getLongitude();
+        double y1 = edge1.getKey().getLatitude();
+        double y2 = edge1.getValue().getLatitude();
+
+        //Get the x and y coordinates of second edge.
+        double x3 = edge2.getKey().getLongitude();
+        double x4 = edge2.getValue().getLongitude();
+        double y3 = edge2.getKey().getLatitude();
+        double y4 = edge2.getValue().getLatitude();
+
+        //Find the equations for both edges.
+        // y = a*x + b
+        //First equation.
+        double a1 = (y2 - y1) / (x2 - x1);
+        double b1 = y1 - a1 * x1;
+
+        //Second equation.
+        double a2 = (y4 - y3) / (x4 - x3);
+        double b2 = y3 - a2 * x3;
+
+
+        //Find intersecting x coordinate.
+        // a1 * x + b1 = a2 * x + b2
+        double x0 = -(b1 - b2) / (a1 - a2);
+        //Find intersecting y coordinate.
+        double y0 = x0 * a1 + b1;
+
+        //Add this to shrunk boundary list.
+        GPSCoordinate coordinate = new GPSCoordinate(y0, x0);
+        shrunkBoundary.add(coordinate);
+
+
+
+        return shrunkBoundary;
+
+    }
+
+
+    /**
+     * Determines if a list of coordinates describes a boundary polygon in clockwise or anti-clockwise order.
+     * @param boundary The list of coodinates.
+     * @return True if clockwise, false if anti-clockwise.
+     */
+    public static boolean isClockwisePolygon(List<GPSCoordinate> boundary) {
+
+        /** From https://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-points-are-in-clockwise-order
+         * sum all pairs (x2 − x1)(y2 + y1)
+         point[0] = (5,0)   edge[0]: (6-5)(4+0) =   4
+         point[1] = (6,4)   edge[1]: (4-6)(5+4) = -18
+         point[2] = (4,5)   edge[2]: (1-4)(5+5) = -30
+         point[3] = (1,5)   edge[3]: (1-1)(0+5) =   0
+         point[4] = (1,0)   edge[4]: (5-1)(0+0) =   0
+         ---
+         -44  counter-clockwise
+         */
+
+        double sum = 0;
+
+        //For the first (size-1) adjacent pairs.
+        for (int i = 0; i < (boundary.size() - 1); i++) {
+
+            //Get the points.
+            GPSCoordinate firstPoint = boundary.get(i);
+            GPSCoordinate secondPoint = boundary.get(i + 1);
+
+            double xDelta = secondPoint.getLongitude() - firstPoint.getLongitude();
+            double ySum = secondPoint.getLatitude() + firstPoint.getLatitude();
+
+            double product = xDelta * ySum;
+
+            sum += product;
+
+        }
+
+        //For the final adjacent pair, between the last and first point.
+        //Get the points.
+        GPSCoordinate firstPoint = boundary.get(boundary.size() - 1);
+        GPSCoordinate secondPoint = boundary.get(0);
+
+        double xDelta = secondPoint.getLongitude() - firstPoint.getLongitude();
+        double ySum = secondPoint.getLatitude() + firstPoint.getLatitude();
+
+        double product = xDelta * ySum;
+
+        sum += product;
+
+
+        //sum > 0 is clockwise, sum < 0 is anticlockwise.
+        return sum > 0;
+
+
+    }
+
 }
 

mock/src/main/java/seng302/Model/Polars.java

@@ -118,10 +118,7 @@ public class Polars {
 
 
         //If the lower bound is greater than the upper bound, we have a "flipped" interval. That is for, e.g., [70, 55] the lower bound is greater than the upper bound, and so it checks that (VMGAngle >= 70 OR VMGAngle =< 55), instead of (VMGAngle >= 70 AND VMGAngle =< 55).
-        boolean flippedInterval = false;
+        boolean flippedInterval = Polars.isFlippedInterval(bearingLowerBound, bearingUpperBound);
-        if (bearingLowerBound.degrees() > bearingUpperBound.degrees()) {
-            flippedInterval = true;
-        }
 
 
 
@@ -179,7 +176,7 @@ public class Polars {
             Bearing bestVMGAngle = Bearing.fromDegrees(0d);
 
             //Calculate the VMG for all possible angles at this wind speed.
-            for (double angleDegree = 0; angleDegree < 360; angleDegree += 0.1) {
+            for (double angleDegree = 0; angleDegree < 360; angleDegree += 1) {
                 Bearing angle = Bearing.fromDegrees(angleDegree);
 
                 //This is the true bearing of the boat, if it went at the angle against the wind.
@@ -191,22 +188,11 @@ public class Polars {
 
                 //Check that the boat's bearing would actually be acceptable.
                 //We continue (skip to next iteration) if it is outside of the interval.
-                if (flippedInterval) {
+                if (!Polars.isBearingInsideInterval(trueBoatBearing, bearingLowerBound, bearingUpperBound)) {
-                    //Bearing must be inside [lower, upper], where lower > upper. So, bearing must be >= lower, or bearing < upper. We use inverted logic since we are skipping if it is true.
+                    continue;
-                    if ((trueBoatBearing.degrees() < bearingLowerBound.degrees()) & (trueBoatBearing.degrees() > bearingUpperBound.degrees())) {
-                        continue;
-                    }
-
-                } else {
-                    //Bearing must be inside [lower, upper].
-                    if ((trueBoatBearing.degrees() < bearingLowerBound.degrees()) || (trueBoatBearing.degrees() > bearingUpperBound.degrees())) {
-                        continue;
-                    }
-
                 }
 
 
-
                 //Basic linear interpolation. Find the nearest two angles from the table, and interpolate between them.
 
                 //Check which pair of adjacent angles the angle is between.
@@ -313,6 +299,58 @@ public class Polars {
     }
 
 
+    /**
+     * Determines whether an interval is "flipped". This means that the lower bound is greater than the upper bound (e.g., [290, 43] degrees).
+     * @param lowerBound The lower bound.
+     * @param upperBound The upper bound.
+     * @return True if the interval is flipped, false otherwise.
+     */
+    public static boolean isFlippedInterval(Bearing lowerBound, Bearing upperBound) {
+
+        //If the lower bound is greater than the upper bound, we have a "flipped" interval.
+        boolean flippedInterval = false;
+        if (lowerBound.degrees() > upperBound.degrees()) {
+            flippedInterval = true;
+        }
+
+        return flippedInterval;
+    }
+
+
+    /**
+     * Determines if a bearing is inside an interval.
+     * @param bearing The bearing to check.
+     * @param lowerBound The lower bound of the interval.
+     * @param upperBound The upper bound of the interval.
+     * @return True if the bearing is inside the interval, false otherwise.
+     */
+    public static boolean isBearingInsideInterval(Bearing bearing, Bearing lowerBound, Bearing upperBound) {
+
+        //Check if it's a flipped interval.
+        boolean flippedInterval = Polars.isFlippedInterval(lowerBound, upperBound);
+
+        if (flippedInterval) {
+            //Bearing must be inside [lower, upper], where lower > upper. So, bearing must be >= lower, or bearing < upper. We use inverted logic since we are skipping if it is true.
+            if ((bearing.degrees() >= lowerBound.degrees()) || (bearing.degrees() <= upperBound.degrees())) {
+                return true;
+            } else {
+                return false;
+            }
+
+        } else {
+            //Bearing must be inside [lower, upper].
+            if ((bearing.degrees() >= lowerBound.degrees()) && (bearing.degrees() <= upperBound.degrees())) {
+                return true;
+            } else {
+                return false;
+            }
+
+        }
+
+
+    }
+
+
     /**
      * Calculate the linear interpolation scalar for a value between two bounds. E.g., lower = 7, upper = 10, value = 8, therefore the scalar (or the proportion between the bounds) is 0.333.
      * Also assumes that the bounds are periodic - e.g., for angles a lower bound of 350deg and upper bound of 5deg is in interval of 15 degrees.

mock/src/main/java/seng302/Model/Race.java

@@ -48,6 +48,11 @@ public class Race implements Runnable {
      */
     private List<GPSCoordinate> boundary;
 
+    /**
+     * A copy of the boundary list, except "shrunk" inwards by 50m.
+     */
+    private List<GPSCoordinate> shrinkBoundary;
+
     /**
      * The elapsed time, in milliseconds, of the race.
      */
@@ -63,7 +68,7 @@ public class Race implements Runnable {
      * Frame periods are multiplied by this to get the amount of time a single frame represents.
      * E.g., frame period = 20ms, scale = 5, frame represents 20 * 5 = 100ms, and so boats are simulated for 100ms, even though only 20ms actually occurred.
      */
-    private int scaleFactor = 5;
+    private int scaleFactor = 15;
 
     /**
      * The race ID of the course.
@@ -121,13 +126,16 @@ public class Race implements Runnable {
         this.boats = FXCollections.observableArrayList(raceData.getBoats());
         this.compoundMarks = FXCollections.observableArrayList(raceData.getCompoundMarks());
         this.boundary = raceData.getBoundary();
+        this.shrinkBoundary = GPSCoordinate.getShrinkBoundary(this.boundary);
+
+
         this.legs = raceData.getLegs();
         this.legs.add(new Leg("Finish", this.legs.size()));
 
         this.raceId = raceData.getRaceId();
 
         //The start time is current time + 4 minutes, scaled. prestart is 3 minutes, and we add another.
-        this.startTime = System.currentTimeMillis() + ((Constants.RacePreStartTime + (1 * 1000)) / this.scaleFactor);
+        this.startTime = System.currentTimeMillis() + ((Constants.RacePreStartTime + (1 * 60 * 1000)) / this.scaleFactor);
 
         this.setRaceStatusEnum(RaceStatusEnum.NOT_ACTIVE);
         this.raceType = RaceTypeEnum.FLEET_RACE;
@@ -374,7 +382,6 @@ public class Race implements Runnable {
 
             } else {
                 //Otherwise, the race is over!
-                System.out.println("test");
                 raceFinished.start();
                 setRaceStatusEnum(RaceStatusEnum.FINISHED);
                 this.stop();
@@ -516,41 +523,48 @@ public class Race implements Runnable {
      */
     private VMG calculateVMG(Boat boat, Bearing[] bearingBounds) {
 
-        //How fast a boat can turn, in degrees per millisecond.
-        double turnRate = 0.03;
-
-        //How much the boat is allowed to turn, considering how long since it last turned.
-        double turnAngle = turnRate * boat.getTimeSinceTackChange();
-        //This ensures that the boat bounds don't flip around.
-        turnAngle = Math.min(turnAngle, 179.999);
-
-        //Find the bounds on what angle the boat is allowed to travel at. The bounds cap out at [0, 360).
-        double bound1Degrees = boat.getBearing().degrees() - turnAngle;
-        double bound2Degrees = boat.getBearing().degrees() + turnAngle;
-
-        Bearing bound1 = Bearing.fromDegrees(bound1Degrees);
-        Bearing bound2 = Bearing.fromDegrees(bound2Degrees);
-
-
         //Get the lower and upper acceptable bounds.
         Bearing lowerAcceptableBound = bearingBounds[0];
         Bearing upperAcceptableBound = bearingBounds[1];
 
 
-        //Find the bounds on what angle the boat can travel on, taking into account both turning rate and the acceptable bounds.
+        //Find the VMG inside these bounds.
-        bound1Degrees = Math.max(bound1.degrees(), lowerAcceptableBound.degrees());
+        VMG bestVMG = boat.getPolars().calculateVMG(this.windDirection, this.windSpeed, boat.calculateBearingToNextMarker(), lowerAcceptableBound, upperAcceptableBound);
-        bound2Degrees = Math.min(bound2.degrees(), upperAcceptableBound.degrees());
-
-        bound1 = Bearing.fromDegrees(bound1Degrees);
-        bound2 = Bearing.fromDegrees(bound2Degrees);
 
 
-        //Calculate VMG using these bounds.
+
-        return boat.getPolars().calculateVMG(this.windDirection, this.windSpeed, boat.calculateBearingToNextMarker(), bound1, bound2);
+        return bestVMG;
 
     }
 
 
+    /**
+     * Determines whether or not a given VMG improves the velocity of a boat, if it were currently using currentVMG.
+     * @param currentVMG The current VMG of the boat.
+     * @param potentialVMG The new VMG to test.
+     * @param bearingToDestination The bearing between the boat and its destination.
+     * @return True if the new VMG is improves velocity, false otherwise.
+     */
+    private boolean improvesVelocity(VMG currentVMG, VMG potentialVMG, Bearing bearingToDestination) {
+
+        //Calculates the angle between the boat and its destination.
+        Angle angleBetweenDestAndHeading = Angle.fromDegrees(currentVMG.getBearing().degrees() - bearingToDestination.degrees());
+
+        //Calculates the angle between the new VMG and the boat's destination.
+        Angle angleBetweenDestAndNewVMG = Angle.fromDegrees(potentialVMG.getBearing().degrees() - bearingToDestination.degrees());
+
+
+        //Calculate the boat's current velocity.
+        double currentVelocity = Math.cos(angleBetweenDestAndHeading.radians()) * currentVMG.getSpeed();
+
+        //Calculate the potential velocity with the new VMG.
+        double vmgVelocity =  Math.cos(angleBetweenDestAndNewVMG.radians()) * potentialVMG.getSpeed();
+
+        //Return whether or not the new VMG gives better velocity.
+        return vmgVelocity > currentVelocity;
+
+    }
+
     /**
      * Determines whether or not a given VMG improves the velocity of a boat.
      * @param boat The boat to test.
@@ -559,21 +573,11 @@ public class Race implements Runnable {
      */
     private boolean improvesVelocity(Boat boat, VMG vmg) {
 
-        //Calculates the angle between the boat and its destination.
+        //Get the boats "current" VMG.
-        Angle angleBetweenDestAndHeading = Angle.fromDegrees(boat.getBearing().degrees() - boat.calculateBearingToNextMarker().degrees());
+        VMG boatVMG = new VMG(boat.getCurrentSpeed(), boat.getBearing());
 
-        //Calculates the angle between the new VMG and the boat's destination.
+        //Check if the new VMG is better than the boat's current VMG.
-        Angle angleBetweenDestAndNewVMG = Angle.fromDegrees(vmg.getBearing().degrees() - boat.calculateBearingToNextMarker().degrees());
+        return this.improvesVelocity(boatVMG, vmg, boat.calculateBearingToNextMarker());
-
-
-        //Calculate the boat's current velocity.
-        double currentVelocity = Math.cos(angleBetweenDestAndHeading.radians()) * boat.getCurrentSpeed();
-
-        //Calculate the potential velocity with the new VMG.
-        double vmgVelocity =  Math.cos(angleBetweenDestAndNewVMG.radians()) * vmg.getSpeed();
-
-        //Return whether or not the new VMG gives better velocity.
-        return vmgVelocity > currentVelocity;
 
     }
 
@@ -604,31 +608,34 @@ public class Race implements Runnable {
             boat.moveForwards(distanceTravelledMeters, updatePeriodMilliseconds * this.scaleFactor);
 
 
-            //Calculate the boat's bearing bounds, to ensure that it doesn't go out of the course.
+            //Only get a new VMG if the boat will go outside the course, or X seconds have elapsed.
-            Bearing[] bearingBounds = this.calculateBearingBounds(boat);
+            boolean willStayInsideCourse = this.checkBearingInsideCourse(boat.getBearing(), boat.getCurrentPosition());
+            long tackPeriod = 15000;
+            if (!willStayInsideCourse || (boat.getTimeSinceTackChange() > tackPeriod)) {
 
-            //Calculate the new VMG.
+                //Calculate the boat's bearing bounds, to ensure that it doesn't go out of the course.
-            VMG newVMG = this.calculateVMG(boat, bearingBounds);
+                Bearing[] bearingBounds = this.calculateBearingBounds(boat);
 
 
+                //Calculate the new VMG.
+                VMG newVMG = this.calculateVMG(boat, bearingBounds);
 
 
-            Azimuth azimuth = Azimuth.fromBearing(boat.getBearing());
+                //If the new vmg improves velocity, use it.
-            GPSCoordinate testBounds = GPSCoordinate.calculateNewPosition(boat.getCurrentPosition(),
+                if (improvesVelocity(boat, newVMG)) {
-                    (100.0 / Constants.NMToMetersConversion), azimuth);
+                    boat.setVMG(newVMG);
-            //If the new vmg improves velocity, use it.
+
-            if (improvesVelocity(boat, newVMG)) {
+                } else {
-                boat.setVMG(newVMG);
+                    //We also need to use the new VMG if our current bearing will take us out of the course.
-            }else if (!GPSCoordinate.isInsideBoundary(testBounds, boundary)){
+                    if (!willStayInsideCourse) {
-                //checks to see if the new vmg sends the boat out of bounds and if so mirrors its direction in the wind
+                        boat.setVMG(newVMG);
-                double currDegrees = newVMG.getBearing().degrees();
+                    }
-                double windDirectionDegrees = this.windDirection.degrees();
+                }
-                double tempHeading = (currDegrees - windDirectionDegrees +90)%360;
-                newVMG.getBearing().setDegrees(tempHeading);
-                boat.setVMG(newVMG);
             }
-
+            
             this.updateEstimatedTime(boat);
+            
+
             //Check the boats position (update leg and stuff).
             this.checkPosition(boat, totalTimeElapsed);
 
@@ -645,12 +652,13 @@ public class Race implements Runnable {
 
         Bearing[] bearings = new Bearing[2];
 
-        Bearing lowerBearing = Bearing.fromDegrees(0);
+        Bearing lowerBearing = Bearing.fromDegrees(0.001);
         Bearing upperBearing = Bearing.fromDegrees(359.999);
 
 
-        boolean foundAnyBadBearing = false;
+
-        boolean foundLowerBearing = false;
+        double lastAngle = -1;
+        boolean lastAngleWasGood = false;
 
         //Check all bearings between [0, 360).
         for (double angle = 0; angle < 360; angle += 1) {
@@ -661,29 +669,29 @@ public class Race implements Runnable {
             //Check that if it is acceptable.
             boolean bearingIsGood = this.checkBearingInsideCourse(bearing, boat.getCurrentPosition());
 
-            if (bearingIsGood) {
 
-                //The lower bearing will be the first acceptable bearing after finding any unacceptable bearing.
+            if (lastAngle != -1) {
-                if (foundAnyBadBearing && !foundLowerBearing) {
+
-                    lowerBearing = bearing;
+                if (lastAngleWasGood && !bearingIsGood) {
-                    foundLowerBearing = true;
+                    //We have flipped over from good bearings to bad bearings. So the last good bearing is the upper bearing.
+                    upperBearing = Bearing.fromDegrees(lastAngle);
                 }
 
-                //The upper bearing will be the last acceptable bearing before finding any unacceptable bearing.
+                if (!lastAngleWasGood && bearingIsGood) {
-                if (!foundAnyBadBearing) {
+                    //We have flipped over from bad bearings to good bearings. So the current bearing is the lower bearing.
-                    upperBearing = bearing;
+                    lowerBearing = Bearing.fromDegrees(angle);
                 }
 
-
-            } else {
-
-                foundAnyBadBearing = true;
-
             }
 
+            lastAngle = angle;
+            lastAngleWasGood = bearingIsGood;
+
         }
 
 
+
+        //TODO BUG if it can't find either upper or lower, it returns (0, 359.999). Should return (boatbearing, boatbearing+0.0001)
         bearings[0] = lowerBearing;
         bearings[1] = upperBearing;
 
@@ -696,6 +704,7 @@ public class Race implements Runnable {
      * Checks if a given bearing, starting at a given position, would put a boat out of the course boundaries.
      * @param bearing The bearing to check.
      * @param position The position to start from.
+     * @return True if the bearing would keep the boat in the course, false if it would take it out of the course.
      */
     private boolean checkBearingInsideCourse(Bearing bearing, GPSCoordinate position) {
 
@@ -704,11 +713,11 @@ public class Race implements Runnable {
 
 
         //Tests to see if a point in front of the boat is out of bounds.
-        double epsilonMeters = 100d;
+        double epsilonMeters = 50d;
         GPSCoordinate testCoord = GPSCoordinate.calculateNewPosition(position, epsilonMeters, azimuth);
 
         //If it isn't inside the boundary, calculate new bearing.
-        if (GPSCoordinate.isInsideBoundary(testCoord, this.boundary)) {
+        if (GPSCoordinate.isInsideBoundary(testCoord, this.shrinkBoundary)) {
             return true;
         } else {
             return false;
@@ -885,6 +894,7 @@ public class Race implements Runnable {
         if (windDir < 0){
             windDir += 65535;
         }
+
         this.windDirection = new Bearing(BoatLocation.convertHeadingIntToDouble(windDir));
     }
 
@@ -916,4 +926,4 @@ public class Race implements Runnable {
             boat.setEstimatedTime(startTime + totalTimeElapsed + timeFromNow);
         }
     }
-}
+}

network/src/main/java/seng302/Networking/Messages/BoatLocation.java

@@ -227,7 +227,7 @@ public class BoatLocation extends AC35Data {
      */
     public static int convertHeadingDoubleToInt(double heading) {
 
-        int headingInt = (int) ((heading / 360.0) * 65536.0);
+        int headingInt = (int) ((heading * 65536.0) / 360.0);
 
         return headingInt;
     }

network/src/main/java/seng302/Networking/Messages/RaceStatus.java

@@ -18,7 +18,7 @@ public class RaceStatus  extends AC35Data {
     private int windSpeed;
     private int raceType;
     private List<BoatStatus> boatStatuses;
-    private static final double windDirectionScalar =  360.0 / 32768.0; // 0x8000 / 360
+    private static final double windDirectionScalar =  360.0 / 65536.0; // 0x10000 / 360
 
     public RaceStatus(long currentTime, int raceID, int raceStatus, long expectedStartTime, int windDirection, int windSpeed, int raceType, List<BoatStatus> boatStatuses){
         super(MessageType.RACESTATUS);