follower/challenge_points.txt

@@ -0,0 +1,19 @@
+(X:40, Y:22)
+(X:43, Y:22)
+(X:46, Y:21)
+(X:48, Y:19)
+(X:48, Y:17)
+(X:46, Y:15)
+(X:41, Y:13)
+(X:41, Y:10)
+(X:46, Y:9)
+(X:49, Y:4)
+(X:40, Y:2)
+(X:30, Y:2)
+(X:21, Y:3)
+(X:16, Y:7)
+(X:13, Y:10)
+(X:14, Y:14)
+(X:11, Y:19)
+(X:13, Y:22)
+(X:24, Y:22)

src/main/java/ch/zhaw/pm2/racetrack/Game.java

@@ -44,32 +44,38 @@ public class Game implements GameSpecification {
             moveStrategies.add("Path Follow Move Strategy");
             for (int i = 0; i < track.getCarCount(); i++) {
                 Car car = track.getCar(i);
-                while (car.getMoveStrategy() == null) {
+                MoveStrategy moveStrategy = null;
+                while (moveStrategy == null) {
+                    String filePath;
                     int moveStrategie = userInterface.selectOption(
                         "Select Strategy for Car " + i + " (" + track.getCarId(i) + ")", moveStrategies);
                     switch (moveStrategie + 1) {
                         case 1:
-                            selectMoveStrategy(car, new DoNotMoveStrategy());
+                            moveStrategy = new DoNotMoveStrategy();
                             break;
                         case 2:
-                            selectMoveStrategy(car, new UserMoveStrategy(userInterface, i, track.getCarId(i)));
+                            moveStrategy = new UserMoveStrategy(userInterface, i, track.getCarId(i));
                             break;
                         case 3:
-                            String path = ".\\moves\\" + selectedTrack.getName().split("\\.")[0] + "-car-" + track.getCar(i).getID() + ".txt";
+                            filePath = ".\\moves\\" + selectedTrack.getName().split("\\.")[0] + "-car-" + track.getCar(i).getID() + ".txt";
                             try {
-                                MoveStrategy moveStrategy = new MoveListStrategy(path);
+                                moveStrategy = new MoveListStrategy(filePath);
-                                selectMoveStrategy(car, moveStrategy);
                             } catch (FileNotFoundException e) {
-                                userInterface.printInformation("There is no MoveList implemented. Choose another Strategy!");
+                                userInterface.printInformation("There is no Move-List implemented. Choose another Strategy!");
                             }
                             //TODO: Backslash kompatibel für Linux
                             break;
                         case 4:
-                            //TODO: add Arguments
+                            filePath = ".\\follower\\" + selectedTrack.getName().split("\\.")[0] + "_points.txt";
-                            selectMoveStrategy(car, new PathFollowerMoveStrategy());
+                            try {
+                                moveStrategy = new PathFollowerMoveStrategy(filePath, track.getCarPos(i));
+                            } catch (FileNotFoundException e) {
+                                userInterface.printInformation("There is no Point-List implemented. Choose another Strategy!");
+                            }
                             break;
                     }
                 }
+                selectMoveStrategy(car, moveStrategy);
             }
             return true;
         } else {

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

@@ -25,9 +25,9 @@ public class MoveListStrategy implements MoveStrategy {
         Direction[] directions = Direction.values();
         while (scanner.hasNextLine()) {
             String line = scanner.nextLine();
-            for (Direction dir : directions) {
+            for (Direction direction : directions) {
-                if (dir.toString().equals(line)) {
+                if (direction.toString().equals(line)) {
-                    moveList.add(dir);
+                    moveList.add(direction);
                     break;
                 }
             }

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

@@ -1,15 +1,126 @@
 package ch.zhaw.pm2.racetrack.strategy;
 
+import ch.zhaw.pm2.racetrack.PositionVector;
 import ch.zhaw.pm2.racetrack.PositionVector.Direction;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Scanner;
+
 /**
  * The PathFollowerMoveStrategy class determines the next move based on a file containing points on a path.
  */
 public class PathFollowerMoveStrategy implements MoveStrategy {
 
+    /**
+     * The current Position of the car.
+     */
+    private PositionVector currentPosition;
+    /**
+     * The current Velocity of the car.
+     */
+    private PositionVector currentVelocity;
+    /**
+     * List of all points on the path.
+     */
+    private ArrayList<PositionVector> pointList;
+    /**
+     * The index of the next point on the path.
+     */
+    private int pointer;
+
+    /**
+     * Constructor to create a new PathFollowerMoveStrategy for a car.
+     * @param path The location where the file is saved
+     * @param startPosition The start position of the car
+     * @throws FileNotFoundException If the file with the given path does not exist.
+     */
+    public PathFollowerMoveStrategy(String path, PositionVector startPosition) throws FileNotFoundException {
+        pointList = new ArrayList<>();
+        pointer = 0;
+        readFile(new File(path));
+        currentPosition = startPosition;
+        currentVelocity = new PositionVector(0, 0);
+    }
+
+    /**
+     * Method to read the given File and add the points to the pointList
+     * @param trackFile the File Object which should be read
+     * @throws FileNotFoundException If the file with the given path does not exist.
+     */
+    public void readFile(File trackFile) throws FileNotFoundException {
+        Scanner scanner = new Scanner(new FileInputStream(trackFile), "UTF-8");
+        while (scanner.hasNextLine()) {
+            String line = scanner.nextLine();
+            String[] coordinates = line.split("(\\(X:|, Y:|\\))");
+            pointList.add(new PositionVector(Integer.parseInt(coordinates[1]), Integer.parseInt(coordinates[2])));
+        }
+    }
+
+    /**
+     * Method to select the direction for the next move.
+     * @return The direction for the next move. null if there are no points left in the list.
+     */
     @Override
     public Direction nextMove() {
-        // TODO: implementation
+        // if no more points in the list --> return null
-        throw new UnsupportedOperationException();
+        if (pointer >= pointList.size()) {
+            return null;
+        }
+
+        // increase pointer variable if the next point is reached.
+        if (pointList.get(pointer).equals(currentPosition)) {
+            pointer ++;
+        }
+
+        // calculate Vector from current Position to next Point
+        PositionVector movementVector = new PositionVector(pointList.get(pointer).getX() - currentPosition.getX(), pointList.get(pointer).getY() - currentPosition.getY());
+
+        // select acceleration for X
+        int accelerationX;
+        if((movementVector.getX() == 0 && currentVelocity.getX() > 0) || //reduce velocity to 0 if the destination coordinate is reached
+            (movementVector.getX() > 0 && movementVector.getX()/2.0 <= currentVelocity.getX()) || //increase velocity
+            (movementVector.getX() < 0 && movementVector.getX()/2.0 < currentVelocity.getX())){ //reduce velocity
+                accelerationX = -1;
+        } else if((movementVector.getX() == 0 && currentVelocity.getX() < 0) || //reduce velocity to 0 if the destination coordinate is reached
+            (movementVector.getX() > 0 && movementVector.getX()/2.0 > currentVelocity.getX()) || //increase velocity
+            (movementVector.getX() < 0 && movementVector.getX()/2.0 >= currentVelocity.getX())) { //reduce velocity
+                accelerationX = 1;
+        }
+        else { //no acceleration
+            accelerationX = 0;
+        }
+
+        // select acceleration for Y
+        int accelerationY;
+        if((movementVector.getY() == 0 && currentVelocity.getY() > 0) || //reduce velocity to 0 if the destination coordinate is reached
+            (movementVector.getY() > 0 && movementVector.getY()/2.0 <= currentVelocity.getY()) || //increase velocity
+            (movementVector.getY() < 0 && movementVector.getY()/2.0 < currentVelocity.getY())){ //reduce velocity
+                accelerationY = -1;
+        } else if((movementVector.getY() == 0 && currentVelocity.getY() < 0) || //reduce velocity to 0 if the destination coordinate is reached
+            (movementVector.getY() > 0 && movementVector.getY()/2.0 > currentVelocity.getY()) || //increase velocity
+            (movementVector.getY() < 0 && movementVector.getY()/2.0 >= currentVelocity.getY())) { //reduce velocity
+                accelerationY = 1;
+        }
+        else { //no acceleration
+            accelerationY = 0;
+        }
+
+        //update current Velocity and current Position with the selected acceleration
+        currentVelocity = new PositionVector(currentVelocity.getX() + accelerationX, currentVelocity.getY() + accelerationY);
+        currentPosition = new PositionVector(currentPosition.getX() + currentVelocity.getX(), currentPosition.getY() + currentVelocity.getY());
+
+        //Find Direction for acceleration
+        PositionVector acceleration = new PositionVector(accelerationX, accelerationY);
+        Direction[] directions = Direction.values();
+        for (Direction direction : directions) {
+            if (direction.vector.equals(acceleration)) {
+                return direction;
+            }
+        }
+    return null;
+
     }
 }