Merge remote-tracking branch 'remotes/origin/story68' into Development

racevisionGame/src/main/java/shared/model/Race.java

@@ -332,6 +332,13 @@ public abstract class Race {
         return  lastFps;
     }
 
+    /**
+     * Returns the legs of this race
+     * @return list of legs
+     */
+    public List<Leg> getLegs() {
+        return legs;
+    }
 
     /**
      * Increments the FPS counter, and adds timePeriod milliseconds to our FPS reset timer.

racevisionGame/src/main/java/visualiser/model/ResizableRaceCanvas.java

@@ -3,16 +3,12 @@ package visualiser.model;
 
 import javafx.scene.Node;
 import javafx.scene.image.Image;
-import javafx.scene.paint.Color;
-import javafx.scene.paint.Paint;
+import javafx.scene.paint.*;
 import javafx.scene.transform.Rotate;
 import network.Messages.Enums.BoatStatusEnum;
 import shared.dataInput.RaceDataSource;
-import shared.model.GPSCoordinate;
-import shared.model.Mark;
-import shared.model.RaceClock;
+import shared.model.*;
 
-import java.time.Duration;
 import java.util.List;
 
 /**
@@ -472,6 +468,9 @@ public class ResizableRaceCanvas extends ResizableCanvas {
         //Race boundary.
         drawBoundary();
 
+        //Guiding Line
+        drawRaceLine();
+
         //Boats.
         drawBoats();
 
@@ -480,6 +479,125 @@ public class ResizableRaceCanvas extends ResizableCanvas {
 
     }
 
+    /**
+     * draws a transparent line around the course that shows the paths boats must travel
+     */
+    public void drawRaceLine(){
+        List<Leg> legs = this.visualiserRace.getLegs();
+        GPSCoordinate legStartPoint = legs.get(0).getStartCompoundMark().getAverageGPSCoordinate();
+        GPSCoordinate nextStartPoint;
+        for (int i = 0; i < legs.size() -1; i++) {
+            nextStartPoint = drawLineRounding(legs, i, legStartPoint);
+            legStartPoint = nextStartPoint;
+        }
+    }
+
+    /**
+     * Draws a line around a course that shows where boats need to go. This method
+     * draws the line leg by leg
+     * @param legs the legs of a race
+     * @param index the index of the current leg to use
+     * @return the end point of the current leg that has been drawn
+     */
+    private GPSCoordinate drawLineRounding(List<Leg> legs, int index, GPSCoordinate legStartPoint){
+        GPSCoordinate startDirectionLinePoint;
+        GPSCoordinate endDirectionLinePoint;
+        Bearing bearingOfDirectionLine;
+
+        GPSCoordinate startNextDirectionLinePoint;
+        GPSCoordinate endNextDirectionLinePoint;
+        Bearing bearingOfNextDirectionLine;
+
+        //finds the direction of the current leg as a bearing
+        startDirectionLinePoint = legStartPoint;
+        endDirectionLinePoint = legs.get(index).getEndCompoundMark().getMark1Position();
+        bearingOfDirectionLine = GPSCoordinate.calculateBearing(startDirectionLinePoint, endDirectionLinePoint);
+
+        //finds the direction of the next leg as a bearing
+        if (index < legs.size() -2){ // not last leg
+            startNextDirectionLinePoint = legs.get(index + 1).getStartCompoundMark().getMark1Position();
+            endNextDirectionLinePoint = legs.get(index + 1).getEndCompoundMark().getMark1Position();
+            bearingOfNextDirectionLine = GPSCoordinate.calculateBearing(startNextDirectionLinePoint, endNextDirectionLinePoint);
+
+            //use the direction line to find a point parallel to it by the mark
+            GPSCoordinate pointToStartCurve = GPSCoordinate.calculateNewPosition(endDirectionLinePoint,
+                    100, Azimuth.fromDegrees(bearingOfDirectionLine.degrees()+90));
+
+            //use the direction line to find a point to curve too
+            GPSCoordinate pointToEndCurve = GPSCoordinate.calculateNewPosition(endDirectionLinePoint,
+                    100, Azimuth.fromDegrees(bearingOfNextDirectionLine.degrees()+90));
+
+            //use the curve points to find the two control points for the bezier curve
+            GPSCoordinate controlPoint;
+            GPSCoordinate controlPoint2;
+            Bearing bearingOfCurveLine = GPSCoordinate.calculateBearing(pointToStartCurve, pointToEndCurve);
+            if ((bearingOfDirectionLine.degrees() - bearingOfNextDirectionLine.degrees() +360)%360< 145){
+                //small turn
+                controlPoint = GPSCoordinate.calculateNewPosition(pointToStartCurve,
+                        50, Azimuth.fromDegrees(bearingOfCurveLine.degrees()+45));
+                controlPoint2 = controlPoint;
+            }else{
+                //large turn
+                controlPoint = GPSCoordinate.calculateNewPosition(pointToStartCurve,
+                        150, Azimuth.fromDegrees(bearingOfCurveLine.degrees()+90));
+                controlPoint2 = GPSCoordinate.calculateNewPosition(pointToEndCurve,
+                        150, Azimuth.fromDegrees(bearingOfCurveLine.degrees()+90));
+            }
+
+
+            //change all gps into graph coordinate
+            GraphCoordinate startPath = this.map.convertGPS(startDirectionLinePoint);
+            GraphCoordinate curvePoint = this.map.convertGPS(pointToStartCurve);
+            GraphCoordinate curvePointEnd = this.map.convertGPS(pointToEndCurve);
+            GraphCoordinate c1 = this.map.convertGPS(controlPoint);
+            GraphCoordinate c2 = this.map.convertGPS(controlPoint2);
+
+            gc.setLineWidth(2);
+            gc.setStroke(Color.MEDIUMAQUAMARINE);
+
+            gc.beginPath();
+            gc.moveTo(startPath.getX(), startPath.getY());
+            gc.lineTo(curvePoint.getX(), curvePoint.getY());
+            drawArrowHead(startDirectionLinePoint, pointToStartCurve);
+            gc.bezierCurveTo(c1.getX(), c1.getY(), c2.getX(), c2.getY(), curvePointEnd.getX(), curvePointEnd.getY());
+            gc.stroke();
+            gc.closePath();
+            gc.save();
+
+            return pointToEndCurve;
+        }else{//last leg so no curve
+            GraphCoordinate startPath = this.map.convertGPS(legStartPoint);
+            GraphCoordinate endPath = this.map.convertGPS(legs.get(index).getEndCompoundMark().getAverageGPSCoordinate());
+
+            gc.beginPath();
+            gc.moveTo(startPath.getX(), startPath.getY());
+            gc.lineTo(endPath.getX(), endPath.getY());
+            gc.stroke();
+            gc.closePath();
+            gc.save();
+            drawArrowHead(legStartPoint, legs.get(index).getEndCompoundMark().getAverageGPSCoordinate());
+            return null;
+        }
+    }
+
+    private void drawArrowHead(GPSCoordinate start, GPSCoordinate end){
+
+        GraphCoordinate lineStart = this.map.convertGPS(start);
+        GraphCoordinate lineEnd = this.map.convertGPS(end);
+
+        double arrowAngle = Math.toRadians(45.0);
+        double arrowLength = 10.0;
+        double dx = lineStart.getX() - lineEnd.getX();
+        double dy = lineStart.getY() - lineEnd.getY();
+        double angle = Math.atan2(dy, dx);
+        double x1 = Math.cos(angle + arrowAngle) * arrowLength + lineEnd.getX();
+        double y1 = Math.sin(angle + arrowAngle) * arrowLength + lineEnd.getY();
+
+        double x2 = Math.cos(angle - arrowAngle) * arrowLength + lineEnd.getX();
+        double y2 = Math.sin(angle - arrowAngle) * arrowLength + lineEnd.getY();
+        gc.strokeLine(lineEnd.getX(), lineEnd.getY(), x1, y1);
+        gc.strokeLine(lineEnd.getX(), lineEnd.getY(), x2, y2);
+    }
 
     /**
      * Draws the race boundary image onto the canvas.