fanwuyang/SENG302
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Changed it so Boat can be used as a superclass for StreamedBoat and BoatInRace properly and removed ConstantVelocityRace. Everything that used to use BoatInRace or StreamedBoat now uses it superclass (boat). #pair[jjg64, cbt24] #refactor #story[782]

Browse Source
This commit is contained in:
Joseph Gardner
2017-04-28 12:35:00 +12:00
parent 3d284c4a2b
commit f377cf6471
16 changed files with 572 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files
visualiser/src/main/java/seng302/Controllers/RaceController.java
+6 -6
View File
@@ -61,15 +61,15 @@ public class RaceController extends Controller {
Button showSetAnno;
@FXML
TableView<BoatInRace> boatInfoTable;
TableView<Boat> boatInfoTable;
@FXML
TableColumn<BoatInRace, String> boatPlacingColumn;
TableColumn<Boat, String> boatPlacingColumn;
@FXML
TableColumn<BoatInRace, String> boatTeamColumn;
TableColumn<Boat, String> boatTeamColumn;
@FXML
TableColumn<BoatInRace, String> boatMarkColumn;
TableColumn<Boat, String> boatMarkColumn;
@FXML
TableColumn<BoatInRace, String> boatSpeedColumn;
TableColumn<Boat, String> boatSpeedColumn;
/**
* Updates the ResizableRaceCanvas (raceMap) with most recent data
@@ -77,7 +77,7 @@ public class RaceController extends Controller {
* @param boats boats that are to be displayed in the race
* @see ResizableRaceCanvas
*/
public void updateMap(ObservableList<BoatInRace> boats) {
public void updateMap(ObservableList<Boat> boats) {
raceMap.setBoats(boats);
raceMap.update();
}
visualiser/src/main/java/seng302/Controllers/StartController.java
+6 -6
View File
@@ -14,7 +14,7 @@ import javafx.scene.layout.AnchorPane;
import javafx.scene.layout.GridPane;
import org.xml.sax.SAXException;
import seng302.Mock.*;
import seng302.Model.BoatInRace;
import seng302.Model.Boat;
import seng302.Model.RaceClock;
import seng302.RaceDataSource;
import seng302.RaceXMLReader;
@@ -34,9 +34,9 @@ public class StartController extends Controller {
@FXML private GridPane start;
@FXML private AnchorPane startWrapper;
@FXML private TableView<BoatInRace> boatNameTable;
@FXML private TableColumn<BoatInRace, String> boatNameColumn;
@FXML private TableColumn<BoatInRace, String> boatCodeColumn;
@FXML private TableView<Boat> boatNameTable;
@FXML private TableColumn<Boat, String> boatNameColumn;
@FXML private TableColumn<Boat, String> boatCodeColumn;
@FXML private Label timeZoneTime;
@FXML private Label timer;
@FXML private int PRERACE_TIME = 15000;
@@ -107,8 +107,8 @@ public class StartController extends Controller {
}
private void initialiseTables() {
List<BoatInRace> boats = raceData.getBoats();
ObservableList<BoatInRace> observableBoats = FXCollections.observableArrayList(boats);
List<Boat> boats = raceData.getBoats();
ObservableList<Boat> observableBoats = FXCollections.observableArrayList(boats);
boatNameTable.setItems(observableBoats);
boatNameColumn.setCellValueFactory(cellData -> cellData.getValue().getName());
visualiser/src/main/java/seng302/Mock/BoatXMLReader.java
+5
View File
@@ -5,6 +5,7 @@ import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import seng302.Model.Boat;
import seng302.XMLReader;
import javax.xml.parsers.ParserConfigurationException;
@@ -153,4 +154,8 @@ public class BoatXMLReader extends XMLReader {
public Map<Integer, StreamedBoat> getStreamedBoatMap() {
return streamedBoatMap;
}
public List<Boat> getBoats() {
return new ArrayList<>(streamedBoatMap.values());
}
}
visualiser/src/main/java/seng302/Mock/StreamedBoat.java
+3 -15
View File
@@ -11,26 +11,22 @@ import seng302.Model.Marker;
/**
* Created by Joseph on 24/04/2017.
*/
public class StreamedBoat extends BoatInRace {
public class StreamedBoat extends Boat {
private int sourceID;
private boolean dnf = false;
private void init() {
this.velocity = 0;
this.scaledVelocity = 0;
this.heading = 0;
this.setCurrentLeg(new Leg("None", -1));
this.setCurrentPosition(new GPSCoordinate(0, 0));
}
public StreamedBoat(int sourceID, String name, Color colour, String abbrev) {
super(name, colour, abbrev);
super(name, abbrev);
this.sourceID = sourceID;
this.init();
}
public StreamedBoat(int sourceID) {
super("None", Color.BLACK, "None");
super("None", "None");
this.sourceID = sourceID;
this.init();
}
@@ -49,12 +45,4 @@ public class StreamedBoat extends BoatInRace {
}
return azimuth;
}
public boolean isDnf() {
return dnf;
}
public void setDnf(boolean dnf) {
this.dnf = dnf;
}
}
visualiser/src/main/java/seng302/Mock/StreamedCourse.java
+3 -6
View File
@@ -1,10 +1,7 @@
package seng302.Mock;
import seng302.GPSCoordinate;
import seng302.Model.BoatInRace;
import seng302.Model.Leg;
import seng302.Model.Marker;
import seng302.Model.RaceClock;
import seng302.Model.*;
import seng302.RaceDataSource;
import java.time.ZonedDateTime;
@@ -51,8 +48,8 @@ public class StreamedCourse implements RaceDataSource {
return regattaXMLReader;
}
public List<BoatInRace> getBoats() {
return new ArrayList<>(boatXMLReader.getStreamedBoatMap().values());
public List<Boat> getBoats() {
return boatXMLReader.getBoats();
}
public List<Leg> getLegs() {
visualiser/src/main/java/seng302/Mock/StreamedRace.java
+6 -64
View File
@@ -29,12 +29,11 @@ public class StreamedRace extends Race {
Marker endMarker = officialStart.getEndMarker();
for (int i = 0; i < startingBoats.size(); i++) {
BoatInRace boat = startingBoats.get(i);
Boat boat = startingBoats.get(i);
if (boat != null) {
Leg startLeg = new Leg(name, 0);
startLeg.setEndMarker(endMarker);
boat.setCurrentLeg(startLeg);
boat.setHeading(boat.calculateHeading());
}
}
}
@@ -55,18 +54,12 @@ public class StreamedRace extends Race {
* @param timeElapsed Time that has elapse since the start of the the race.
* @see BoatInRace
*/
protected void checkPosition(StreamedBoat boat, long timeElapsed) {
protected void checkPosition(Boat boat, long timeElapsed) {
if (boat.getCurrentLeg().getName().toLowerCase().contains("finish")) {
//boat has finished
boatsFinished++;
boat.setFinished(true);
boat.setTimeFinished(timeElapsed);
} else if (boat.isDnf()) {
boatsFinished++;
boat.setFinished(true);
boat.setCurrentLeg(new Leg("DNF", -1));
boat.setVelocity(0);
boat.setScaledVelocity(0);
}
//Update the boat display table in the GUI to reflect the leg change
updatePositions();
@@ -78,64 +71,13 @@ public class StreamedRace extends Race {
* @param boat to be updated
* @param millisecondsElapsed time since last update
*/
protected void updatePosition(StreamedBoat boat, int millisecondsElapsed) {
//distanceTravelled = velocity (nm p hr) * time taken to update loop
double distanceTravelled = (boat.getVelocity() * millisecondsElapsed) / 3600000;
boolean finish = boat.getCurrentLeg().getName().toLowerCase().contains("finish");
if (!finish) {
//Calculate boat's new position by adding the distance travelled onto the start point of the leg
boat.setCurrentPosition(calculatePosition(boat.getCurrentPosition(), distanceTravelled, boat.calculateAzimuth()));
}
protected void updatePosition(Boat boat, int millisecondsElapsed) {
//TODO Grab info from network
// setPostiion(boat, coordinate);
}
protected void setPostion(StreamedBoat boat, GPSCoordinate coordinate) {
protected void setPostion(Boat boat, GPSCoordinate coordinate) {
boat.setCurrentPosition(coordinate);
}
/**
* Calculates the boats next GPS position based on its distance travelled and heading
*
* @param oldCoordinates GPS coordinates of the boat's starting position
* @param distanceTravelled distance in nautical miles
* @param azimuth boat's current direction. Value between -180 and 180
* @return The boat's new coordinate
*/
public static GPSCoordinate calculatePosition(GPSCoordinate oldCoordinates, double distanceTravelled, double azimuth) {
//Find new coordinate using current heading and distance
GeodeticCalculator geodeticCalculator = new GeodeticCalculator();
//Load start point into calculator
Point2D startPoint = new Point2D.Double(oldCoordinates.getLongitude(), oldCoordinates.getLatitude());
geodeticCalculator.setStartingGeographicPoint(startPoint);
//load direction and distance travelled into calculator
geodeticCalculator.setDirection(azimuth, distanceTravelled * Constants.NMToMetersConversion);
//get new point
Point2D endPoint = geodeticCalculator.getDestinationGeographicPoint();
return new GPSCoordinate(endPoint.getY(), endPoint.getX());
}
/**
* Checks the position of the boat, this updates the boats current position.
* @deprecated
* @param boat Boat that the postion is to be updated for.
* @param timeElapsed Time that has elapse since the start of the the race.
* @see BoatInRace
*/
protected void checkPosition(BoatInRace boat, long timeElapsed) {
}
/**
* Updates the boat's gps coordinates
* @deprecated
* @param boat to be updated
* @param millisecondsElapsed time since last update
*/
protected void updatePosition(BoatInRace boat, int millisecondsElapsed){
}
}
visualiser/src/main/java/seng302/Model/Boat.java
+136 -4
View File
@@ -2,16 +2,39 @@ package seng302.Model;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import org.geotools.referencing.GeodeticCalculator;
import seng302.Constants;
import seng302.GPSCoordinate;
import java.awt.geom.Point2D;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
/**
* Created by fwy13 on 3/03/17.
*/
public class Boat {
private StringProperty name;
protected StringProperty name;
protected double velocity;
private StringProperty velocityProp;
private String abbrev;
protected String abbrev;
protected GPSCoordinate currentPosition;
protected double heading;
protected Leg currentLeg;
protected StringProperty currentLegName;
protected boolean finished = false;
protected long timeFinished;
protected StringProperty position;
protected boolean started = false;
private double wakeScale = 1 / 50;
protected Queue<TrackPoint> track = new ConcurrentLinkedQueue<>();
protected long nextValidTime = 0;
protected static final float BASE_TRACK_POINT_TIME_INTERVAL = 5000;
protected static float trackPointTimeInterval = 5000; // every 1 seconds
protected final int TRACK_POINT_LIMIT = 10;
/**
* Boat initialiser which keeps all of the information of the boat.
@@ -25,6 +48,8 @@ public class Boat {
this.velocityProp = new SimpleStringProperty(String.valueOf(Math.round(velocity)));
this.abbrev = abbrev;
this.name = new SimpleStringProperty(name);
currentLegName = new SimpleStringProperty("");
position = new SimpleStringProperty("-");
}
/**
@@ -34,8 +59,52 @@ public class Boat {
* @param abbrev nam abbreviation
*/
public Boat(String name, String abbrev) {
this.abbrev = abbrev;
this.name = new SimpleStringProperty(name);
this(name, 0, abbrev);
}
/**
* Returns the position of the end of the boat's wake, which is 180 degrees
* from the boat's heading, and whose length is proportional to the boat's
* speed.
*
* @return GPSCoordinate of wake endpoint.
*/
public GPSCoordinate getWake() {
double reverseHeading = getHeading() - 180;
double distance = wakeScale * getVelocity();
GeodeticCalculator calc = new GeodeticCalculator();
calc.setStartingGeographicPoint(
new Point2D.Double(getCurrentPosition().getLongitude(), getCurrentPosition().getLatitude())
);
calc.setDirection(reverseHeading, distance);
Point2D endpoint = calc.getDestinationGeographicPoint();
return new GPSCoordinate(endpoint.getY(), endpoint.getX());
}
/**
* Adds a new point to boat's track.
* @param coordinate of point on track
* @return whether add is successful
* @see seng302.Model.TrackPoint
*/
public boolean addTrackPoint(GPSCoordinate coordinate) {
Boolean added = System.currentTimeMillis() >= nextValidTime;
long currentTime = System.currentTimeMillis();
if (added && this.started) {
nextValidTime = currentTime + (long) trackPointTimeInterval;
track.add(new TrackPoint(coordinate, currentTime, TRACK_POINT_LIMIT * (long) trackPointTimeInterval));
}
return added;
}
/**
* Returns the boat's sampled track between start of race and current time.
* @return queue of track points
* @see seng302.Model.TrackPoint
*/
public Queue<TrackPoint> getTrack() {
return track;
}
/**
@@ -94,4 +163,67 @@ public class Boat {
return abbrev;
}
public GPSCoordinate getCurrentPosition() {
return currentPosition;
}
public void setCurrentPosition(GPSCoordinate currentPosition) {
this.currentPosition = currentPosition;
}
public double getHeading() {
return heading;
}
public void setHeading(double heading) {
this.heading = heading;
}
public Leg getCurrentLeg() {
return currentLeg;
}
public void setCurrentLeg(Leg currentLeg) {
this.currentLeg = currentLeg;
this.currentLegName.setValue(currentLeg.getName());
}
public boolean isFinished() {
return finished;
}
public void setFinished(boolean finished) {
this.finished = finished;
}
public long getTimeFinished() {
return timeFinished;
}
public void setTimeFinished(long timeFinished) {
this.timeFinished = timeFinished;
}
public StringProperty positionProperty() {
return position;
}
public void setPosition(String position) {
this.position.set(position);
}
public boolean isStarted() {
return started;
}
public void setStarted(boolean started) {
this.started = started;
}
/**
* @return Name of boat's current leg
*/
public StringProperty getCurrentLegName() {
return currentLegName;
}
}
visualiser/src/main/java/seng302/Model/BoatInRace.java
-17
View File
@@ -35,7 +35,6 @@ public class BoatInRace extends Boat {
protected static final float BASE_TRACK_POINT_TIME_INTERVAL = 5000;
protected static float trackPointTimeInterval = 5000; // every 1 seconds
protected final int TRACK_POINT_LIMIT = 10;
protected boolean trackVisible = true;
/**
* Constructor method.
@@ -309,22 +308,6 @@ public class BoatInRace extends Boat {
return track;
}
/**
* Returns whether track is visible
* @return true if visible
*/
public boolean isTrackVisible() {
return trackVisible;
}
/**
* Sets track visibility.
* @param trackVisible visible if true.
*/
public void setTrackVisible(boolean trackVisible) {
this.trackVisible = trackVisible;
}
/**
* Get base track point time interval
* @return base track point time interval
visualiser/src/main/java/seng302/Model/ConstantVelocityRace.java
+208 -208
View File
@@ -1,208 +1,208 @@
package seng302.Model;
import org.geotools.referencing.GeodeticCalculator;
import seng302.Constants;
import seng302.Controllers.RaceController;
import seng302.GPSCoordinate;
import seng302.RaceDataSource;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
/**
* Created by cbt24 on 6/03/17.
*
* @deprecated
*/
public class ConstantVelocityRace extends Race {
private int dnfChance = 0; //%percentage chance a boat fails at each checkpoint
/**
* Initialiser for a constant velocity race without standard data source
*
* @param startingBoats in race
* @param legs in race
* @param controller for graphics
* @param scaleFactor of timer
*/
public ConstantVelocityRace(List<BoatInRace> startingBoats, List<Leg> legs, RaceController controller, int scaleFactor) {
super(startingBoats, legs, controller, scaleFactor);
}
/**
* Initialiser for legacy tests
*
* @param startingBoats in race
* @param legs in race
* @param controller for graphics
* @param scaleFactor of timer
*
* @deprecated Please use {@link #ConstantVelocityRace(List, List, RaceController, int) } for future tests.
*/
public ConstantVelocityRace(BoatInRace[] startingBoats, List<Leg> legs, RaceController controller, int scaleFactor) {
super(Arrays.asList(startingBoats), legs, controller, scaleFactor);
}
/**
* Initialiser for constant velocity race with standard data source
* @param raceData for race
* @param controller for graphics
* @param scaleFactor of timer
*/
public ConstantVelocityRace(RaceDataSource raceData, RaceController controller, int scaleFactor) {
super(raceData, controller, scaleFactor);
}
public void initialiseBoats() {
Leg officialStart = legs.get(0);
String name = officialStart.getName();
Marker endMarker = officialStart.getEndMarker();
BoatInRace.setTrackPointTimeInterval(BoatInRace.getBaseTrackPointTimeInterval() / scaleFactor);
ArrayList<Marker> startMarkers = getSpreadStartingPositions();
for (int i = 0; i < startingBoats.size(); i++) {
BoatInRace boat = startingBoats.get(i);
if (boat != null) {
boat.setScaledVelocity(boat.getVelocity() * scaleFactor);
Leg startLeg = new Leg(name, 0);
boat.setCurrentPosition(startMarkers.get(i).getAverageGPSCoordinate());
startLeg.setStartMarker(startMarkers.get(i));
startLeg.setEndMarker(endMarker);
startLeg.calculateDistance();
boat.setCurrentLeg(startLeg);
boat.setHeading(boat.calculateHeading());
}
}
}
/**
* Creates a list of starting positions for the different boats, so they do not appear cramped at the start line
*
* @return list of starting positions
*/
public ArrayList<Marker> getSpreadStartingPositions() {
int nBoats = startingBoats.size();
Marker marker = legs.get(0).getStartMarker();
GeodeticCalculator initialCalc = new GeodeticCalculator();
initialCalc.setStartingGeographicPoint(marker.getMark1().getLongitude(), marker.getMark1().getLatitude());
initialCalc.setDestinationGeographicPoint(marker.getMark2().getLongitude(), marker.getMark2().getLatitude());
double azimuth = initialCalc.getAzimuth();
double distanceBetweenMarkers = initialCalc.getOrthodromicDistance();
double distanceBetweenBoats = distanceBetweenMarkers / (nBoats + 1);
GeodeticCalculator positionCalc = new GeodeticCalculator();
positionCalc.setStartingGeographicPoint(marker.getMark1().getLongitude(), marker.getMark1().getLatitude());
ArrayList<Marker> positions = new ArrayList<>();
for (int i = 0; i < nBoats; i++) {
positionCalc.setDirection(azimuth, distanceBetweenBoats);
Point2D position = positionCalc.getDestinationGeographicPoint();
positions.add(new Marker(new GPSCoordinate(position.getY(), position.getX())));
positionCalc = new GeodeticCalculator();
positionCalc.setStartingGeographicPoint(position);
}
return positions;
}
/**
* Sets the chance each boat has of failing at a gate or marker
* @param chance percentage chance a boat has of failing per checkpoint.
*/
protected void setDnfChance(int chance) {
if (chance >= 0 && chance <= 100) {
dnfChance = chance;
}
}
protected boolean doNotFinish() {
Random rand = new Random();
return rand.nextInt(100) < dnfChance;
}
/**
* Calculates the distance a boat has travelled and updates its current position according to this value.
*
* @param boat to be updated
* @param millisecondsElapsed since last update
*/
protected void updatePosition(BoatInRace boat, int millisecondsElapsed) {
//distanceTravelled = velocity (nm p hr) * time taken to update loop
double distanceTravelled = (boat.getScaledVelocity() * millisecondsElapsed) / 3600000;
double totalDistanceTravelled = distanceTravelled + boat.getDistanceTravelledInLeg();
boolean finish = boat.getCurrentLeg().getName().equals("Finish");
if (!finish) {
boat.setHeading(boat.calculateHeading());
//update boat's distance travelled
boat.setDistanceTravelledInLeg(totalDistanceTravelled);
//Calculate boat's new position by adding the distance travelled onto the start point of the leg
boat.setCurrentPosition(calculatePosition(boat.getCurrentLeg().getStartMarker().getAverageGPSCoordinate(),
totalDistanceTravelled, boat.calculateAzimuth()));
}
}
protected void checkPosition(BoatInRace boat, long timeElapsed) {
if (boat.getDistanceTravelledInLeg() > boat.getCurrentLeg().getDistance()) {
//boat has passed onto new leg
if (boat.getCurrentLeg().getName().equals("Finish")) {
//boat has finished
boatsFinished++;
boat.setFinished(true);
boat.setTimeFinished(timeElapsed);
} else if (doNotFinish()) {
boatsFinished++;
boat.setFinished(true);
boat.setCurrentLeg(new Leg("DNF", -1));
boat.setVelocity(0);
boat.setScaledVelocity(0);
} else {
//Calculate how much the boat overshot the marker by
boat.setDistanceTravelledInLeg(boat.getDistanceTravelledInLeg() - boat.getCurrentLeg().getDistance());
//Move boat on to next leg
Leg nextLeg = legs.get(boat.getCurrentLeg().getLegNumber() + 1);
boat.setCurrentLeg(nextLeg);
//Add overshoot distance into the distance travelled for the next leg
boat.setDistanceTravelledInLeg(boat.getDistanceTravelledInLeg());
}
//Update the boat display table in the GUI to reflect the leg change
updatePositions();
}
}
/**
* Calculates the boats next GPS position based on its distance travelled and heading
*
* @param oldCoordinates GPS coordinates of the boat's starting position
* @param distanceTravelled distance in nautical miles
* @param azimuth boat's current direction. Value between -180 and 180
* @return The boat's new coordinate
*/
public static GPSCoordinate calculatePosition(GPSCoordinate oldCoordinates, double distanceTravelled, double azimuth) {
//Find new coordinate using current heading and distance
GeodeticCalculator geodeticCalculator = new GeodeticCalculator();
//Load start point into calculator
Point2D startPoint = new Point2D.Double(oldCoordinates.getLongitude(), oldCoordinates.getLatitude());
geodeticCalculator.setStartingGeographicPoint(startPoint);
//load direction and distance tranvelled into calculator
geodeticCalculator.setDirection(azimuth, distanceTravelled * Constants.NMToMetersConversion);
//get new point
Point2D endPoint = geodeticCalculator.getDestinationGeographicPoint();
return new GPSCoordinate(endPoint.getY(), endPoint.getX());
}
}
//package seng302.Model;
//
//import org.geotools.referencing.GeodeticCalculator;
//import seng302.Constants;
//import seng302.Controllers.RaceController;
//import seng302.GPSCoordinate;
//import seng302.RaceDataSource;
//
//import java.awt.geom.Point2D;
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.List;
//import java.util.Random;
//
///**
// * Created by cbt24 on 6/03/17.
// *
// * @deprecated
// */
//public class ConstantVelocityRace extends Race {
//
// private int dnfChance = 0; //%percentage chance a boat fails at each checkpoint
//
// /**
// * Initialiser for a constant velocity race without standard data source
// *
// * @param startingBoats in race
// * @param legs in race
// * @param controller for graphics
// * @param scaleFactor of timer
// */
// public ConstantVelocityRace(List<BoatInRace> startingBoats, List<Leg> legs, RaceController controller, int scaleFactor) {
// super(startingBoats, legs, controller, scaleFactor);
// }
//
// /**
// * Initialiser for legacy tests
// *
// * @param startingBoats in race
// * @param legs in race
// * @param controller for graphics
// * @param scaleFactor of timer
// *
// * @deprecated Please use {@link #ConstantVelocityRace(List, List, RaceController, int) } for future tests.
// */
// public ConstantVelocityRace(BoatInRace[] startingBoats, List<Leg> legs, RaceController controller, int scaleFactor) {
// super(Arrays.asList(startingBoats), legs, controller, scaleFactor);
// }
//
// /**
// * Initialiser for constant velocity race with standard data source
// * @param raceData for race
// * @param controller for graphics
// * @param scaleFactor of timer
// */
// public ConstantVelocityRace(RaceDataSource raceData, RaceController controller, int scaleFactor) {
// super(raceData, controller, scaleFactor);
// }
//
// public void initialiseBoats() {
// Leg officialStart = legs.get(0);
// String name = officialStart.getName();
// Marker endMarker = officialStart.getEndMarker();
//
// BoatInRace.setTrackPointTimeInterval(BoatInRace.getBaseTrackPointTimeInterval() / scaleFactor);
//
// ArrayList<Marker> startMarkers = getSpreadStartingPositions();
// for (int i = 0; i < startingBoats.size(); i++) {
// BoatInRace boat = startingBoats.get(i);
// if (boat != null) {
// boat.setScaledVelocity(boat.getVelocity() * scaleFactor);
// Leg startLeg = new Leg(name, 0);
// boat.setCurrentPosition(startMarkers.get(i).getAverageGPSCoordinate());
// startLeg.setStartMarker(startMarkers.get(i));
// startLeg.setEndMarker(endMarker);
// startLeg.calculateDistance();
// boat.setCurrentLeg(startLeg);
// boat.setHeading(boat.calculateHeading());
// }
// }
// }
//
// /**
// * Creates a list of starting positions for the different boats, so they do not appear cramped at the start line
// *
// * @return list of starting positions
// */
// public ArrayList<Marker> getSpreadStartingPositions() {
//
// int nBoats = startingBoats.size();
// Marker marker = legs.get(0).getStartMarker();
//
// GeodeticCalculator initialCalc = new GeodeticCalculator();
// initialCalc.setStartingGeographicPoint(marker.getMark1().getLongitude(), marker.getMark1().getLatitude());
// initialCalc.setDestinationGeographicPoint(marker.getMark2().getLongitude(), marker.getMark2().getLatitude());
//
// double azimuth = initialCalc.getAzimuth();
// double distanceBetweenMarkers = initialCalc.getOrthodromicDistance();
// double distanceBetweenBoats = distanceBetweenMarkers / (nBoats + 1);
//
// GeodeticCalculator positionCalc = new GeodeticCalculator();
// positionCalc.setStartingGeographicPoint(marker.getMark1().getLongitude(), marker.getMark1().getLatitude());
// ArrayList<Marker> positions = new ArrayList<>();
//
// for (int i = 0; i < nBoats; i++) {
// positionCalc.setDirection(azimuth, distanceBetweenBoats);
// Point2D position = positionCalc.getDestinationGeographicPoint();
// positions.add(new Marker(new GPSCoordinate(position.getY(), position.getX())));
//
// positionCalc = new GeodeticCalculator();
// positionCalc.setStartingGeographicPoint(position);
// }
// return positions;
// }
//
// /**
// * Sets the chance each boat has of failing at a gate or marker
// * @param chance percentage chance a boat has of failing per checkpoint.
// */
// protected void setDnfChance(int chance) {
// if (chance >= 0 && chance <= 100) {
// dnfChance = chance;
// }
// }
//
// protected boolean doNotFinish() {
// Random rand = new Random();
// return rand.nextInt(100) < dnfChance;
// }
//
// /**
// * Calculates the distance a boat has travelled and updates its current position according to this value.
// *
// * @param boat to be updated
// * @param millisecondsElapsed since last update
// */
// protected void updatePosition(BoatInRace boat, int millisecondsElapsed) {
//
// //distanceTravelled = velocity (nm p hr) * time taken to update loop
// double distanceTravelled = (boat.getScaledVelocity() * millisecondsElapsed) / 3600000;
//
// double totalDistanceTravelled = distanceTravelled + boat.getDistanceTravelledInLeg();
//
// boolean finish = boat.getCurrentLeg().getName().equals("Finish");
// if (!finish) {
// boat.setHeading(boat.calculateHeading());
// //update boat's distance travelled
// boat.setDistanceTravelledInLeg(totalDistanceTravelled);
// //Calculate boat's new position by adding the distance travelled onto the start point of the leg
// boat.setCurrentPosition(calculatePosition(boat.getCurrentLeg().getStartMarker().getAverageGPSCoordinate(),
// totalDistanceTravelled, boat.calculateAzimuth()));
// }
// }
//
// protected void checkPosition(BoatInRace boat, long timeElapsed) {
// if (boat.getDistanceTravelledInLeg() > boat.getCurrentLeg().getDistance()) {
// //boat has passed onto new leg
// if (boat.getCurrentLeg().getName().equals("Finish")) {
// //boat has finished
// boatsFinished++;
// boat.setFinished(true);
// boat.setTimeFinished(timeElapsed);
// } else if (doNotFinish()) {
// boatsFinished++;
// boat.setFinished(true);
// boat.setCurrentLeg(new Leg("DNF", -1));
// boat.setVelocity(0);
// boat.setScaledVelocity(0);
// } else {
// //Calculate how much the boat overshot the marker by
// boat.setDistanceTravelledInLeg(boat.getDistanceTravelledInLeg() - boat.getCurrentLeg().getDistance());
// //Move boat on to next leg
// Leg nextLeg = legs.get(boat.getCurrentLeg().getLegNumber() + 1);
//
// boat.setCurrentLeg(nextLeg);
// //Add overshoot distance into the distance travelled for the next leg
// boat.setDistanceTravelledInLeg(boat.getDistanceTravelledInLeg());
// }
// //Update the boat display table in the GUI to reflect the leg change
// updatePositions();
// }
// }
//
// /**
// * Calculates the boats next GPS position based on its distance travelled and heading
// *
// * @param oldCoordinates GPS coordinates of the boat's starting position
// * @param distanceTravelled distance in nautical miles
// * @param azimuth boat's current direction. Value between -180 and 180
// * @return The boat's new coordinate
// */
// public static GPSCoordinate calculatePosition(GPSCoordinate oldCoordinates, double distanceTravelled, double azimuth) {
//
// //Find new coordinate using current heading and distance
//
// GeodeticCalculator geodeticCalculator = new GeodeticCalculator();
// //Load start point into calculator
// Point2D startPoint = new Point2D.Double(oldCoordinates.getLongitude(), oldCoordinates.getLatitude());
// geodeticCalculator.setStartingGeographicPoint(startPoint);
// //load direction and distance tranvelled into calculator
// geodeticCalculator.setDirection(azimuth, distanceTravelled * Constants.NMToMetersConversion);
// //get new point
// Point2D endPoint = geodeticCalculator.getDestinationGeographicPoint();
//
// return new GPSCoordinate(endPoint.getY(), endPoint.getX());
// }
//
//}
visualiser/src/main/java/seng302/Model/Race.java
+23 -16
View File
@@ -21,8 +21,8 @@ import java.util.Random;
* Created by fwy13 on 3/03/17.
*/
public abstract class Race implements Runnable {
//protected BoatInRace[] startingBoats;
protected ObservableList<BoatInRace> startingBoats;
//protected Boat[] startingBoats;
protected ObservableList<Boat> startingBoats;
protected List<Leg> legs;
protected RaceController controller;
protected int boatsFinished = 0;
@@ -42,7 +42,7 @@ public abstract class Race implements Runnable {
* @param controller race controller
* @param scaleFactor for race
*/
public Race(List<BoatInRace> boats, List<Leg> legs, RaceController controller, int scaleFactor) {
public Race(List<Boat> boats, List<Leg> legs, RaceController controller, int scaleFactor) {
this.startingBoats = FXCollections.observableArrayList(boats);
this.legs = legs;
@@ -54,14 +54,21 @@ public abstract class Race implements Runnable {
}
}
public Race(BoatInRace[] startingBoats, List<Leg> legs, RaceController controller, int scaleFactor) {
this(Arrays.asList(startingBoats), legs, controller, scaleFactor);
}
public Race(RaceDataSource raceData, RaceController controller, int scaleFactor) {
this(raceData.getBoats(), raceData.getLegs(), controller, scaleFactor);
}
/**
* @deprecated
* @param startingBoats
* @param legs
* @param controller
* @param scaleFactor
*/
public Race(Boat[] startingBoats, List<Leg> legs, RaceController controller, int scaleFactor) {
this(Arrays.asList(startingBoats), legs, controller, scaleFactor);
}
public abstract void initialiseBoats();
/**
@@ -75,9 +82,9 @@ public abstract class Race implements Runnable {
*
* @param boat Boat that the postion is to be updated for.
* @param timeElapsed Time that has elapse since the start of the the race.
* @see BoatInRace
* @see Boat
*/
protected abstract void checkPosition(BoatInRace boat, long timeElapsed);
protected abstract void checkPosition(Boat boat, long timeElapsed);
/**
* Updates the boat's gps coordinates
@@ -85,7 +92,7 @@ public abstract class Race implements Runnable {
* @param boat to be updated
* @param millisecondsElapsed time since last update
*/
protected abstract void updatePosition(BoatInRace boat, int millisecondsElapsed);
protected abstract void updatePosition(Boat boat, int millisecondsElapsed);
/**
* Runnable for the thread.
@@ -189,7 +196,7 @@ public abstract class Race implements Runnable {
System.setProperty("javafx.animation.fullspeed", "true");
for (BoatInRace boat : startingBoats) {
for (Boat boat : startingBoats) {
boat.setStarted(true);
}
@@ -205,7 +212,7 @@ public abstract class Race implements Runnable {
if (boatsFinished < startingBoats.size()) {
totalTimeElapsed = System.currentTimeMillis() - timeRaceStarted;
for (BoatInRace boat : startingBoats) {
for (Boat boat : startingBoats) {
if (boat != null && !boat.isFinished()) {
boat.addTrackPoint(boat.getCurrentPosition());
updatePosition(boat, Math.round(1000 / lastFPS) > 20 ? 15 : Math.round(1000 / lastFPS));
@@ -234,7 +241,7 @@ public abstract class Race implements Runnable {
*/
protected void updatePositions() {
FXCollections.sort(startingBoats, (a, b) -> b.getCurrentLeg().getLegNumber() - a.getCurrentLeg().getLegNumber());
for(BoatInRace boat: startingBoats) {
for(Boat boat: startingBoats) {
if(boat != null) {
boat.setPosition(Integer.toString(startingBoats.indexOf(boat) + 1));
if (boat.getCurrentLeg().getName().equals("DNF") || boat.getCurrentLeg().getLegNumber() == 0)
@@ -253,11 +260,11 @@ public abstract class Race implements Runnable {
/**
* Returns the boats that have started the race.
*
* @return ObservableList of BoatInRace class that participated in the race.
* @return ObservableList of Boat class that participated in the race.
* @see ObservableList
* @see BoatInRace
* @see Boat
*/
public ObservableList<BoatInRace> getStartingBoats() {
public ObservableList<Boat> getStartingBoats() {
return startingBoats;
}
}
visualiser/src/main/java/seng302/Model/RaceClock.java
+1
View File
@@ -57,6 +57,7 @@ public class RaceClock {
}
public String getTimeZone() {
System.out.println(zoneId.toString());
return zoneId.toString();
}
visualiser/src/main/java/seng302/Model/ResizableRaceCanvas.java
+30 -12
View File
@@ -21,12 +21,13 @@ import java.util.List;
public class ResizableRaceCanvas extends Canvas {
private GraphicsContext gc;
private RaceMap map;
private List<BoatInRace> boats;
private List<Boat> boats;
private boolean raceAnno = true;
private boolean annoName = true;
private boolean annoAbbrev = true;
private boolean annoSpeed = true;
private boolean annoPath = true;
private List<Color> colours;
private List<GPSCoordinate> raceBoundaries;
private List<Marker> markers;
double[] xpoints = {}, ypoints = {};
@@ -46,6 +47,7 @@ public class ResizableRaceCanvas extends Canvas {
this.raceBoundaries = raceData.getBoundary();
this.markers = raceData.getMarkers();
makeColours();
}
/**
@@ -53,7 +55,7 @@ public class ResizableRaceCanvas extends Canvas {
*
* @param boats in race
*/
public void setBoats(List<BoatInRace> boats) {
public void setBoats(List<Boat> boats) {
this.boats = boats;
}
@@ -81,9 +83,9 @@ public class ResizableRaceCanvas extends Canvas {
gc.fillOval(graphCoordinate.getX() - (d / 2), graphCoordinate.getY() - (d / 2), d, d);
}
public void displayBoat(BoatInRace boat, double angle) {
public void displayBoat(Boat boat, double angle, Color colour) {
GraphCoordinate pos = this.map.convertGPS(boat.getCurrentPosition());
Paint paint = boat.getColour();
Paint paint = colour;
double[] x = {pos.getX() - 6, pos.getX(), pos.getX() + 6};
double[] y = {pos.getY() + 12, pos.getY() - 12, pos.getY() + 12};
@@ -322,27 +324,29 @@ public class ResizableRaceCanvas extends Canvas {
* Draws boats while race in progress, when leg heading is set.
*/
public void updateBoats() {
int currentColour = 0;
// TODO Remove null when boats are ready
boats = null;
if (boats != null) {
for (BoatInRace boat : boats) {
for (Boat boat : boats) {
boolean finished = boat.getCurrentLeg().getName().equals("Finish") || boat.getCurrentLeg().getName().equals("DNF");
boolean isStart = boat.isStarted();
if (!finished && isStart) {
displayBoat(boat, boat.getHeading());
displayBoat(boat, boat.getHeading(), colours.get(currentColour));
GraphCoordinate wakeFrom = this.map.convertGPS(boat.getCurrentPosition());
GraphCoordinate wakeTo = this.map.convertGPS(boat.getWake());
displayLine(wakeFrom, wakeTo, boat.getColour());
displayLine(wakeFrom, wakeTo, colours.get(currentColour));
} else if (!isStart) {
displayBoat(boat, boat.getHeading());
displayBoat(boat, boat.getHeading(), colours.get(currentColour));
} else {
displayBoat(boat, 0);
displayBoat(boat, 0, colours.get(currentColour));
}
if (raceAnno)
displayText(boat.toString(), boat.getAbbrev(), boat.getVelocity(), this.map.convertGPS(boat.getCurrentPosition()));
if(boat.isTrackVisible()) drawTrack(boat);
drawTrack(boat, colours.get(currentColour));
currentColour = (currentColour + 1) % colours.size();
}
}
}
@@ -352,11 +356,11 @@ public class ResizableRaceCanvas extends Canvas {
* @param boat whose track is displayed
* @see seng302.Model.TrackPoint
*/
private void drawTrack(BoatInRace boat) {
private void drawTrack(Boat boat, Color colour) {
if (annoPath && raceAnno) {
for (TrackPoint point : boat.getTrack()) {
GraphCoordinate scaledCoordinate = this.map.convertGPS(point.getCoordinate());
Color boatColour = boat.getColour();
Color boatColour = colour;
gc.setFill(new Color(boatColour.getRed(), boatColour.getGreen(), boatColour.getBlue(), point.getAlpha()));
gc.fillOval(scaledCoordinate.getX(), scaledCoordinate.getY(), 5, 5);
}
@@ -381,6 +385,20 @@ public class ResizableRaceCanvas extends Canvas {
}
}
private void makeColours() {
colours = new ArrayList<Color>(Arrays.asList(
Color.BLUEVIOLET,
Color.BLACK,
Color.RED,
Color.ORANGE,
Color.DARKOLIVEGREEN,
Color.LIMEGREEN,
Color.PURPLE,
Color.DARKGRAY,
Color.YELLOW
));
}
/**
* Set the Canvas to resizable.
*
visualiser/src/main/java/seng302/RaceDataSource.java
+2 -1
View File
@@ -1,5 +1,6 @@
package seng302;
import seng302.Model.Boat;
import seng302.Model.BoatInRace;
import seng302.Model.Leg;
import seng302.Model.Marker;
@@ -11,7 +12,7 @@ import java.util.List;
* Created by connortaylorbrown on 19/04/17.
*/
public interface RaceDataSource {
List<BoatInRace> getBoats();
List<Boat> getBoats();
List<Leg> getLegs();
List<Marker> getMarkers();
List<GPSCoordinate> getBoundary();
visualiser/src/main/java/seng302/RaceXMLReader.java
+2 -2
View File
@@ -17,7 +17,7 @@ import java.util.List;
* @deprecated use {@link seng302.Mock.StreamedCourseXMLReader}
*/
public class RaceXMLReader extends XMLReader implements RaceDataSource {
private List<BoatInRace> boats = new ArrayList<>();
private List<Boat> boats = new ArrayList<>();
private Color[] colors = {Color.BLUEVIOLET, Color.BLACK, Color.RED, Color.ORANGE, Color.DARKOLIVEGREEN, Color.LIMEGREEN};//TODO make this established in xml or come up with a better system.
private List<Leg> legs = new ArrayList<>();
private GPSCoordinate mark, startPt1, startPt2, finishPt1, finishPt2, leewardPt1, leewardPt2, windwardPt1, windwardPt2;
@@ -269,7 +269,7 @@ public class RaceXMLReader extends XMLReader implements RaceDataSource {
return null;
}
public List<BoatInRace> getBoats() {
public List<Boat> getBoats() {
return boats;
}
visualiser/src/test/java/seng302/Model/ConstantVelocityRaceTest.java
+140 -140
View File
@@ -1,140 +1,140 @@
package seng302.Model;
import javafx.scene.paint.Color;
import org.geotools.referencing.GeodeticCalculator;
import org.junit.Test;
import seng302.Constants;
import seng302.GPSCoordinate;
import java.lang.reflect.Array;
import java.util.ArrayList;
import static org.junit.Assert.assertEquals;
/**
* Created by esa46 on 16/03/17.
*/
public class ConstantVelocityRaceTest {
Marker START_MARKER = new Marker(new GPSCoordinate(0, 0));
Marker END_MARKER = new Marker(new GPSCoordinate(10, 10));
Leg START_LEG = new Leg("Start", START_MARKER, END_MARKER, 0);
int ONE_HOUR = 3600000; //1 hour in milliseconds
private ArrayList<Leg> generateLegsArray() {
ArrayList<Leg> legs = new ArrayList<>();
legs.add(START_LEG);
return legs;
}
@Test
public void updatePositionChangesDistanceTravelled() {
ArrayList<Leg> legs = generateLegsArray();
BoatInRace boat = new BoatInRace("Test", 1, Color.ALICEBLUE, "tt");
boat.setCurrentLeg(legs.get(0));
boat.setDistanceTravelledInLeg(0);
BoatInRace[] boats = new BoatInRace[]{boat};
ConstantVelocityRace race = new ConstantVelocityRace(boats, legs, null, 1);
race.updatePosition(boat, ONE_HOUR);
assertEquals(boat.getDistanceTravelledInLeg(), boat.getVelocity(), 1e-8);
}
@Test
public void updatePositionHandlesNoChangeToDistanceTravelled() {
ArrayList<Leg> legs = generateLegsArray();
BoatInRace boat = new BoatInRace("Test", 0, Color.ALICEBLUE, "tt");
boat.setCurrentLeg(legs.get(0));
boat.setDistanceTravelledInLeg(0);
BoatInRace[] boats = new BoatInRace[]{boat};
ConstantVelocityRace race = new ConstantVelocityRace(boats, legs, null, 1);
race.updatePosition(boat, ONE_HOUR);
assertEquals(boat.getDistanceTravelledInLeg(), 0, 1e-8);
}
@Test
public void changesToDistanceTravelledAreAdditive() {
ArrayList<Leg> legs = generateLegsArray();
BoatInRace boat = new BoatInRace("Test", 5, Color.ALICEBLUE, "tt");
boat.setCurrentLeg(legs.get(0));
boat.setDistanceTravelledInLeg(50);
BoatInRace[] boats = new BoatInRace[]{boat};
ConstantVelocityRace race = new ConstantVelocityRace(boats, legs, null, 1);
race.updatePosition(boat, ONE_HOUR);
assertEquals(boat.getDistanceTravelledInLeg(), boat.getVelocity() + 50, 1e-8);
}
@Test
public void travelling10nmNorthGivesCorrectNewCoordinates() {
GPSCoordinate oldPos = new GPSCoordinate(0, 0);
GPSCoordinate newPos = ConstantVelocityRace.calculatePosition(oldPos, 10, 0);
GeodeticCalculator calc = new GeodeticCalculator();
calc.setStartingGeographicPoint(0, 0);
calc.setDirection(0, 10 * Constants.NMToMetersConversion);
assertEquals(newPos.getLongitude(), 0, 1e-8);
assertEquals(newPos.getLatitude(), calc.getDestinationGeographicPoint().getY(), 1e-8);
assertEquals(newPos.getLongitude(), calc.getDestinationGeographicPoint().getX(), 1e-8);
}
@Test
public void travelling10nmEastGivesCorrectNewCoordinates() {
GPSCoordinate oldPos = new GPSCoordinate(0, 0);
GPSCoordinate newPos = ConstantVelocityRace.calculatePosition(oldPos, 10, 90);
GeodeticCalculator calc = new GeodeticCalculator();
calc.setStartingGeographicPoint(0, 0);
calc.setDirection(90, 10 * Constants.NMToMetersConversion);
assertEquals(newPos.getLatitude(), 0, 1e-8);
assertEquals(newPos.getLatitude(), calc.getDestinationGeographicPoint().getY(), 1e-8);
assertEquals(newPos.getLongitude(), calc.getDestinationGeographicPoint().getX(), 1e-8);
}
@Test
public void travelling10nmWestGivesCorrectNewCoordinates() {
GPSCoordinate oldPos = new GPSCoordinate(0, 0);
GPSCoordinate newPos = ConstantVelocityRace.calculatePosition(oldPos, 10, -90);
GeodeticCalculator calc = new GeodeticCalculator();
calc.setStartingGeographicPoint(0, 0);
calc.setDirection(-90, 10 * Constants.NMToMetersConversion);
assertEquals(newPos.getLatitude(), 0, 1e-8);
assertEquals(newPos.getLatitude(), calc.getDestinationGeographicPoint().getY(), 1e-8);
assertEquals(newPos.getLongitude(), calc.getDestinationGeographicPoint().getX(), 1e-8);
}
@Test
public void travelling10nmSouthGivesCorrectNewCoordinates() {
GPSCoordinate oldPos = new GPSCoordinate(0, 0);
GPSCoordinate newPos = ConstantVelocityRace.calculatePosition(oldPos, 10, 180);
GeodeticCalculator calc = new GeodeticCalculator();
calc.setStartingGeographicPoint(0, 0);
calc.setDirection(180, 10 * Constants.NMToMetersConversion);
assertEquals(newPos.getLongitude(), 0, 1e-8);
assertEquals(newPos.getLatitude(), calc.getDestinationGeographicPoint().getY(), 1e-8);
assertEquals(newPos.getLongitude(), calc.getDestinationGeographicPoint().getX(), 1e-8);
}
}
//package seng302.Model;
//
//
//import javafx.scene.paint.Color;
//import org.geotools.referencing.GeodeticCalculator;
//import org.junit.Test;
//import seng302.Constants;
//import seng302.GPSCoordinate;
//
//import java.lang.reflect.Array;
//import java.util.ArrayList;
//
//import static org.junit.Assert.assertEquals;
//
///**
// * Created by esa46 on 16/03/17.
// */
//public class ConstantVelocityRaceTest {
//
// Marker START_MARKER = new Marker(new GPSCoordinate(0, 0));
// Marker END_MARKER = new Marker(new GPSCoordinate(10, 10));
// Leg START_LEG = new Leg("Start", START_MARKER, END_MARKER, 0);
//
// int ONE_HOUR = 3600000; //1 hour in milliseconds
//
//
// private ArrayList<Leg> generateLegsArray() {
// ArrayList<Leg> legs = new ArrayList<>();
// legs.add(START_LEG);
// return legs;
// }
//
// @Test
// public void updatePositionChangesDistanceTravelled() {
// ArrayList<Leg> legs = generateLegsArray();
// BoatInRace boat = new BoatInRace("Test", 1, Color.ALICEBLUE, "tt");
// boat.setCurrentLeg(legs.get(0));
// boat.setDistanceTravelledInLeg(0);
// BoatInRace[] boats = new BoatInRace[]{boat};
//
// ConstantVelocityRace race = new ConstantVelocityRace(boats, legs, null, 1);
//
// race.updatePosition(boat, ONE_HOUR);
// assertEquals(boat.getDistanceTravelledInLeg(), boat.getVelocity(), 1e-8);
// }
//
//
// @Test
// public void updatePositionHandlesNoChangeToDistanceTravelled() {
//
// ArrayList<Leg> legs = generateLegsArray();
// BoatInRace boat = new BoatInRace("Test", 0, Color.ALICEBLUE, "tt");
// boat.setCurrentLeg(legs.get(0));
// boat.setDistanceTravelledInLeg(0);
// BoatInRace[] boats = new BoatInRace[]{boat};
//
// ConstantVelocityRace race = new ConstantVelocityRace(boats, legs, null, 1);
//
// race.updatePosition(boat, ONE_HOUR);
// assertEquals(boat.getDistanceTravelledInLeg(), 0, 1e-8);
// }
//
// @Test
// public void changesToDistanceTravelledAreAdditive() {
//
// ArrayList<Leg> legs = generateLegsArray();
// BoatInRace boat = new BoatInRace("Test", 5, Color.ALICEBLUE, "tt");
// boat.setCurrentLeg(legs.get(0));
// boat.setDistanceTravelledInLeg(50);
// BoatInRace[] boats = new BoatInRace[]{boat};
//
// ConstantVelocityRace race = new ConstantVelocityRace(boats, legs, null, 1);
//
// race.updatePosition(boat, ONE_HOUR);
// assertEquals(boat.getDistanceTravelledInLeg(), boat.getVelocity() + 50, 1e-8);
// }
//
// @Test
// public void travelling10nmNorthGivesCorrectNewCoordinates() {
// GPSCoordinate oldPos = new GPSCoordinate(0, 0);
// GPSCoordinate newPos = ConstantVelocityRace.calculatePosition(oldPos, 10, 0);
//
// GeodeticCalculator calc = new GeodeticCalculator();
// calc.setStartingGeographicPoint(0, 0);
// calc.setDirection(0, 10 * Constants.NMToMetersConversion);
//
// assertEquals(newPos.getLongitude(), 0, 1e-8);
// assertEquals(newPos.getLatitude(), calc.getDestinationGeographicPoint().getY(), 1e-8);
// assertEquals(newPos.getLongitude(), calc.getDestinationGeographicPoint().getX(), 1e-8);
// }
//
//
// @Test
// public void travelling10nmEastGivesCorrectNewCoordinates() {
// GPSCoordinate oldPos = new GPSCoordinate(0, 0);
// GPSCoordinate newPos = ConstantVelocityRace.calculatePosition(oldPos, 10, 90);
//
// GeodeticCalculator calc = new GeodeticCalculator();
// calc.setStartingGeographicPoint(0, 0);
// calc.setDirection(90, 10 * Constants.NMToMetersConversion);
//
//
// assertEquals(newPos.getLatitude(), 0, 1e-8);
// assertEquals(newPos.getLatitude(), calc.getDestinationGeographicPoint().getY(), 1e-8);
// assertEquals(newPos.getLongitude(), calc.getDestinationGeographicPoint().getX(), 1e-8);
// }
//
//
// @Test
// public void travelling10nmWestGivesCorrectNewCoordinates() {
// GPSCoordinate oldPos = new GPSCoordinate(0, 0);
// GPSCoordinate newPos = ConstantVelocityRace.calculatePosition(oldPos, 10, -90);
//
// GeodeticCalculator calc = new GeodeticCalculator();
// calc.setStartingGeographicPoint(0, 0);
// calc.setDirection(-90, 10 * Constants.NMToMetersConversion);
//
//
// assertEquals(newPos.getLatitude(), 0, 1e-8);
// assertEquals(newPos.getLatitude(), calc.getDestinationGeographicPoint().getY(), 1e-8);
// assertEquals(newPos.getLongitude(), calc.getDestinationGeographicPoint().getX(), 1e-8);
// }
//
//
// @Test
// public void travelling10nmSouthGivesCorrectNewCoordinates() {
// GPSCoordinate oldPos = new GPSCoordinate(0, 0);
// GPSCoordinate newPos = ConstantVelocityRace.calculatePosition(oldPos, 10, 180);
//
// GeodeticCalculator calc = new GeodeticCalculator();
// calc.setStartingGeographicPoint(0, 0);
// calc.setDirection(180, 10 * Constants.NMToMetersConversion);
//
//
// assertEquals(newPos.getLongitude(), 0, 1e-8);
// assertEquals(newPos.getLatitude(), calc.getDestinationGeographicPoint().getY(), 1e-8);
// assertEquals(newPos.getLongitude(), calc.getDestinationGeographicPoint().getX(), 1e-8);
// }
//
//}
visualiser/src/test/java/seng302/Model/RaceXMLTest.java
+1 -1
View File
@@ -30,7 +30,7 @@ public class RaceXMLTest {
try {
RaceXMLReader raceXMLReader = new RaceXMLReader("raceXML/bermuda_AC35.xml", false);
raceXMLReader.readBoats();
List<BoatInRace> boats = raceXMLReader.getBoats();
List<Boat> boats = raceXMLReader.getBoats();
assertTrue(boats.size() == 6);
//test boat 1
assertEquals(boats.get(0).getName().getValue(), "ORACLE TEAM USA");