mirror of
https://github.com/michaelrausch/Party-Parrots-At-Sea.git
synced 2026-05-09 06:18:44 +00:00
Merge branch 'develop' into Story64_SailsAnimations
# Conflicts: # src/main/java/seng302/model/Yacht.java
This commit is contained in:
Kusal Ekanayake
@@ -4,12 +4,9 @@ import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import javafx.application.Platform;
|
||||
import javafx.collections.FXCollections;
|
||||
import javafx.collections.ObservableList;
|
||||
import seng302.gameServer.server.messages.BoatActionType;
|
||||
import seng302.model.Player;
|
||||
import seng302.model.Yacht;
|
||||
import seng302.gameServer.server.messages.BoatActionType;
|
||||
|
||||
/**
|
||||
* A Static class to hold information about the current state of the game (model)
|
||||
@@ -30,8 +27,6 @@ public class GameState implements Runnable {
|
||||
private static GameStages currentStage;
|
||||
private static long startTime;
|
||||
|
||||
// TODO: 26/07/17 cir27 - Super hackish fix until something more permanent can be made.
|
||||
private static ObservableList<String> observablePlayers = FXCollections.observableArrayList();
|
||||
private static Map<Player, String> playerStringMap = new HashMap<>();
|
||||
/*
|
||||
Ideally I would like to make this class an object instantiated by the server and given to
|
||||
@@ -60,7 +55,6 @@ public class GameState implements Runnable {
|
||||
yachts = new HashMap<>();
|
||||
|
||||
new Thread(this).start();
|
||||
|
||||
}
|
||||
|
||||
public static String getHostIpAddress() {
|
||||
@@ -71,20 +65,14 @@ public class GameState implements Runnable {
|
||||
return players;
|
||||
}
|
||||
|
||||
public static ObservableList<String> getObservablePlayers () {
|
||||
return observablePlayers;
|
||||
}
|
||||
|
||||
public static void addPlayer(Player player) {
|
||||
players.add(player);
|
||||
String playerText = player.getYacht().getSourceId() + " " + player.getYacht().getBoatName() + " " + player.getYacht().getCountry();
|
||||
Platform.runLater(() -> observablePlayers.add(playerText)); //Had to add this to handle javaFX window using array
|
||||
playerStringMap.put(player, playerText);
|
||||
}
|
||||
|
||||
public static void removePlayer(Player player) {
|
||||
players.remove(player);
|
||||
observablePlayers.remove(playerStringMap.get(player));
|
||||
playerStringMap.remove(player);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package seng302.gameServer.server.messages;
|
||||
|
||||
public class BoatLocationMessage extends Message {
|
||||
|
||||
private final int MESSAGE_SIZE = 56;
|
||||
|
||||
private long messageVersionNumber;
|
||||
@@ -28,6 +29,7 @@ public class BoatLocationMessage extends Message {
|
||||
|
||||
/**
|
||||
* Describes the location, altitude and sensor data from the boat.
|
||||
*
|
||||
* @param sourceId ID of the boat
|
||||
* @param sequenceNum Sequence number of the message
|
||||
* @param latitude The boats latitude
|
||||
@@ -35,7 +37,8 @@ public class BoatLocationMessage extends Message {
|
||||
* @param heading The boats heading
|
||||
* @param boatSpeed The boats speed
|
||||
*/
|
||||
public BoatLocationMessage(int sourceId, int sequenceNum, double latitude, double longitude, double heading, long boatSpeed){
|
||||
public BoatLocationMessage(int sourceId, int sequenceNum, double latitude, double longitude,
|
||||
double heading, long boatSpeed) {
|
||||
messageVersionNumber = 1;
|
||||
time = System.currentTimeMillis();
|
||||
this.sourceId = sourceId;
|
||||
@@ -94,6 +97,7 @@ public class BoatLocationMessage extends Message {
|
||||
|
||||
/**
|
||||
* Convert binary latitude or longitude to floating point number
|
||||
*
|
||||
* @param binaryPackedLatLon Binary packed lat OR lon
|
||||
* @return Floating point lat/lon
|
||||
*/
|
||||
@@ -103,6 +107,7 @@ public class BoatLocationMessage extends Message {
|
||||
|
||||
/**
|
||||
* Convert binary packed heading to floating point number
|
||||
*
|
||||
* @param binaryPackedHeading Binary packed heading
|
||||
* @return heading as a decimal
|
||||
*/
|
||||
@@ -112,6 +117,7 @@ public class BoatLocationMessage extends Message {
|
||||
|
||||
/**
|
||||
* Convert binary packed wind angle to floating point number
|
||||
*
|
||||
* @param binaryPackedWindAngle Binary packed wind angle
|
||||
* @return wind angle as a decimal
|
||||
*/
|
||||
@@ -121,6 +127,7 @@ public class BoatLocationMessage extends Message {
|
||||
|
||||
/**
|
||||
* Convert a latitude or longitude to a binary packed long
|
||||
*
|
||||
* @param latLon A floating point latitude/longitude
|
||||
* @return A binary packed lat/lon
|
||||
*/
|
||||
@@ -130,6 +137,7 @@ public class BoatLocationMessage extends Message {
|
||||
|
||||
/**
|
||||
* Convert a heading to a binary packed long
|
||||
*
|
||||
* @param heading A floating point heading
|
||||
* @return A binary packed heading
|
||||
*/
|
||||
@@ -139,6 +147,7 @@ public class BoatLocationMessage extends Message {
|
||||
|
||||
/**
|
||||
* Convert a wind angle to a binary packed long
|
||||
*
|
||||
* @param windAngle Floating point wind angle
|
||||
* @return A binary packed wind angle
|
||||
*/
|
||||
|
||||
@@ -1,137 +0,0 @@
|
||||
package seng302.gameServer.server.simulator;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Observable;
|
||||
import java.util.concurrent.ThreadLocalRandom;
|
||||
import seng302.model.mark.Mark;
|
||||
import seng302.gameServer.server.simulator.parsers.RaceParser;
|
||||
import seng302.model.GeoPoint;
|
||||
import seng302.utilities.GeoUtility;
|
||||
|
||||
public class Simulator extends Observable implements Runnable {
|
||||
|
||||
private List<Corner> course;
|
||||
private List<Boat> boats;
|
||||
private long lapse;
|
||||
private boolean isRaceStarted;
|
||||
|
||||
/**
|
||||
* Creates a simulator instance with given time lapse.
|
||||
* @param lapse time duration in millisecond.
|
||||
*/
|
||||
public Simulator(long lapse) {
|
||||
RaceParser rp = new RaceParser("/server_config/race.xml");
|
||||
course = rp.getCourse();
|
||||
boats = rp.getBoats();
|
||||
this.lapse = lapse;
|
||||
isRaceStarted = false;
|
||||
|
||||
setLegs();
|
||||
|
||||
// set start line's coordinate to boats
|
||||
Double startLat = course.get(0).getCompoundMark().getSubMark(1).getLat();
|
||||
Double startLng = course.get(0).getCompoundMark().getSubMark(1).getLng();
|
||||
for (Boat boat : boats) {
|
||||
boat.setLat(startLat);
|
||||
boat.setLng(startLng);
|
||||
boat.setLastPassedCorner(course.get(0));
|
||||
boat.setHeadingCorner(course.get(1));
|
||||
boat.setSpeed(ThreadLocalRandom.current().nextInt(40000, 60000 + 1));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
|
||||
int numOfFinishedBoats = 0;
|
||||
|
||||
while (numOfFinishedBoats < boats.size()) {
|
||||
|
||||
// if race has started, then boat should start to move.
|
||||
if (isRaceStarted) {
|
||||
for (Boat boat : boats) {
|
||||
numOfFinishedBoats += moveBoat(boat, lapse);
|
||||
}
|
||||
}
|
||||
|
||||
setChanged();
|
||||
notifyObservers(boats);
|
||||
|
||||
try {
|
||||
Thread.sleep(lapse);
|
||||
} catch (InterruptedException e) {
|
||||
System.out.println("[Simulator] interrupted exception ");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Moves a boat with given time duration.
|
||||
* @param boat the boat to be moved
|
||||
* @param duration the moving duration in milliseconds
|
||||
* @return 1 if the boat has reached the final line, otherwise return 0
|
||||
*/
|
||||
private int moveBoat(Boat boat, double duration) {
|
||||
if (boat.getHeadingCorner() != null) {
|
||||
|
||||
boat.move(boat.getLastPassedCorner().getBearingToNextCorner(), duration);
|
||||
|
||||
GeoPoint boatPos = new GeoPoint(boat.getLat(), boat.getLng());
|
||||
GeoPoint lastMarkPos = boat.getLastPassedCorner().getCompoundMark().getSubMark(1);
|
||||
|
||||
double distanceFromLastMark = GeoUtility.getDistance(boatPos, lastMarkPos);
|
||||
// if a boat passes its heading mark
|
||||
while (distanceFromLastMark >= boat.getLastPassedCorner().getDistanceToNextCorner()) {
|
||||
double compensateDistance = distanceFromLastMark - boat.getLastPassedCorner().getDistanceToNextCorner();
|
||||
boat.setLastPassedCorner(boat.getHeadingCorner());
|
||||
boat.setHeadingCorner(boat.getLastPassedCorner().getNextCorner());
|
||||
|
||||
// heading corner == null means boat has reached the final mark
|
||||
if (boat.getHeadingCorner() == null) {
|
||||
boat.setFinished(true);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// move compensate distance for the mark just passed
|
||||
GeoPoint pos = GeoUtility.getGeoCoordinate(
|
||||
boat.getLastPassedCorner().getCompoundMark().getSubMark(1),
|
||||
boat.getLastPassedCorner().getBearingToNextCorner(),
|
||||
compensateDistance);
|
||||
boat.setLat(pos.getLat());
|
||||
boat.setLng(pos.getLng());
|
||||
distanceFromLastMark = GeoUtility.getDistance(new GeoPoint(boat.getLat(), boat.getLng()),
|
||||
boat.getLastPassedCorner().getCompoundMark().getSubMark(1));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Link all the corners in the course list so that every corner knows its next
|
||||
* corner, as well as the distance and bearing to its next corner. However,
|
||||
* the last corner's heading is null, which means it is the final line.
|
||||
*/
|
||||
private void setLegs() {
|
||||
// get the bearing from one mark to the next heading mark
|
||||
for (int i = 0; i < course.size() - 1; i++) {
|
||||
|
||||
Mark mark1 = course.get(i).getCompoundMark().getSubMark(1);
|
||||
Mark mark2 = course.get(i + 1).getCompoundMark().getSubMark(1);
|
||||
course.get(i).setDistanceToNextCorner(GeoUtility.getDistance(mark1, mark2));
|
||||
|
||||
course.get(i).setNextCorner(course.get(i + 1));
|
||||
|
||||
course.get(i).setBearingToNextCorner(
|
||||
GeoUtility.getBearing(course.get(i).getCompoundMark().getSubMark(1),
|
||||
course.get(i + 1).getCompoundMark().getSubMark(1)));
|
||||
}
|
||||
}
|
||||
|
||||
public List<Boat> getBoats(){
|
||||
return boats;
|
||||
}
|
||||
|
||||
public void setRaceStarted(boolean raceStarted) {
|
||||
isRaceStarted = raceStarted;
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,5 @@
|
||||
package seng302.model;
|
||||
|
||||
import static seng302.utilities.GeoUtility.getGeoCoordinate;
|
||||
|
||||
import java.text.DateFormat;
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.ArrayList;
|
||||
@@ -14,6 +12,8 @@ import javafx.beans.property.ReadOnlyLongWrapper;
|
||||
import javafx.scene.paint.Color;
|
||||
import seng302.gameServer.GameState;
|
||||
import seng302.model.mark.CompoundMark;
|
||||
import seng302.model.mark.Mark;
|
||||
import seng302.utilities.GeoUtility;
|
||||
|
||||
/**
|
||||
* Yacht class for the racing boat.
|
||||
@@ -29,6 +29,8 @@ public class Yacht {
|
||||
void notifyLocation(Yacht yacht, double lat, double lon, double heading, double velocity, boolean sailIn);
|
||||
}
|
||||
|
||||
private static final Double ROUNDING_DISTANCE = 15d; // TODO: 3/08/17 wmu16 - Look into this value further
|
||||
|
||||
//BOTH AFAIK
|
||||
private String boatType;
|
||||
private Integer sourceId;
|
||||
@@ -38,12 +40,12 @@ public class Yacht {
|
||||
private String country;
|
||||
|
||||
private Long estimateTimeAtFinish;
|
||||
private Long timeTillNext;
|
||||
private Long lastMark;
|
||||
private Long markRoundTime;
|
||||
private Double distanceToNextMark;
|
||||
private Long timeTillNext;
|
||||
private CompoundMark nextMark;
|
||||
private Double heading;
|
||||
private Double lat;
|
||||
private Double lon;
|
||||
private Integer legNumber = 0;
|
||||
|
||||
//SERVER SIDE
|
||||
@@ -53,6 +55,11 @@ public class Yacht {
|
||||
private GeoPoint location;
|
||||
private Integer boatStatus;
|
||||
private Double velocity;
|
||||
//MARK ROUNDING INFO
|
||||
private GeoPoint lastLocation; //For purposes of mark rounding calculations
|
||||
private Boolean hasEnteredRoundingZone; //The distance that the boat must be from the mark to round
|
||||
private Boolean hasPassedFirstLine; //The line extrapolated from the next mark to the current mark
|
||||
private Boolean hasPassedSecondLine; //The line extrapolated from the last mark to the current mark
|
||||
|
||||
//CLIENT SIDE
|
||||
private List<YachtLocationListener> locationListeners = new ArrayList<>();
|
||||
@@ -73,8 +80,13 @@ public class Yacht {
|
||||
this.boatName = boatName;
|
||||
this.country = country;
|
||||
this.location = new GeoPoint(57.670341, 11.826856);
|
||||
this.lastLocation = location;
|
||||
this.heading = 120.0; //In degrees
|
||||
this.velocity = 0d; //in mms-1
|
||||
|
||||
this.hasEnteredRoundingZone = false;
|
||||
this.hasPassedFirstLine = false;
|
||||
this.hasPassedSecondLine = false;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -110,8 +122,36 @@ public class Yacht {
|
||||
}
|
||||
}
|
||||
|
||||
Double metersCovered = velocity * secondsElapsed;
|
||||
location = getGeoCoordinate(location, heading, metersCovered);
|
||||
//UPDATE BOAT LOCATION
|
||||
location = GeoUtility.getGeoCoordinate(location, heading, velocity * secondsElapsed);
|
||||
|
||||
//CHECK FOR MARK ROUNDING
|
||||
distanceToNextMark = calcDistanceToNextMark();
|
||||
if (distanceToNextMark < ROUNDING_DISTANCE) {
|
||||
hasEnteredRoundingZone = true;
|
||||
}
|
||||
|
||||
// TODO: 3/08/17 wmu16 - Implement line cross check here
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the distance to the next mark (closest of the two if a gate mark).
|
||||
*
|
||||
* @return A distance in metres. Returns -1 if there is no next mark
|
||||
*/
|
||||
public Double calcDistanceToNextMark() {
|
||||
if (nextMark == null) {
|
||||
return -1d;
|
||||
} else if (nextMark.isGate()) {
|
||||
Mark sub1 = nextMark.getSubMark(1);
|
||||
Mark sub2 = nextMark.getSubMark(2);
|
||||
Double distance1 = GeoUtility.getDistance(location, sub1);
|
||||
Double distance2 = GeoUtility.getDistance(location, sub2);
|
||||
return (distance1 < distance2) ? distance1 : distance2;
|
||||
} else {
|
||||
return GeoUtility.getDistance(location, nextMark.getSubMark(1));
|
||||
}
|
||||
}
|
||||
|
||||
public void adjustHeading(Double amount) {
|
||||
@@ -327,20 +367,21 @@ public class Yacht {
|
||||
return nextMark;
|
||||
}
|
||||
|
||||
public Double getLat() {
|
||||
return lat;
|
||||
public GeoPoint getLocation() {
|
||||
return location;
|
||||
}
|
||||
|
||||
public void setLat(Double lat) {
|
||||
this.lat = lat;
|
||||
}
|
||||
|
||||
public Double getLon() {
|
||||
return lon;
|
||||
}
|
||||
|
||||
public void setLon(Double lon) {
|
||||
this.lon = lon;
|
||||
/**
|
||||
* Sets the current location of the boat in lat and long whilst preserving the last location
|
||||
*
|
||||
* @param lat Latitude
|
||||
* @param lng Longitude
|
||||
*/
|
||||
public void setLocation(Double lat, Double lng) {
|
||||
lastLocation.setLat(location.getLat());
|
||||
lastLocation.setLng(location.getLng());
|
||||
location.setLat(lat);
|
||||
location.setLng(lng);
|
||||
}
|
||||
|
||||
public Double getHeading() {
|
||||
@@ -360,10 +401,6 @@ public class Yacht {
|
||||
return boatName;
|
||||
}
|
||||
|
||||
public GeoPoint getLocation() {
|
||||
return location;
|
||||
}
|
||||
|
||||
public void updateTimeSinceLastMarkProperty(long timeSinceLastMark) {
|
||||
this.timeSinceLastMarkProperty.set(timeSinceLastMark);
|
||||
}
|
||||
@@ -397,18 +434,18 @@ public class Yacht {
|
||||
this.velocity = velocity;
|
||||
}
|
||||
|
||||
public Boolean getClientSailsIn(){
|
||||
return clientSailsIn;
|
||||
|
||||
public Double getDistanceToNextMark() {
|
||||
return distanceToNextMark;
|
||||
}
|
||||
|
||||
public void updateLocation (double lat, double lon, double heading, double velocity) {
|
||||
this.lat = lat;
|
||||
this.lon = lon;
|
||||
public void updateLocation(double lat, double lng, double heading, double velocity) {
|
||||
setLocation(lat, lng);
|
||||
this.heading = heading;
|
||||
this.velocity = velocity;
|
||||
updateVelocityProperty(velocity);
|
||||
for (YachtLocationListener yll : locationListeners) {
|
||||
yll.notifyLocation(this, lat, lon, heading, velocity, clientSailsIn);
|
||||
yll.notifyLocation(this, lat, lng, heading, velocity, clientSailsIn);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -86,4 +86,46 @@ public class CompoundMark {
|
||||
public List<Mark> getMarks () {
|
||||
return marks;
|
||||
}
|
||||
|
||||
|
||||
// @Override
|
||||
// public boolean equals(Object other) {
|
||||
// if (other == null) {
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// if (!(other instanceof Mark)){
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// Mark otherMark = (Mark) other;
|
||||
//
|
||||
// if (otherMark.getLat() != getLat() || otherMark.getLongitude() != getLongitude()) {
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// if (otherMark.getCompoundMarkID() != getCompoundMarkID()){
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// if (otherMark.getId() != getId()){
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// if (!otherMark.getName().equals(name)){
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
// return true;
|
||||
// }
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
int hash = 0;
|
||||
for (Mark mark : marks) {
|
||||
hash += Double.hashCode(mark.getSourceID()) + Double.hashCode(mark.getLat())
|
||||
+ Double.hashCode(mark.getLng()) + mark.getName().hashCode();
|
||||
}
|
||||
return hash + getName().hashCode() + Integer.hashCode(getId());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,135 @@
|
||||
package seng302.model.mark;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import org.w3c.dom.Document;
|
||||
import org.xml.sax.InputSource;
|
||||
import org.xml.sax.SAXException;
|
||||
import seng302.model.stream.xml.generator.Race;
|
||||
import seng302.model.stream.xml.parser.RaceXMLData;
|
||||
import seng302.utilities.XMLGenerator;
|
||||
import seng302.utilities.XMLParser;
|
||||
|
||||
import javax.xml.parsers.DocumentBuilder;
|
||||
import javax.xml.parsers.DocumentBuilderFactory;
|
||||
import javax.xml.parsers.ParserConfigurationException;
|
||||
import java.io.IOException;
|
||||
import java.io.StringReader;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Class to hold the order of the marks in the race.
|
||||
*/
|
||||
public class MarkOrder {
|
||||
private List<Mark> raceMarkOrder;
|
||||
private Logger logger = LoggerFactory.getLogger(MarkOrder.class);
|
||||
|
||||
public MarkOrder(){
|
||||
loadRaceProperties();
|
||||
}
|
||||
|
||||
/**
|
||||
* @return An ordered list of marks in the race
|
||||
* OR null if the mark order could not be loaded
|
||||
*/
|
||||
public List<Mark> getMarkOrder(){
|
||||
if (raceMarkOrder == null){
|
||||
logger.warn("Race order accessed but not instantiated");
|
||||
return null;
|
||||
}
|
||||
|
||||
return Collections.unmodifiableList(raceMarkOrder);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the mark in the race after the previous mark
|
||||
* @param position The current race position
|
||||
* @return the next race position
|
||||
* OR null if there is no position
|
||||
*/
|
||||
public RacePosition getNextPosition(RacePosition position){
|
||||
Mark previousMark = position.getNextMark();
|
||||
Mark nextMark;
|
||||
|
||||
if (position.getPositionIndex() + 1 >= raceMarkOrder.size() - 1){
|
||||
RacePosition nextRacePosition = new RacePosition(raceMarkOrder.size() - 1, null, previousMark);
|
||||
nextRacePosition.setFinishingLeg();
|
||||
|
||||
return nextRacePosition;
|
||||
}
|
||||
|
||||
Integer nextPositionIndex = position.getPositionIndex() + 1;
|
||||
RacePosition nextRacePosition = new RacePosition(nextPositionIndex, raceMarkOrder.get(nextPositionIndex), previousMark);
|
||||
|
||||
return nextRacePosition;
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads the race order from an XML string
|
||||
* @param xml An AC35 RaceXML
|
||||
* @return An ordered list of marks in the race
|
||||
*/
|
||||
private List<Mark> loadRaceOrderFromXML(String xml){
|
||||
|
||||
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
|
||||
DocumentBuilder db;
|
||||
Document doc;
|
||||
|
||||
try {
|
||||
db = dbf.newDocumentBuilder();
|
||||
doc = db.parse(new InputSource(new StringReader(xml)));
|
||||
} catch (ParserConfigurationException | IOException | SAXException e) {
|
||||
logger.error("Failed to read generated race XML");
|
||||
return null;
|
||||
}
|
||||
|
||||
RaceXMLData data = XMLParser.parseRace(doc);
|
||||
|
||||
if (data != null){
|
||||
logger.debug("Loaded RaceXML for mark order");
|
||||
List<Corner> corners = data.getMarkSequence();
|
||||
Map<Integer, CompoundMark> marks = data.getCompoundMarks();
|
||||
List<Mark> course = new ArrayList<>();
|
||||
|
||||
for (Corner corner : corners){
|
||||
CompoundMark compoundMark = marks.get(corner.getCompoundMarkID());
|
||||
course.add(compoundMark.getMarks().get(0));
|
||||
}
|
||||
|
||||
return course;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The first position in the race
|
||||
*/
|
||||
public RacePosition getFirstPosition(){
|
||||
if (raceMarkOrder.size() > 0){
|
||||
return new RacePosition(-1, raceMarkOrder.get(0), null);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load the raceXML and mark order
|
||||
*/
|
||||
private void loadRaceProperties(){
|
||||
XMLGenerator generator = new XMLGenerator();
|
||||
|
||||
generator.setRace(new Race());
|
||||
|
||||
String raceXML = generator.getRaceAsXml();
|
||||
|
||||
if (raceXML == null){
|
||||
logger.error("Failed to generate raceXML (for race properties)");
|
||||
return;
|
||||
}
|
||||
raceMarkOrder = loadRaceOrderFromXML(raceXML);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package seng302.model.mark;
|
||||
|
||||
/**
|
||||
* Represents a boats position between two marks
|
||||
*/
|
||||
public class RacePosition {
|
||||
private Integer positionIndex;
|
||||
private Mark nextMark;
|
||||
private Mark previousMark;
|
||||
private Boolean isFinishingLeg;
|
||||
|
||||
public RacePosition(Integer positionIndex, Mark nextMark, Mark previousMark){
|
||||
this.positionIndex = positionIndex;
|
||||
this.nextMark = nextMark;
|
||||
this.previousMark = previousMark;
|
||||
isFinishingLeg = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The position of the boat (0...number of marks in race - 1)
|
||||
*/
|
||||
public Integer getPositionIndex(){
|
||||
return positionIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The mark the boat is heading to
|
||||
* will return NULL if this is the finishing legg
|
||||
*/
|
||||
public Mark getNextMark(){
|
||||
return nextMark;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The mark the boat is heading away from,
|
||||
* Will return NULL if this is the starting leg
|
||||
*/
|
||||
public Mark getPreviousMark(){
|
||||
return previousMark;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets a flag that this is the last leg in the race
|
||||
*/
|
||||
public void setFinishingLeg(){
|
||||
isFinishingLeg = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return true if this is the last leg in the race
|
||||
*/
|
||||
public boolean getIsFinishingLeg() {
|
||||
return isFinishingLeg;
|
||||
}
|
||||
}
|
||||
@@ -34,14 +34,12 @@ public class GeoUtility {
|
||||
*
|
||||
* @param p1 the first geographical position, start point
|
||||
* @param p2 the second geographical position, end point
|
||||
* @return the initial bearing in degree from p1 to p2, value range (0 ~ 360 deg.).
|
||||
* vertical up is 0 deg. horizontal right is 90 deg.
|
||||
* @return the initial bearing in degree from p1 to p2, value range (0 ~ 360 deg.). vertical up
|
||||
* is 0 deg. horizontal right is 90 deg.
|
||||
*
|
||||
* NOTE:
|
||||
* The final bearing will differ from the initial bearing by varying degrees
|
||||
* according to distance and latitude (if you were to go from say 35°N,45°E
|
||||
* (≈ Baghdad) to 35°N,135°E (≈ Osaka), you would start on a heading of 60°
|
||||
* and end up on a heading of 120°
|
||||
* NOTE: The final bearing will differ from the initial bearing by varying degrees according to
|
||||
* distance and latitude (if you were to go from say 35°N,45°E (≈ Baghdad) to 35°N,135°E (≈
|
||||
* Osaka), you would start on a heading of 60° and end up on a heading of 120°
|
||||
*/
|
||||
public static Double getBearing(GeoPoint p1, GeoPoint p2) {
|
||||
return (Math.toDegrees(getBearingRad(p1, p2)) + 360.0) % 360.0;
|
||||
@@ -52,28 +50,27 @@ public class GeoUtility {
|
||||
*
|
||||
* @param p1 the first geographical position, start point
|
||||
* @param p2 the second geographical position, end point
|
||||
* @return the initial bearing in degree from p1 to p2, value range (0 ~ 360 deg.).
|
||||
* vertical up is 0 deg. horizontal right is 90 deg.
|
||||
* @return the initial bearing in degree from p1 to p2, value range (0 ~ 360 deg.). vertical up
|
||||
* is 0 deg. horizontal right is 90 deg.
|
||||
*
|
||||
* NOTE:
|
||||
* The final bearing will differ from the initial bearing by varying degrees
|
||||
* according to distance and latitude (if you were to go from say 35°N,45°E
|
||||
* (≈ Baghdad) to 35°N,135°E (≈ Osaka), you would start on a heading of 60°
|
||||
* and end up on a heading of 120°
|
||||
* NOTE: The final bearing will differ from the initial bearing by varying degrees according to
|
||||
* distance and latitude (if you were to go from say 35°N,45°E (≈ Baghdad) to 35°N,135°E (≈
|
||||
* Osaka), you would start on a heading of 60° and end up on a heading of 120°
|
||||
*/
|
||||
public static Double getBearingRad(GeoPoint p1, GeoPoint p2) {
|
||||
double dLon = Math.toRadians(p2.getLng() - p1.getLng());
|
||||
|
||||
double y = Math.sin(dLon) * Math.cos(Math.toRadians(p2.getLat()));
|
||||
double x = Math.cos(Math.toRadians(p1.getLat())) * Math.sin(Math.toRadians(p2.getLat()))
|
||||
- Math.sin(Math.toRadians(p1.getLat())) * Math.cos(Math.toRadians(p2.getLat())) * Math.cos(dLon);
|
||||
- Math.sin(Math.toRadians(p1.getLat())) * Math.cos(Math.toRadians(p2.getLat())) * Math
|
||||
.cos(dLon);
|
||||
|
||||
return Math.atan2(y, x);
|
||||
}
|
||||
|
||||
/**
|
||||
* Given an existing point in lat/lng, distance in (in meter) and bearing
|
||||
* (in degrees), calculates the new lat/lng.
|
||||
* Given an existing point in lat/lng, distance in (in meter) and bearing (in degrees),
|
||||
* calculates the new lat/lng.
|
||||
*
|
||||
* @param origin the original position within lat / lng
|
||||
* @param bearing the bearing in degree, from original position to the new position
|
||||
@@ -96,12 +93,13 @@ public class GeoUtility {
|
||||
return new GeoPoint(Math.toDegrees(endLat), Math.toDegrees(endLng));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Performs the line function on two points of a line and a test point to test which side of the line that point is
|
||||
* on. If the return value is
|
||||
* return 1, then the point is on one side of the line,
|
||||
* return -1 then the point is on the other side of the line
|
||||
* return 0 then the point is exactly on the line.
|
||||
* Performs the line function on two points of a line and a test point to test which side of the
|
||||
* line that point is on. If the return value is return 1, then the point is on one side of the
|
||||
* line, return -1 then the point is on the other side of the line return 0 then the point is
|
||||
* exactly on the line.
|
||||
*
|
||||
* @param linePoint1 One point of the line
|
||||
* @param linePoint2 Second point of the line
|
||||
* @param testPoint The point to test with this line
|
||||
@@ -120,25 +118,26 @@ public class GeoUtility {
|
||||
|
||||
if (result > 0) {
|
||||
return 1;
|
||||
}
|
||||
else if (result < 0) {
|
||||
} else if (result < 0) {
|
||||
return -1;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Given a point and a vector (angle and vector length) Will create a new point, that vector away from the origin
|
||||
* point
|
||||
* Given a point and a vector (angle and vector length) Will create a new point, that vector
|
||||
* away from the origin point
|
||||
*
|
||||
* @param originPoint The point with which to use as the base for our vector addition
|
||||
* @param angleInDeg (DEGREES) The angle at which our new point is being created (in degrees!)
|
||||
* @param vectorLength The length out on this angle from the origin point to create the new point
|
||||
* @param vectorLength The length out on this angle from the origin point to create the new
|
||||
* point
|
||||
* @return a Point2D
|
||||
*/
|
||||
public static Point2D makeArbitraryVectorPoint(Point2D originPoint, Double angleInDeg, Double vectorLength) {
|
||||
public static Point2D makeArbitraryVectorPoint(Point2D originPoint, Double angleInDeg,
|
||||
Double vectorLength) {
|
||||
|
||||
Double endPointX = originPoint.getX() + vectorLength * Math.cos(Math.toRadians(angleInDeg));
|
||||
Double endPointY = originPoint.getY() + vectorLength * Math.sin(Math.toRadians(angleInDeg));
|
||||
@@ -146,4 +145,42 @@ public class GeoUtility {
|
||||
return new Point2D(endPointX, endPointY);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Define vector v1 = p1 - p0 to v2 = p2- p0. This function returns the difference of bearing
|
||||
* from v1 to v2. For example, if bearing of v1 is 30 deg and bearing of v2 is 90 deg, then the
|
||||
* difference is 60 deg.
|
||||
*
|
||||
* @param bearing1 the bearing of v1
|
||||
* @param bearing2 the bearing of v2
|
||||
* @return the difference of bearing from v1 to v2
|
||||
*/
|
||||
private static double getBearingDiff(double bearing1, double bearing2) {
|
||||
return ((360 - bearing1) + bearing2) % 360;
|
||||
}
|
||||
|
||||
/**
|
||||
* Given three geo points to form a triangle, the method returns true if the fourth point is
|
||||
* inside the triangle
|
||||
*
|
||||
* @param v1 the vertex of the triangle
|
||||
* @param v2 the vertex of the triangle
|
||||
* @param v3 the vertex of the triangle
|
||||
* @param point the point to be tested
|
||||
* @return true if the fourth point is inside the triangle
|
||||
*/
|
||||
public static boolean isPointInTriangle(GeoPoint v1, GeoPoint v2, GeoPoint v3, GeoPoint point) {
|
||||
// true, if diff of bearing from (v1->v2) to (v1->p) is less than 180 deg
|
||||
boolean sideFlag = getBearingDiff(getBearing(v1, v2), getBearing(v1, point)) < 180;
|
||||
|
||||
if ((getBearingDiff(getBearing(v2, v3), getBearing(v2, point)) < 180) != sideFlag) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ((getBearingDiff(getBearing(v3, v1), getBearing(v3, point)) < 180) != sideFlag) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,35 +0,0 @@
|
||||
//package seng302;
|
||||
//
|
||||
//import org.junit.Test;
|
||||
//import seng302.model.Boat;
|
||||
//
|
||||
//import static org.junit.Assert.assertEquals;
|
||||
//
|
||||
///**
|
||||
// * Unit test for the Team class.
|
||||
// */
|
||||
//public class BoatTest {
|
||||
//
|
||||
// @Test
|
||||
// public void testBoatCreation() {
|
||||
// Boat boat1 = new Boat("Team 1");
|
||||
// assertEquals(boat1.getTeamName(), "Team 1");
|
||||
// assertEquals(boat1.getVelocity(), (double) 10.0, 1e-15);
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testChangeTeamName() {
|
||||
// Boat boat1 = new Boat("Team 1");
|
||||
// boat1.setTeamName("Team 2");
|
||||
// assertEquals(boat1.getTeamName(), "Team 2");
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testSetVelocity() {
|
||||
// Boat boat1 = new Boat("Team 1", 29.0, "", 100);
|
||||
// assertEquals(boat1.getVelocity(), (double) 29.0, 1e-15);
|
||||
//
|
||||
// boat1.setVelocity(12.0);
|
||||
// assertEquals(boat1.getVelocity(), (double)12.0, 1e-15);
|
||||
// }
|
||||
//}
|
||||
@@ -1,67 +0,0 @@
|
||||
package seng302;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNotEquals;
|
||||
|
||||
import javafx.geometry.Point2D;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import seng302.utilities.GeoUtility;
|
||||
|
||||
/**
|
||||
* Test Class for the GeometryUtils class
|
||||
* Created by wmu16 on 24/05/17.
|
||||
*/
|
||||
public class TestGeoUtils {
|
||||
|
||||
//Line in x = y
|
||||
private Point2D linePoint1 = new Point2D(0, 0);
|
||||
private Point2D linePoint2 = new Point2D(1, 1);
|
||||
|
||||
//Point below x = y
|
||||
private Point2D arbitraryPoint1 = new Point2D(1, 0);
|
||||
|
||||
//Point above x = y
|
||||
private Point2D arbitraryPoint2 = new Point2D(0, 1);
|
||||
|
||||
//Point on x = y
|
||||
private Point2D arbitraryPoint3 = new Point2D(2, 2);
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testLineFunction() {
|
||||
|
||||
Integer lineFunctionResult1 = GeoUtility.lineFunction(linePoint1, linePoint2, arbitraryPoint1);
|
||||
Integer lineFunctionResult2 = GeoUtility.lineFunction(linePoint1, linePoint2, arbitraryPoint2);
|
||||
Integer lineFunctionResult3 = GeoUtility.lineFunction(linePoint1, linePoint2, arbitraryPoint3);
|
||||
|
||||
//Point1 and Point2 are on opposite sides
|
||||
assertEquals(Math.abs(lineFunctionResult1), Math.abs(lineFunctionResult2));
|
||||
assertNotEquals(lineFunctionResult1, lineFunctionResult2);
|
||||
|
||||
//Point3 is on the line
|
||||
assertEquals((long) lineFunctionResult3, 0L);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMakeArbitraryVectorPoint() {
|
||||
|
||||
//Make a point (1,0) from point (0,0)
|
||||
Point2D newPoint = GeoUtility.makeArbitraryVectorPoint(linePoint1, 0d, 1d);
|
||||
Point2D expected = new Point2D(1,0);
|
||||
|
||||
assertEquals(expected.getX(), newPoint.getX(), 1E-6);
|
||||
assertEquals(expected.getY(), newPoint.getY(), 1E-6);
|
||||
|
||||
newPoint = GeoUtility.makeArbitraryVectorPoint(linePoint1, 90d, 1d);
|
||||
expected = new Point2D(0, 1);
|
||||
|
||||
assertEquals(expected.getX(), newPoint.getX(), 1E-6);
|
||||
assertEquals(expected.getY(), newPoint.getY(), 1E-6);
|
||||
}
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
package seng302.gameServer.server.simulator;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
import seng302.model.GeoPoint;
|
||||
import seng302.utilities.GeoUtility;
|
||||
|
||||
/**
|
||||
* To test methods in GeoUtility.
|
||||
* Created by Haoming on 28/04/17.
|
||||
*/
|
||||
public class GeoUtilityTest {
|
||||
|
||||
private GeoPoint p1 = new GeoPoint(57.670333, 11.827833);
|
||||
private GeoPoint p2 = new GeoPoint(57.671524, 11.844495);
|
||||
private GeoPoint p3 = new GeoPoint(57.670822, 11.843392);
|
||||
private GeoPoint p4 = new GeoPoint(25.694829, 98.392049);
|
||||
|
||||
private double toleranceRate = 0.01;
|
||||
|
||||
@Test
|
||||
public void getDistance() throws Exception {
|
||||
double expected, actual;
|
||||
|
||||
actual = GeoUtility.getDistance(p1, p2);
|
||||
expected = 1000;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getDistance(p1, p3);
|
||||
expected = 927;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getDistance(p2, p4);
|
||||
expected = 7430180;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getBearing() throws Exception {
|
||||
double expected, actual;
|
||||
|
||||
actual = GeoUtility.getBearing(p1, p2);
|
||||
expected = 82;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getBearing(p1, p3);
|
||||
expected = 86;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getBearing(p2, p4);
|
||||
expected = 78;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getGeoCoordinate() throws Exception {
|
||||
GeoPoint expected, actual;
|
||||
|
||||
actual = GeoUtility.getGeoCoordinate(p1, 82.0, 1000.0);
|
||||
expected = p2;
|
||||
assertEquals(expected.getLat(), actual.getLat(), expected.getLat() * toleranceRate);
|
||||
assertEquals(expected.getLng(), actual.getLng(), expected.getLng() * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getGeoCoordinate(p1, 86.0, 927.0);
|
||||
expected = p3;
|
||||
assertEquals(expected.getLat(), actual.getLat(), expected.getLat() * toleranceRate);
|
||||
assertEquals(expected.getLng(), actual.getLng(), expected.getLng() * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getGeoCoordinate(p2, 78.0, 7430180.0);
|
||||
expected = p4;
|
||||
assertEquals(expected.getLat(), actual.getLat(), expected.getLat() * toleranceRate);
|
||||
assertEquals(expected.getLng(), actual.getLng(), expected.getLng() * toleranceRate);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
package seng302.model;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import seng302.model.mark.CompoundMark;
|
||||
import seng302.model.mark.Mark;
|
||||
|
||||
/**
|
||||
* Use this link to test geo distances
|
||||
* http://www.csgnetwork.com/gpsdistcalc.html
|
||||
* Created by wmu16 on 3/08/17.
|
||||
*/
|
||||
public class YachtTest {
|
||||
|
||||
private Yacht yacht;
|
||||
private CompoundMark compoundMark;
|
||||
private Double toleranceRatio = 0.01;
|
||||
private GeoPoint p1 = new GeoPoint(57.670333, 11.827833);
|
||||
private GeoPoint p2 = new GeoPoint(57.671524, 11.844495);
|
||||
private GeoPoint p3 = new GeoPoint(57.670822, 11.843392);
|
||||
private GeoPoint p4 = new GeoPoint(25.694829, 98.392049);
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
yacht = new Yacht("Yacht",
|
||||
0,
|
||||
"0",
|
||||
"WillIsCool",
|
||||
"HaomingIsOk",
|
||||
"NZL");
|
||||
|
||||
yacht.setLocation(57.670333, 11.827833);
|
||||
|
||||
compoundMark = new CompoundMark(0, "HaomingsMark");
|
||||
Mark subMark1 = new Mark("H", 57.671524, 11.844495, 0);
|
||||
Mark subMark2 = new Mark("H", 57.670822, 11.843392, 0);
|
||||
compoundMark.addSubMarks(subMark1, subMark2);
|
||||
|
||||
yacht.setNextMark(compoundMark);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDistanceToNextMark() {
|
||||
Double actual, expected;
|
||||
actual = yacht.calcDistanceToNextMark();
|
||||
expected = 927d;
|
||||
assertEquals(expected, actual, expected * toleranceRatio);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -1,45 +0,0 @@
|
||||
//package seng302.model.mark;
|
||||
//
|
||||
//import static org.junit.Assert.assertEquals;
|
||||
//import static org.junit.Assert.assertTrue;
|
||||
//
|
||||
//import org.junit.Before;
|
||||
//import org.junit.Test;
|
||||
//
|
||||
///**
|
||||
// * Created by Haoming on 17/3/17.
|
||||
// */
|
||||
//public class MarkTest {
|
||||
//
|
||||
// private SingleMark singleMark1;
|
||||
// private SingleMark singleMark2;
|
||||
// private GateMark gateMark;
|
||||
//
|
||||
// @Before
|
||||
// public void setUp() throws Exception {
|
||||
// this.singleMark1 = new SingleMark("testMark_SM1", 12.23234, -34.342, 1, 0);
|
||||
// this.singleMark2 = new SingleMark("testMark_SM2", 12.23239, -34.352, 2, 1);
|
||||
// this.gateMark = new GateMark("testMark_GM", MarkType.OPEN_GATE, singleMark1, singleMark2, singleMark1.getLatitude(), singleMark2.getLongitude(), 2);
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void getName() throws Exception {
|
||||
// assertEquals("testMark_SM1", this.singleMark1.getName());
|
||||
// assertEquals("testMark_GM", this.gateMark.getName());
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void getMarkType() throws Exception {
|
||||
// assertTrue(this.singleMark2.getMarkType() == MarkType.SINGLE_MARK);
|
||||
// assertTrue(this.gateMark.getMarkType() == MarkType.OPEN_GATE);
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void getMarkContent() throws Exception {
|
||||
// assertEquals(12.23234, this.singleMark1.getLatitude(), 1e-10);
|
||||
// assertEquals(-34.342, this.singleMark1.getLongitude(), 1e-10);
|
||||
// assertEquals("testMark_SM1", this.gateMark.getSingleMark1().getName());
|
||||
// assertEquals(-34.352, this.gateMark.getSingleMark2().getLongitude(), 1e-10);
|
||||
// }
|
||||
//
|
||||
//}
|
||||
@@ -0,0 +1,83 @@
|
||||
package seng302.models;
|
||||
|
||||
import org.junit.AfterClass;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
import seng302.model.mark.Mark;
|
||||
import seng302.model.mark.MarkOrder;
|
||||
import seng302.model.mark.RacePosition;
|
||||
|
||||
import static junit.framework.TestCase.assertEquals;
|
||||
import static junit.framework.TestCase.assertTrue;
|
||||
|
||||
public class MarkOrderTest {
|
||||
private static MarkOrder markOrder;
|
||||
|
||||
@BeforeClass
|
||||
public static void setup(){
|
||||
markOrder = new MarkOrder();
|
||||
}
|
||||
|
||||
/**
|
||||
* Test to ensure marks are loaded from XML
|
||||
*/
|
||||
@Test
|
||||
public void testMarkOrderLoadedFromXML(){
|
||||
assertTrue(markOrder != null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if .getNextMark() returns null if it is called with the final mark in the race
|
||||
*/
|
||||
@Test
|
||||
public void testNextMarkAtEnd(){
|
||||
// There are no marks in the XML, therefore this can't be tested
|
||||
if (markOrder.getMarkOrder().size() == 0){
|
||||
return;
|
||||
}
|
||||
|
||||
Mark lastMark = markOrder.getMarkOrder().get(markOrder.getMarkOrder().size() - 1);
|
||||
Integer lastIndex = markOrder.getMarkOrder().size() - 1;
|
||||
|
||||
RacePosition lastRacePosition = new RacePosition(lastIndex, lastMark, null);
|
||||
|
||||
assertEquals(null, markOrder.getNextPosition(lastRacePosition).getNextMark());
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if .getNextMark() method returns the next mark in the race
|
||||
*/
|
||||
@Test
|
||||
public void testNextMark(){
|
||||
// There are not enough marks for this to be tested
|
||||
if (markOrder.getMarkOrder().size() < 2){
|
||||
return;
|
||||
}
|
||||
|
||||
RacePosition firstRacePos = new RacePosition(0, markOrder.getMarkOrder().get(0), null);
|
||||
|
||||
assertEquals(markOrder.getMarkOrder().get(1).getName(), markOrder.getNextPosition(firstRacePos).getNextMark().getName());
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if a whole race can be completed
|
||||
*/
|
||||
@Test
|
||||
public void testMarkSequence(){
|
||||
RacePosition current = markOrder.getFirstPosition();
|
||||
|
||||
while (!current.getIsFinishingLeg()){
|
||||
|
||||
current = markOrder.getNextPosition(current);
|
||||
|
||||
if (current.getIsFinishingLeg()){
|
||||
assertEquals(null, current.getNextMark());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void tearDown(){
|
||||
markOrder = null;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
package seng302.utilities;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNotEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import javafx.geometry.Point2D;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import seng302.model.GeoPoint;
|
||||
import seng302.utilities.GeoUtility;
|
||||
|
||||
/**
|
||||
* To test methods in GeoUtility.
|
||||
* Use this site to calculate distances
|
||||
* https://rechneronline.de/geo-coordinates/#distance
|
||||
* Created by Haoming on 28/04/17.
|
||||
*/
|
||||
public class GeoUtilityTest {
|
||||
|
||||
|
||||
//Line in x = y
|
||||
private Point2D linePoint1 = new Point2D(0, 0);
|
||||
private Point2D linePoint2 = new Point2D(1, 1);
|
||||
|
||||
private Point2D arbitraryPoint1 = new Point2D(1, 0); //Point below x = y
|
||||
private Point2D arbitraryPoint2 = new Point2D(0, 1); //Point above x = y
|
||||
private Point2D arbitraryPoint3 = new Point2D(2, 2); //Point on x = y
|
||||
|
||||
private GeoPoint p1 = new GeoPoint(57.670333, 11.827833);
|
||||
private GeoPoint p2 = new GeoPoint(57.671524, 11.844495);
|
||||
private GeoPoint p3 = new GeoPoint(57.670822, 11.843392);
|
||||
private GeoPoint p4 = new GeoPoint(25.694829, 98.392049);
|
||||
private GeoPoint p5 = new GeoPoint(57.671829, 11.842049);
|
||||
|
||||
private double toleranceRate = 0.01;
|
||||
|
||||
|
||||
@Test
|
||||
public void getBearing() throws Exception {
|
||||
double expected, actual;
|
||||
|
||||
actual = GeoUtility.getBearing(p1, p2);
|
||||
expected = 82;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getBearing(p1, p3);
|
||||
expected = 86;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getBearing(p2, p4);
|
||||
expected = 78;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getGeoCoordinate() throws Exception {
|
||||
GeoPoint expected, actual;
|
||||
|
||||
actual = GeoUtility.getGeoCoordinate(p1, 82.0, 1000.0);
|
||||
expected = p2;
|
||||
assertEquals(expected.getLat(), actual.getLat(), expected.getLat() * toleranceRate);
|
||||
assertEquals(expected.getLng(), actual.getLng(), expected.getLng() * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getGeoCoordinate(p1, 86.0, 927.0);
|
||||
expected = p3;
|
||||
assertEquals(expected.getLat(), actual.getLat(), expected.getLat() * toleranceRate);
|
||||
assertEquals(expected.getLng(), actual.getLng(), expected.getLng() * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getGeoCoordinate(p2, 78.0, 7430180.0);
|
||||
expected = p4;
|
||||
assertEquals(expected.getLat(), actual.getLat(), expected.getLat() * toleranceRate);
|
||||
assertEquals(expected.getLng(), actual.getLng(), expected.getLng() * toleranceRate);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testGetDistance() throws Exception {
|
||||
double expected, actual;
|
||||
|
||||
actual = GeoUtility.getDistance(p1, p2);
|
||||
expected = 1000;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getDistance(p1, p3);
|
||||
expected = 927;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
|
||||
actual = GeoUtility.getDistance(p2, p4);
|
||||
expected = 7430180;
|
||||
assertEquals(expected, actual, expected * toleranceRate);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLineFunction() {
|
||||
|
||||
Integer lineFunctionResult1 = GeoUtility
|
||||
.lineFunction(linePoint1, linePoint2, arbitraryPoint1);
|
||||
Integer lineFunctionResult2 = GeoUtility
|
||||
.lineFunction(linePoint1, linePoint2, arbitraryPoint2);
|
||||
Integer lineFunctionResult3 = GeoUtility
|
||||
.lineFunction(linePoint1, linePoint2, arbitraryPoint3);
|
||||
|
||||
//Point1 and Point2 are on opposite sides
|
||||
assertEquals(Math.abs(lineFunctionResult1), Math.abs(lineFunctionResult2));
|
||||
assertNotEquals(lineFunctionResult1, lineFunctionResult2);
|
||||
|
||||
//Point3 is on the line
|
||||
assertEquals((long) lineFunctionResult3, 0L);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMakeArbitraryVectorPoint() {
|
||||
|
||||
//Make a point (1,0) from point (0,0)
|
||||
Point2D newPoint = GeoUtility.makeArbitraryVectorPoint(linePoint1, 0d, 1d);
|
||||
Point2D expected = new Point2D(1, 0);
|
||||
|
||||
assertEquals(expected.getX(), newPoint.getX(), 1E-6);
|
||||
assertEquals(expected.getY(), newPoint.getY(), 1E-6);
|
||||
|
||||
newPoint = GeoUtility.makeArbitraryVectorPoint(linePoint1, 90d, 1d);
|
||||
expected = new Point2D(0, 1);
|
||||
|
||||
assertEquals(expected.getX(), newPoint.getX(), 1E-6);
|
||||
assertEquals(expected.getY(), newPoint.getY(), 1E-6);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsPointInTriangle() {
|
||||
GeoPoint v1 = new GeoPoint(57.670333, 11.842833);
|
||||
GeoPoint v2 = new GeoPoint(57.671524, 11.844495);
|
||||
GeoPoint v3 = new GeoPoint(57.671829, 11.842049);
|
||||
GeoPoint p1 = new GeoPoint(57.670822, 11.843192); // inside triangle
|
||||
GeoPoint p2 = new GeoPoint(57.670892, 11.843642); // outside triangle
|
||||
|
||||
// benchmark test. 100,000 calculations for 0.336 seconds
|
||||
// long startTime = System.nanoTime();
|
||||
// for (int i = 0; i < 100000; i++) {
|
||||
// assertTrue(GeoUtility.isPointInTriangle(v1, v2, v3, p1));
|
||||
// }
|
||||
// System.out.println((System.nanoTime() - startTime) / 1000000000.0);
|
||||
|
||||
// test for different orders of vertices, which should not affect the result
|
||||
assertTrue(GeoUtility.isPointInTriangle(v2, v1, v3, p1));
|
||||
assertTrue(GeoUtility.isPointInTriangle(v3, v1, v2, p1));
|
||||
|
||||
assertFalse(GeoUtility.isPointInTriangle(v1, v2, v3, p2));
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user