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/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