WIP: Implemented basic mark rounding algorithm.

Removed RacePosition class. Instead marks are just grabbed from the mark order class when necessary.
No marks are stored as an attribute in the yacht class but the 'currentMarkSeqID' which is used to get current, and surrounding marks.
Works for all marks in between but not including starting and finishing gate as no angle can be made with them. Still to work out how to implement this

 #story[1124]

src/test/java/seng302/model/YachtTest.java

@@ -38,17 +38,19 @@ public class YachtTest {
         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);
-    }
+    //This will no longer work as we cant set the next mark any more as we no longer hold it in
+    //yacht class as an attribute
+
+//    @Test
+//    public void testDistanceToNextMark() {
+//        Double actual, expected;
+//        actual = yacht.calcDistanceToNextMark();
+//        expected = 927d;
+//        assertEquals(expected, actual, expected * toleranceRatio);
+//    }
 
 
 }

src/test/java/seng302/models/MarkOrderTest.java

@@ -3,19 +3,22 @@ package seng302.models;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Test;
+import seng302.model.mark.CompoundMark;
 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.assertFalse;
 import static junit.framework.TestCase.assertTrue;
 
 public class MarkOrderTest {
     private static MarkOrder markOrder;
+    private static Integer currentSeqID;
 
     @BeforeClass
     public static void setup(){
         markOrder = new MarkOrder();
+        currentSeqID = 0;
     }
 
     /**
@@ -26,54 +29,39 @@ public class MarkOrderTest {
         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;
-        }
+    public void testIsLastMark() {
+        currentSeqID = 0;
+        assertFalse(markOrder.isLastMark(currentSeqID));
 
-        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());
+        currentSeqID = markOrder.getMarkOrder().size() - 1;
+        assertTrue(markOrder.isLastMark(currentSeqID));
     }
 
-    /**
-     * 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;
-        }
+    public void testGetNextMark() {
+        currentSeqID = 4;
+        CompoundMark nextMark = markOrder.getMarkOrder().get(4 + 1);
+        assertEquals(nextMark, markOrder.getNextMark(currentSeqID));
 
-        RacePosition firstRacePos = new RacePosition(0, markOrder.getMarkOrder().get(0), null);
-
-        assertEquals(markOrder.getMarkOrder().get(1).getName(), markOrder.getNextPosition(firstRacePos).getNextMark().getName());
+        currentSeqID = 3;
+        nextMark = markOrder.getMarkOrder().get(3 + 1);
+        assertEquals(nextMark, markOrder.getNextMark(currentSeqID));
     }
 
-    /**
-     * Test if a whole race can be completed
-     */
     @Test
-    public void testMarkSequence(){
-        RacePosition current = markOrder.getFirstPosition();
+    public void testGetCurrentMark() {
+        currentSeqID = 0;
+        CompoundMark currentMark = markOrder.getMarkOrder().get(0);
+        assertEquals(currentMark, markOrder.getCurrentMark(0));
+    }
 
-        while (!current.getIsFinishingLeg()){
-
-            current = markOrder.getNextPosition(current);
-
-            if (current.getIsFinishingLeg()){
-                assertEquals(null, current.getNextMark());
-            }
-        }
+    @Test
+    public void testGetPreviousMark() {
+        currentSeqID = 1;
+        CompoundMark prevMark = markOrder.getMarkOrder().get(0);
+        assertEquals(prevMark, markOrder.getPreviousMark(currentSeqID));
     }
 
     @AfterClass