Merge branch 'issue#1_wakes_3.0' into 'develop'

Issue#1 wakes 3.0

Changed methods in the wake class to fix issues caused by unexpected velocities making the wakes go crazy.
Improved performance.
Made wakes look different.

See merge request !33

src/main/java/seng302/models/BoatGroup.java

@@ -1,6 +1,7 @@
 package seng302.models;
 
 import javafx.geometry.Point2D;
+import javafx.scene.CacheHint;
 import javafx.scene.Group;
 import javafx.scene.paint.Color;
 import javafx.scene.shape.Line;
@@ -99,8 +100,13 @@ public class BoatGroup extends RaceObject {
         boatPoly.setOnMouseEntered(event -> boatPoly.setFill(Color.FLORALWHITE));
         boatPoly.setOnMouseExited(event -> boatPoly.setFill(color));
         boatPoly.setOnMouseClicked(event -> setIsSelected(!isSelected));
+        boatPoly.setCache(true);
+        boatPoly.setCacheHint(CacheHint.SPEED);
+
 
         teamNameObject = new Text(boat.getShortName());
+        teamNameObject.setCache(true);
+        teamNameObject.setCacheHint(CacheHint.SPEED);
         velocityObject = new Text(String.valueOf(boat.getVelocity()));
         DateFormat format = new SimpleDateFormat("mm:ss");
         String timeToNextMark = format
@@ -113,6 +119,8 @@ public class BoatGroup extends RaceObject {
         } else {
             legTimeObject = new Text("Last mark: -");
         }
+        velocityObject.setCache(true);
+        velocityObject.setCacheHint(CacheHint.SPEED);
 
         teamNameObject.setX(TEAMNAME_X_OFFSET);
         teamNameObject.setY(TEAMNAME_Y_OFFSET);
@@ -214,8 +222,6 @@ public class BoatGroup extends RaceObject {
      *                     on.
      */
     public void updatePosition(long timeInterval) {
-        //Calculate the movement of the boat.
-        if (isMaximized) {
         double dx = pixelVelocityX * timeInterval;
         double dy = pixelVelocityY * timeInterval;
         double rotation = rotationalVelocity * timeInterval;
@@ -241,7 +247,6 @@ public class BoatGroup extends RaceObject {
         }
         wake.updatePosition(timeInterval);
     }
-    }
 
     /**
      * Sets the destination of the boat and the headng it should have once it reaches
@@ -257,32 +262,21 @@ public class BoatGroup extends RaceObject {
             if (setToInitialLocation) {
                 destinationSet = true;
                 boat.setVelocity(groundSpeed);
-                if (currentRotation < 0) {
-                    currentRotation = 360 - currentRotation;
-                }
                 double dx = newXValue - boatPoly.getLayoutX();
                 double dy = newYValue - boatPoly.getLayoutY();
-                //Check movement is reasonable. Assumes a 1000 * 1000 canvas
+
-                if (Math.abs(dx) > 50 || Math.abs(dy) > 50) {
-                    dx = 0;
-                    dy = 0;
-                    moveTo(newXValue, newYValue);
-                }
 
                 pixelVelocityX = dx / expectedUpdateInterval;
                 pixelVelocityY = dy / expectedUpdateInterval;
                 rotationalGoal = rotation;
                 calculateRotationalVelocity();
 
-                if (wakeGenerationDelay > 0) {
+                if (Math.abs(rotationalVelocity) > 0.075) {
-                    wake.rotate(rotationalGoal);
-                    rotateTo(rotationalGoal); //Need to test with this removed.
                     rotationalVelocity = 0;
-                    wakeGenerationDelay--;
+                    rotateTo(rotationalGoal);
-                } else {
+                    wake.rotate(rotationalGoal);
-                    wake.setRotationalVelocity(rotationalVelocity, rotationalGoal,
-                            boat.getVelocity());
                 }
+                wake.setRotationalVelocity(rotationalVelocity, boat.getVelocity());
                 velocityObject.setText(String.format("%.2f m/s", boat.getVelocity()));
                 DateFormat format = new SimpleDateFormat("mm:ss");
                 // estimate time to next mark
@@ -304,27 +298,6 @@ public class BoatGroup extends RaceObject {
             }
         }
         //If minimized generate lines every 5 calls to set destination.
-        if (!isMaximized) {
-            setToInitialLocation = false;
-            wakeGenerationDelay = 2;
-            if (setCallCount-- == 0) {
-                setCallCount = 5;
-                if (lastPoint != null) {
-                    Line l = new Line(
-                            lastPoint.getX(),
-                            lastPoint.getY(),
-                            newXValue,
-                            newYValue
-                    );
-                    l.getStrokeDashArray().setAll(3d, 7d);
-                    l.setStroke(boatPoly.getFill());
-                    lineStorage.add(l);
-                }
-                if (destinationSet) { //Only begin drawing after the first destination is set
-                    lastPoint = new Point2D(newXValue, newYValue);
-                }
-            }
-        }
     }
 
     public void setDestination(double newXValue, double newYValue, double groundSpeed,

src/main/java/seng302/models/Wake.java

@@ -1,30 +1,34 @@
 package seng302.models;
 
+import javafx.scene.CacheHint;
 import javafx.scene.Group;
 import javafx.scene.paint.Color;
 import javafx.scene.shape.Arc;
 import javafx.scene.shape.ArcType;
+import javafx.scene.shape.StrokeLineCap;
 import javafx.scene.transform.Rotate;
 
 /**
- * By default wake is a group containing 5 arcs. Each arc starts from the same point. Each arc is larger and more
+ * A group containing objects used to represent wakes onscreen. Contains functionality for their animation.
- * transparent than the last. On calling updatePositions() arcs rotate at velocities given by setRotationalVelocity().
- * The larger and more transparent an arc is the longer the delay before it rotates at the latest velocity. It is
- * assumed that rotationalVelocities() are set regularly as wakes do not stop rotating and an array of velocities needs
- * to be populated for the class to work as expected.
  */
 class Wake extends Group {
 
-    private int numWakes = 5;
+    //The number of wakes
-    private double[] velocities = new double[13];
+    private int numWakes = 8;
+    //The total possible difference between the first wake and the last. Increasing/Decreasing this will make wakes fan out more/less.
+    private final double MAX_DIFF = 75;
+    //Increasing/decreasing this will alter the speed that wakes converge when the heading stop changing. Anything over about 1500 may cause oscillation.
+    private final int UNIFICATION_SPEED = 750;
+
+
     private Arc[] arcs = new Arc[numWakes];
+    private double[] rotationalVelocities = new double[numWakes];
     private double[] rotations = new double[numWakes];
-    private int[] velocityIndices = new int[numWakes];
+    private double baseRad;
-    private double sum = 0;
-    private static double max;
 
     /**
      * Create a wake at the given location.
+     *
      * @param startingX x location where the tip of wake arcs will be.
      * @param startingY y location where the tip of wake arcs will be.
      */
@@ -35,73 +39,76 @@ class Wake extends Group {
         for (int i = 0; i < numWakes; i++) {
             //Default triangle is -110 deg out of phase with a default wake and has angle of 40 deg.
             arc = new Arc(0, 0, 0, 0, -110, 40);
-            //Opacity increases from 0.5 -> 0 evenly over the 5 wake arcs.
+            arc.setCache(true);
-            arc.setFill(new Color(0.18, 0.7, 1.0, 1.0 + -0.175 * i));
+            arc.setCacheHint(CacheHint.SPEED);
-            arc.setType(ArcType.ROUND);
+            arc.setType(ArcType.OPEN);
+            arc.setStroke(new Color(0.18, 0.7, 1.0, 1.0 + (-0.99 / numWakes * i)));
+            arc.setStrokeWidth(3.0);
+            arc.setStrokeLineCap(StrokeLineCap.ROUND);
+            arc.setFill(new Color(0.0, 0.0, 0.0, 0.0));
+            baseRad = (20 / numWakes);
             arcs[i] = arc;
         }
         super.getChildren().addAll(arcs);
     }
 
     /**
-     * Sets the rotationalVelocity of each arc. Each arc is 3 velocities behind the next smallest arc. The smallest uses
+     * Sets the rotationalVelocity of each arc.
-     * the latest given velocity.
+     *
      * @param rotationalVelocity The rotationalVelocity the wake should move at.
-     * @param rotationGoal Where the wake will rotate to if the wake is calculated to be on a straight section. This is
-     *                     used to prevent desynchronisation with the Boat polygon.
      * @param velocity           The real world velocity of the boat in m/s.
      */
-    void setRotationalVelocity (double rotationalVelocity, double rotationGoal, double velocity) {
+    void setRotationalVelocity(double rotationalVelocity, double velocity) {
-        sum -= Math.abs(velocities[(velocityIndices[0] + 10) % 13]);
+        rotationalVelocities[0] = rotationalVelocity;
-        sum += Math.abs(rotationalVelocity);
+        for (int i = 1; i < numWakes; i++) {
-        max = Math.max(max, rotationalVelocity);
+            double wakeSeparationRad = Math.toRadians(rotations[i - 1] - rotations[i]);
-        if (sum < (max / 3))
+            double shortestDistance = Math.atan2(
-            rotate (rotationGoal); //In relatively straight segments the wake snaps to match the boats current position.
+                    Math.sin(wakeSeparationRad),
-                                   //This stops the wake from eventually becoming out of sync with the boat.
+                    Math.cos(wakeSeparationRad)
-        //This accounts for rogue rotations that are greater than what would be realistic. Value is kinda rough.
+            );
-        //Basically just for our internal mock.
+            double distDeg = Math.toDegrees(shortestDistance);
-        if (Math.abs(rotationalVelocity) > 0.05) {
-            rotationalVelocity = 0;
-            rotate(rotationGoal);
-        }
-        //Update the index of the array of recent velocities that each wake uses. Each wake is 3 velocities behind the
-        //next smallest wake.
-        velocityIndices[0] = (13 + (velocityIndices[0] - 1) % 13) % 13;
-        velocities[velocityIndices[0]] = rotationalVelocity;
-        for (int i = 1; i < numWakes; i++)
-            velocityIndices[i] = (velocityIndices[0] + 3 * i) % 13;
 
-        //Scale wakes based on velocity.
+            if (rotationalVelocities[i - 1] < 0.01 && rotationalVelocities[i - 1] > -0.01) {
-        double baseRad = 20;
+                rotationalVelocities[i] = distDeg / UNIFICATION_SPEED * Math.log(Math.abs(distDeg) + 1) / Math.log(MAX_DIFF / numWakes);
-        double rad;
+
+            } else {
+                if (distDeg < (MAX_DIFF / numWakes))
+                    rotationalVelocities[i] = rotationalVelocities[i - 1] * Math.log(Math.abs(distDeg) + 1) / Math.log(MAX_DIFF / numWakes);
+                else
+                    rotationalVelocities[i] = rotationalVelocities[i - 1];
+            }
+        }
+
+        double rad = baseRad + velocity;
         for (Arc arc : arcs) {
-            rad = baseRad + velocity;
             arc.setRadiusX(rad);
             arc.setRadiusY(rad);
-            baseRad += 5 + (velocity / 2);
+            rad += (20 / numWakes) + (velocity / 2);
         }
     }
 
     /**
      * Arcs rotate based on the distance they would have travelled over the supplied time interval.
+     *
      * @param timeInterval the time interval, in microseconds, that the wake should move.
      */
     void updatePosition(long timeInterval) {
         for (int i = 0; i < numWakes; i++) {
-            rotations[i] = rotations[i] + velocities[velocityIndices[i]] * timeInterval;
+            rotations[i] = rotations[i] + rotationalVelocities[i] * timeInterval;
             arcs[i].getTransforms().setAll(new Rotate(rotations[i]));
         }
     }
 
     /**
      * Rotate all wakes to the given rotation.
+     *
      * @param rotation the from north angle in degrees to rotate to.
      */
     void rotate(double rotation) {
         for (int i = 0; i < arcs.length; i++) {
             rotations[i] = rotation;
+            rotationalVelocities[i] = 0;
             arcs[i].getTransforms().setAll(new Rotate(rotation));
         }
     }
-
 }