Merge branch 'issue_26_wind' into RaceFactory

# Conflicts: # racevisionGame/src/main/java/mock/model/MockRace.java # racevisionGame/src/main/java/shared/model/Race.java # racevisionGame/src/main/java/visualiser/model/VisualiserRace.java
2017-08-02 15:04:55 +12:00
parent 81eeca3533 ed12ff659d
commit 51bbdf9a50
5 changed files with 376 additions and 16 deletions
@@ -69,7 +69,18 @@ public class MockRace extends Race {

        this.shrinkBoundary = GPSCoordinate.getShrinkBoundary(this.boundary);

-        this.wind = new Wind();
+
+        //Set up wind generator. It may be tidier to create this outside the race (with the values sourced from a data file maybe?) and pass it in.
+        this.windGenerator = new WindGenerator(
+                Bearing.fromDegrees(225),
+                Bearing.fromDegrees(215),
+                Bearing.fromDegrees(235),
+                12d,
+                8d,
+                16d );
+
+        //Wind.
+        this.setWind(windGenerator.generateBaselineWind());
    }

    /**
@@ -106,6 +117,7 @@ public class MockRace extends Race {
     */
    public void run() {
        initialiseBoats();
+        initialiseWindDirection();
        this.countdownTimer.start();
    }

@@ -253,8 +265,8 @@ public class MockRace extends Race {


        //Convert wind direction and speed to ints. //TODO this conversion should be done inside the racestatus class.
-        int windDirectionInt = AC35UnitConverter.encodeHeading(wind.getWindDirection().degrees());
-        int windSpeedInt = (int) (wind.getWindSpeed() * Constants.KnotsToMMPerSecond);
+        int windDirectionInt = AC35UnitConverter.encodeHeading(this.getWindDirection().degrees());
+        int windSpeedInt = (int) (this.getWindSpeed() * Constants.KnotsToMMPerSecond);

        //Create race status object, and send it.
        RaceStatus raceStatus = new RaceStatus(
@@ -541,7 +553,12 @@ public class MockRace extends Race {


        //Find the VMG inside these bounds.
-        VMG bestVMG = boat.getPolars().calculateVMG(wind.getWindDirection(), wind.getWindSpeed(), boat.calculateBearingToNextMarker(), lowerAcceptableBound, upperAcceptableBound);
+        VMG bestVMG = boat.getPolars().calculateVMG(
+                this.getWindDirection(),
+                this.getWindSpeed(),
+                boat.calculateBearingToNextMarker(),
+                lowerAcceptableBound,
+                upperAcceptableBound);


        return bestVMG;
@@ -811,11 +828,24 @@ public class MockRace extends Race {
        return boats;
    }

+
+    /**
+     * Initialises the wind bearing with the value of the windBaselineBearing.
+     */
+    protected void initialiseWindDirection() {
+        //Set the starting bearing.
+        this.setWind(windGenerator.generateBaselineWind());
+    }
+
+
    /**
     * Changes the wind direction randomly, while keeping it within [windLowerBound, windUpperBound].
     */
    protected void changeWindDirection() {
-        this.wind.changeWindDirection();
+
+        Wind nextWind = windGenerator.generateNextWind(raceWind.getValue());
+
+        setWind(nextWind);
    }


@@ -0,0 +1,249 @@
+package mock.model;
+
+
+import shared.model.Bearing;
+import shared.model.Wind;
+
+import java.util.Random;
+
+/**
+ * This class generates Wind objects for use in a MockRace.
+ * Bounds on bearing and speed can be specified.
+ * Wind can be completely random, or random incremental change.
+ */
+public class WindGenerator {
+
+    /**
+     * The bearing the wind direction starts at.
+     */
+    private Bearing windBaselineBearing;
+
+    /**
+     * The lower bearing angle that the wind may have.
+     */
+    private Bearing windBearingLowerBound;
+
+    /**
+     * The upper bearing angle that the wind may have.
+     */
+    private Bearing windBearingUpperBound;
+
+
+
+    /**
+     * The speed the wind starts at, in knots.
+     */
+    private double windBaselineSpeed;
+
+    /**
+     * The lower speed that the wind may have, in knots.
+     */
+    private double windSpeedLowerBound;
+
+    /**
+     * The upper speed that the wind may have, in knots.
+     */
+    private double windSpeedUpperBound;
+
+
+    /**
+     * Creates a wind generator, with a baseline, lower bound, and upper bound, for the wind speed and direction.
+     * @param windBaselineBearing Baseline wind direction.
+     * @param windBearingLowerBound Lower bound for wind direction.
+     * @param windBearingUpperBound Upper bound for wind direction.
+     * @param windBaselineSpeed Baseline wind speed, in knots.
+     * @param windSpeedLowerBound Lower bound for wind speed, in knots.
+     * @param windSpeedUpperBound Upper bound for wind speed, in knots.
+     */
+    public WindGenerator(Bearing windBaselineBearing, Bearing windBearingLowerBound, Bearing windBearingUpperBound, double windBaselineSpeed, double windSpeedLowerBound, double windSpeedUpperBound) {
+
+        this.windBaselineBearing = windBaselineBearing;
+        this.windBearingLowerBound = windBearingLowerBound;
+        this.windBearingUpperBound = windBearingUpperBound;
+        this.windBaselineSpeed = windBaselineSpeed;
+        this.windSpeedLowerBound = windSpeedLowerBound;
+        this.windSpeedUpperBound = windSpeedUpperBound;
+
+    }
+
+
+    /**
+     * Generates a wind object using the baseline wind speed and bearing.
+     * @return Baseline wind object.
+     */
+    public Wind generateBaselineWind() {
+        return new Wind(windBaselineBearing, windBaselineSpeed);
+    }
+
+    /**
+     * Generates a random Wind object, that is within the provided bounds.
+     * @return Generated wind object.
+     */
+    public Wind generateRandomWind() {
+
+        double windSpeed = generateRandomWindSpeed();
+        Bearing windBearing = generateRandomWindBearing();
+
+        return new Wind(windBearing, windSpeed);
+
+    }
+
+    /**
+     * Generates a random wind speed within the specified bounds. In knots.
+     * @return Wind speed, in knots.
+     */
+    private double generateRandomWindSpeed() {
+
+        double randomSpeedKnots = generateRandomValueInBounds(windSpeedLowerBound, windSpeedUpperBound);
+
+        return randomSpeedKnots;
+    }
+
+
+    /**
+     * Generates a random wind bearing within the specified bounds.
+     * @return Wind bearing.
+     */
+    private Bearing generateRandomWindBearing() {
+
+        double randomBearingDegrees = generateRandomValueInBounds(windBearingLowerBound.degrees(), windBearingUpperBound.degrees());
+
+        return Bearing.fromDegrees(randomBearingDegrees);
+    }
+
+
+    /**
+     * Generates a random value within a specified interval.
+     * @param lowerBound The lower bound of the interval.
+     * @param upperBound The upper bound of the interval.
+     * @return A random value within the interval.
+     */
+    private static double generateRandomValueInBounds(double lowerBound, double upperBound) {
+
+        float proportion = new Random().nextFloat();
+
+        double delta = upperBound - lowerBound;
+
+        double amount = delta * proportion;
+
+        double finalAmount = amount + lowerBound;
+
+        return finalAmount;
+
+    }
+
+
+    /**
+     * Generates a new value within an interval, given a start value, chance to change, and change amount.
+     * @param lowerBound Lower bound of interval.
+     * @param upperBound Upper bound of interval.
+     * @param currentValue The current value to change.
+     * @param changeAmount The amount to change by.
+     * @param chanceToChange The change to actually change the value.
+     * @return The new value.
+     */
+    private static double generateNextValueInBounds(double lowerBound, double upperBound, double currentValue, double changeAmount, double chanceToChange) {
+
+        float chance = new Random().nextFloat();
+
+
+        if (chance <= chanceToChange) {
+            currentValue += changeAmount;
+
+        } else if (chance <= (2 * chanceToChange)) {
+            currentValue -= changeAmount;
+
+        }
+
+        currentValue = clamp(lowerBound, upperBound, currentValue);
+
+        return currentValue;
+
+    }
+
+
+    /**
+     * Generates the next Wind object, that is within the provided bounds. This randomly increases or decreases the wind's speed and bearing.
+     * @param currentWind The current wind to change. This is not modified.
+     * @return Generated wind object.
+     */
+    public Wind generateNextWind(Wind currentWind) {
+
+        double windSpeed = generateNextWindSpeed(currentWind.getWindSpeed());
+        Bearing windBearing = generateNextWindBearing(currentWind.getWindDirection());
+
+        return new Wind(windBearing, windSpeed);
+
+    }
+
+
+    /**
+     * Generates the next wind speed to use.
+     * @param windSpeed Current wind speed, in knots.
+     * @return Next wind speed, in knots.
+     */
+    private double generateNextWindSpeed(double windSpeed) {
+
+        double chanceToChange = 0.2;
+        double changeAmount = 0.1;
+
+        double nextWindSpeed = generateNextValueInBounds(
+                windSpeedLowerBound,
+                windSpeedUpperBound,
+                windSpeed,
+                changeAmount,
+                chanceToChange);
+
+        return nextWindSpeed;
+    }
+
+
+    /**
+     * Generates the next wind speed to use.
+     * @param windBearing Current wind bearing.
+     * @return Next wind speed.
+     */
+    private Bearing generateNextWindBearing(Bearing windBearing) {
+
+        double chanceToChange = 0.2;
+        double changeAmount = 0.5;
+
+        double nextWindBearingDegrees = generateNextValueInBounds(
+                windBearingLowerBound.degrees(),
+                windBearingUpperBound.degrees(),
+                windBearing.degrees(),
+                changeAmount,
+                chanceToChange);
+
+        return Bearing.fromDegrees(nextWindBearingDegrees);
+    }
+
+
+
+
+
+    /**
+     * Clamps a value to be within an interval.
+     * @param lower Lower bound of the interval.
+     * @param upper Upper bound of the interval.
+     * @param value Value to clamp.
+     * @return The clamped value.
+     */
+    private static double clamp(double lower, double upper, double value) {
+
+        if (value > upper) {
+            value = upper;
+
+        } else if (value < lower) {
+            value = lower;
+
+        }
+
+        return value;
+    }
+
+
+
+
+
+}