continued class PathFinderStrategy

src/main/java/ch/zhaw/pm2/racetrack/strategy/PathFinderStrategy.java

@@ -1,5 +1,7 @@
 package ch.zhaw.pm2.racetrack.strategy;
 
+import ch.zhaw.pm2.racetrack.Game;
+import ch.zhaw.pm2.racetrack.InvalidTrackFormatException;
 import ch.zhaw.pm2.racetrack.PositionVector;
 import ch.zhaw.pm2.racetrack.Track;
 
@@ -10,53 +12,74 @@ import java.util.List;
 
 public class PathFinderStrategy implements MoveStrategy{
     private ArrayList<tryOutPaths> possiblePaths;
-    private Track track;
+    private Game game;
-    List<PositionVector.Direction> directions = Arrays.asList(PositionVector.Direction.values());
+    private boolean foundPath = false;
+    private List<PositionVector.Direction> directions = Arrays.asList(PositionVector.Direction.values());
+    private ArrayList<PositionVector.Direction> directionToTake = new ArrayList<>();
+    private int currentMove = 0;
 
-    public PathFinderStrategy(Track track, int carIndex) {
+    public PathFinderStrategy(Game game, int carIndex) {
-        this.track = track;
+        this.game = game;
         possiblePaths = new ArrayList<>();
+        calculatePaths();
+        try {
+            getDirections();
+        } catch (InvalidTrackFormatException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void calculatePaths() {
+        for (int i = 0; i < 50; i++) {
+            if(foundPath){
+                break;
             }
 
-    private void test(){
             ArrayList<tryOutPaths> temporary = new ArrayList<>();
             Iterator<tryOutPaths> it = possiblePaths.iterator();
 
-        while(it.hasNext()) {
+            while (it.hasNext()) {
                 tryOutPaths current = it.next();
                 if (!current.isFeasible()) {
                     it.remove();
-            }
+                } else {
-            else {
                     for (PositionVector.Direction direction : directions) {
                         temporary.add(current);
-                    if (temporary.get(temporary.size() - 1).takeDirection(direction)){
+                        if (temporary.get(temporary.size() - 1).takeDirection(direction)) {
-                    break;
+                            foundPath = true;
                         }
                     }
                 }
             }
-        //ab hier zu löschen
-        for (tryOutPaths paths : possiblePaths){
-            for (PositionVector.Direction direction : directions) {
-                temporary.add(paths);
-                temporary.get(temporary.size() - 1).takeDirection(direction);
-            }
-        }
-        //bis hier löschen
             possiblePaths.clear();
             possiblePaths.addAll(temporary);
         }
+    }
+
+    private void getDirections() throws InvalidTrackFormatException {
+        if(foundPath){
+            for (tryOutPaths path: possiblePaths) {
+                if (path.isFinished()){
+                    directionToTake = path.getDirectionsTaken();
+                }
+            }
+        } else {
+          throw new InvalidTrackFormatException();
+        }
+    }
 
     @Override
     public PositionVector.Direction nextMove() {
-        return null;
+        PositionVector.Direction direction = directionToTake.get(currentMove);
+        currentMove++;
+        return direction;
     }
 
     public class tryOutPaths {
         ArrayList<PositionVector.Direction>  directionsTaken = new ArrayList<>();
         PositionVector currentPosition;
         Track track;
+
         private boolean feasible;
         private boolean finished;
         public tryOutPaths(Track track){
@@ -81,5 +104,13 @@ public class PathFinderStrategy implements MoveStrategy{
                 return false;
             }
         }
+
+        public ArrayList<PositionVector.Direction> getDirectionsTaken(){
+            return directionsTaken;
+        }
+
+        public boolean isFinished(){
+            return finished;
+        }
     }
 }