gamePhase() prevent null direction

-added Klassendiagramm
-create Constructor InvalidTrackFormatException

Klassendiagramm.drawio

@@ -0,0 +1 @@
+<mxfile host="Electron" modified="2022-03-22T17:46:19.706Z" agent="5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/16.5.1 Chrome/96.0.4664.110 Electron/16.0.7 Safari/537.36" etag="blTsmpdlGFIXdx0F82xm" version="16.5.1" type="device"><diagram id="C5RBs43oDa-KdzZeNtuy" name="Page-1">7Vtbd6I6GP01PraLi7c+qr3MzOn0OGNPe16jRMgxEE+Itc6vny8QQExVaGVorWt1rZKPkED2zpedDTbsgf98w9Hc+84cTBuW4Tw37MuGZZnwB/9kZBVHOu1mHHA5cVSlLDAiv7AKGiq6IA4OcxUFY1SQeT44YUGAJyIXQ5yzZb7alNF8r3PkYi0wmiCqRx+JI7w42rU6WfwLJq6X9Gy2L+IzPkoqqycJPeSw5VrIvmrYA86YiI/85wGmcvCScXn8unqkt7P2zbcf4f/on/5f93cPZ3Fj12UuSR+B40C8uulfs+n1l4fmf//Oh9c/lsZNb/ztTF1iPCG6UOM1xDxkgXpisUqGMVwSn6IASv0pC8RInYFB6CNK3ACOJ3B3mEPgCXNBAIGeOiHYHKITj1DnFq3YQj5DKNBklpT6HuPkFzSLKJwyIQCnuVBkstq5GiN5JYQNiHIcQp1hMjBmGrpFoVB1JoxSNA/JOLphWcVH3CVBnwnB/KQhtggc7KhSinRUEJzNUu7I6wvCoWCTo4Gf18io4LnBzMeCr6CKOttVaKiZ1lLFZUZbs61i3jpl7a6aLmqquGnLaWc/YWqhwIUhSHuz7Hx3ZrNgf4BHrjtEAfYACdyXgxiukxAO1h40C0XULEFTU6PpHfKxRlIYZ7FGSIqnYisdwzmakMC9jepcNrPIT/WkMsTg2imNqOARx8FBRBWBBIrZJPkxZyQQ0VC0+vAHAzYwzluNFtzQAMpmVoY/WZ2LAQuAVYhE9MFA1SWWdH2BWDsn7X5irfKIlUV2nUg5SMviZ+lpxmOBJOPdwh9D0jg2JHfkE0/4VB1WhXfLqhlvW8P7ykdEXtZzHMjQ4QnwgwLe6dYMeFMDXEOYkkg9qNEwX1xZ98DvA5CyuQTve0mHyzNT44Stc8J+AX+KxpgOWUgEYbJ9Htfd4EVdWds0msVQ3bH8vwnUlp61F3zioVAmbhBdMxje6OgI53NloJp15+a2hupILBz5mAU1v3HS/JVpfrtbreg37Vf2V4Po72wn6rHKxoJZp12YZe9lA9DVsOzB3UvrxjK+w0pydEgeVA+Wxrv2DcDFSQ8eHNSiIr8qOWjqZuFXSPzGFaARrbSWcc9kOeBMtnZkM3pdAjWrwrhbd6I2davtBssVd4R9EiAuAb9HM6w7xB8d36ogrV/xJzewKxvjwOnJty1QGlMmxXYfQkqNm0ZcvCY0Wbn2yOX88ocdFydTB9MxW15lgX4UgBMJU0qL7ZDBrhTvhwy2Fy4usJmTd7sT2JeA5JgiQZ7yL512aPOhJG6myy0jr8stw843ET+kumr9LU/ZhuJR0Bo6mFOvW39DzqY4DJku108bzOo3mLb5yh1fx9hL4hc2mHazQHed97HBNHXXcoQoUhn3E65t6eT9OBtLUzcpNfQ++06jPKxF94+VbTV0k/JTKZYEsXctWTYXls4rJcvmCmV1Nu6lasmiG43b3lKeBEv1gqW1oSAKf5Zi7lhjtguWVivf3bv+DEa3UUeCY6y/uvksgqVTmF3vRrDo1uiAiOOTnAc1wMvjXLsDnnw1mpurkB1OQB8W6No/fbF0xxSEvVzELWPAnBPgBwa88Gcx1SGu+6kDGBNxhMZB3VjbrxRjh8Na9zM1kD+9v1Ae11ZBGVaVwWDp1t8DQOQc4wJdHYrt2jOx7v79vRDzhXQXevJV5a2cBydECyN6UXu+Lef8sXk01uW8vdQWNOt3+tTY7jX6Eiz3On0KZ0mlnIuibuiNpp+98b2ieWHlmyhq+m26PFpDW0w/raGzzRdOG+2w6TTElfiGlu4bGufnCfAZXSMvbi0R7Ek7Y+XIxWt4H01mbsTfAaOMw/mAZf6jMrut4jkhmV/q55bqthrpjxyL+3Rnb2RUQsw/BpdunhXHKtFPHxWsw8z+5JPcPw6d7plReAq5wKOt3ueaHN9EVVfBRQz8VKPvxrqUif5GYmgE2MaV4uvExWGYknyevmHiv4UrUMx+bB1Xz36ybl/9Bg==</diagram></mxfile>

build.gradle

@@ -44,7 +44,7 @@ version = '2022.1'
 
 application {
     // Define the main class for the application.
-    mainClass = 'ch.zhaw.pm2.racetrack.ConsoleApp'
+    mainClass = 'ch.zhaw.pm2.racetrack.Main'
 }
 
 run {

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

@@ -1,10 +1,7 @@
 package ch.zhaw.pm2.racetrack;
 
 import ch.zhaw.pm2.racetrack.given.GameSpecification;
-import ch.zhaw.pm2.racetrack.strategy.DoNotMoveStrategy;
-import ch.zhaw.pm2.racetrack.strategy.MoveListStrategy;
-import ch.zhaw.pm2.racetrack.strategy.PathFollowerMoveStrategy;
-import ch.zhaw.pm2.racetrack.strategy.UserMoveStrategy;
+import ch.zhaw.pm2.racetrack.strategy.*;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -21,7 +18,7 @@ import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
 public class Game implements GameSpecification {
     public static final int NO_WINNER = -1;
     private Track track;
-    int currentCarIndex;
+    private int currentCarIndex;
 
     UserInterface userInterface;
 
@@ -30,54 +27,86 @@ public class Game implements GameSpecification {
     }
 
 
-    public boolean initPhase() throws InvalidTrackFormatException, FileNotFoundException {
+    public boolean initPhase() throws InvalidTrackFormatException {
         File folder = new File("tracks");
         File[] listOfFiles = folder.listFiles();
-        if(listOfFiles.length > 0) {
+        if (listOfFiles.length > 0) {
             List<String> tracks = new ArrayList<>();
-            for(File file : listOfFiles){
+            for (File file : listOfFiles) {
                 tracks.add(file.getName());
             }
             File selectedTrack = listOfFiles[userInterface.selectOption("Select Track file", tracks)];
-            try {
-                track = new Track(selectedTrack);
-            } catch (FileNotFoundException | PositionVectorNotValid e) {
-                e.printStackTrace();
-            }
+            selectTrack(selectedTrack);
             List<String> moveStrategies = new ArrayList<>();
             moveStrategies.add("Do not move Strategy");
             moveStrategies.add("User Move Strategy");
             moveStrategies.add("Move List Strategy");
             moveStrategies.add("Path Follow Move Strategy");
-            for(int i = 0; i < track.getCarCount() ; i++ ) {
+            for (int i = 0; i < track.getCarCount(); i++) {
+                Car car = track.getCar(i);
+                while (car.getMoveStrategy() == null) {
                     int moveStrategie = userInterface.selectOption(
                         "Select Strategy for Car " + i + " (" + track.getCarId(i) + ")", moveStrategies);
-                switch (moveStrategie + 1) { //TODO: set Movestrategy with method in Track
+                    switch (moveStrategie + 1) {
                         case 1:
-                        track.getCar(i).setMoveStrategy(new DoNotMoveStrategy()); //TODO: add Arguments
+                            selectMoveStrategy(car, new DoNotMoveStrategy());
                             break;
                         case 2:
-                        track.getCar(i).setMoveStrategy(new UserMoveStrategy(userInterface, i, track.getCarId(i))); //TODO: add Arguments
+                            selectMoveStrategy(car, new UserMoveStrategy(userInterface, i, track.getCarId(i)));
                             break;
                         case 3:
-                        track.getCar(i).setMoveStrategy(new MoveListStrategy()); //TODO: add Arguments
+                            String path = ".\\moves\\" + selectedTrack.getName().split("\\.")[0] + "-car-" + track.getCar(i).getID() + ".txt";
+                            try {
+                                MoveStrategy moveStrategy = new MoveListStrategy(path);
+                                selectMoveStrategy(car, moveStrategy);
+                            } catch (FileNotFoundException e) {
+                                userInterface.printInformation("There is no MoveList implemented. Choose another Strategy!");
+                            }
+                            //TODO: Backslash kompatibel für Linux
                             break;
                         case 4:
-                        track.getCar(i).setMoveStrategy(new PathFollowerMoveStrategy()); //TODO: add Arguments
+                            //TODO: add Arguments
+                            selectMoveStrategy(car, new PathFollowerMoveStrategy());
                             break;
                     }
                 }
+            }
             return true;
-        }
-        else{
+        } else {
             userInterface.printInformation("No Trackfile found!");
             return false;
         }
     }
 
+    /**
+     * The functionality was taken out of init to automate testing
+     *
+     * @param selectedTrack
+     */
+    Track selectTrack(File selectedTrack) {
+        try {
+            track = new Track(selectedTrack);
+            return track;
+        } catch (FileNotFoundException | PositionVectorNotValid | InvalidTrackFormatException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * The functionality was taken out of init to automate testing
+     *
+     * @param car      to set the MoveStrategy
+     * @param strategy The movestrategy to set
+     */
+    void selectMoveStrategy(Car car, MoveStrategy strategy) {
+        car.setMoveStrategy(strategy);
+    }
+
     /**
      * Return the index of the current active car.
      * Car indexes are zero-based, so the first car is 0, and the last car is getCarCount() - 1.
+     *
      * @return The zero-based number of the current car
      */
     @Override
@@ -87,6 +116,7 @@ public class Game implements GameSpecification {
 
     /**
      * Get the id of the specified car.
+     *
      * @param carIndex The zero-based carIndex number
      * @return A char containing the id of the car
      */
@@ -97,6 +127,7 @@ public class Game implements GameSpecification {
 
     /**
      * Get the position of the specified car.
+     *
      * @param carIndex The zero-based carIndex number
      * @return A PositionVector containing the car's current position
      */
@@ -107,6 +138,7 @@ public class Game implements GameSpecification {
 
     /**
      * Get the velocity of the specified car.
+     *
      * @param carIndex The zero-based carIndex number
      * @return A PositionVector containing the car's current velocity
      */
@@ -117,14 +149,17 @@ public class Game implements GameSpecification {
 
     /**
      * Return the winner of the game. If the game is still in progress, returns NO_WINNER.
+     *
      * @return The winning car's index (zero-based, see getCurrentCar()), or NO_WINNER if the game is still in progress
      */
     @Override
     public int getWinner() {
-        List<Car> cars = track.getCars();
-        for (Car car: cars) {
-            if(car.getWinPoints() == 1){
-                return car.getID();
+        if (onlyOneCarLeft()) {
+            return currentCarIndex;
+        }
+        for (int i = 0; i < track.getCarCount(); i++) {
+            if (track.getCar(i).getWinPoints() == 1) {
+                return i;
             }
         }
         return NO_WINNER;
@@ -158,37 +193,46 @@ public class Game implements GameSpecification {
      */
     @Override
     public void doCarTurn(Direction acceleration) throws PositionVectorNotValid {
-        // TODO: implementation
         track.getCar(currentCarIndex).accelerate(acceleration);
 
         PositionVector crashPosition = null;
-        List<PositionVector> positionList  = calculatePath(track.getCarPos(currentCarIndex),track.getCar(currentCarIndex).nextPosition());
-        //TODO: check if Method calculatePath contains endposition
-        for(PositionVector location : positionList) { //todo: check if order must be reversed
-            if(willCarCrash(currentCarIndex, location)) {
-                crashPosition = location;
+        List<PositionVector> positionList = calculatePath(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition());
+        for (int i = 0; i < positionList.size(); i++) {
+            if (willCarCrash(currentCarIndex, positionList.get(i))) {
+                if (i == 0) {
+                    crashPosition = track.getCarPos(currentCarIndex);
+                } else {
+                    crashPosition = positionList.get(i - 1);
+                }
+                break;
             }
         }
-        if(crashPosition != null) {
+        if (crashPosition != null) {
             track.carDoesCrash(currentCarIndex, crashPosition);
-        }
-        else {
-            track.moveCar(currentCarIndex);
+        } else {
             calculateWinner(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition(), currentCarIndex);
+            track.moveCar(currentCarIndex);
         }
     }
 
-    public int gamePhase() throws PositionVectorNotValid {
-        while (getWinner() == NO_WINNER) {
+    public String gamePhase() throws PositionVectorNotValid {
+        while (carsMoving() && getWinner() == NO_WINNER) {
             userInterface.printTrack(track);
-            Direction direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
-            doCarTurn(direction);
-            if(allCarsCrashed()) {
-                return NO_WINNER;
+            Direction direction;
+            direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
+            if (direction == null) {
+                track.getCar(currentCarIndex).setMoveStrategy(new DoNotMoveStrategy());
+                direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
             }
+            doCarTurn(direction);
             switchToNextActiveCar();
         }
-        return getWinner();
+        userInterface.printTrack(track);
+        int indexWinner = getWinner();
+        if (indexWinner == NO_WINNER) {
+            return null;
+        }
+        return String.valueOf(track.getCar(indexWinner).getID());
     }
 
     /**
@@ -199,9 +243,8 @@ public class Game implements GameSpecification {
         do {
             if ((currentCarIndex + 1) == track.getCarCount()) {
                 currentCarIndex = 0;
-            }
-            else {
-                currentCarIndex ++;
+            } else {
+                currentCarIndex++;
             }
         } while (track.getCar(currentCarIndex).isCrashed());
         // TODO: evtl andere Kapselung
@@ -215,6 +258,7 @@ public class Game implements GameSpecification {
      * - Detect which axis of the distance vector is longer (faster movement)
      * - for each pixel on the 'faster' axis calculate the position on the 'slower' axis.
      * Direction of the movement has to correctly considered
+     *
      * @param startPosition Starting position as a PositionVector
      * @param endPosition   Ending position as a PositionVector
      * @return Intervening grid positions as a List of PositionVector's, including the starting and ending positions.
@@ -244,20 +288,24 @@ public class Game implements GameSpecification {
         int distanceSlowAxis, distanceFastAxis;
         if (distX > distY) {
             // x axis is the 'fast' direction
-            parallelStepX = dirX; parallelStepY = 0; // parallel step only moves in x direction
-            diagonalStepX = dirX; diagonalStepY = dirY; // diagonal step moves in both directions
+            parallelStepX = dirX;
+            parallelStepY = 0; // parallel step only moves in x direction
+            diagonalStepX = dirX;
+            diagonalStepY = dirY; // diagonal step moves in both directions
             distanceSlowAxis = distY;
             distanceFastAxis = distX;
         } else {
             // y axis is the 'fast' direction
-            parallelStepX = 0; parallelStepY = dirY; // parallel step only moves in y direction
-            diagonalStepX = dirX; diagonalStepY = dirY; // diagonal step moves in both directions
+            parallelStepX = 0;
+            parallelStepY = dirY; // parallel step only moves in y direction
+            diagonalStepX = dirX;
+            diagonalStepY = dirY; // diagonal step moves in both directions
             distanceSlowAxis = distX;
             distanceFastAxis = distY;
         }
 
-        int error = distanceFastAxis/2;
-        for(int step = 0; step < distanceFastAxis; step ++) {
+        int error = distanceFastAxis / 2;
+        for (int step = 0; step < distanceFastAxis; step++) {
             error -= distanceSlowAxis;
             if (error < 0) {
                 error += distanceFastAxis; // correct error value to be positive again
@@ -270,55 +318,54 @@ public class Game implements GameSpecification {
                 y += parallelStepY;
             }
 
-        pathList.add(new PositionVector(x,y));
+            pathList.add(new PositionVector(x, y));
         }
         return pathList;
     }
 
-    private void calculateWinner(PositionVector start, PositionVector finish, int carIndex ) {
+    private void calculateWinner(PositionVector start, PositionVector finish, int carIndex) {
         List<PositionVector> path = calculatePath(start, finish);
-        for (PositionVector point : path){
+        for (PositionVector point : path) {
+            if (track.getSpaceType(point) != null) {
                 switch (track.getSpaceType(point)) {
                     case FINISH_UP:
-                    if(start.getY() < finish.getY()) {
+                        if (start.getY() < finish.getY()) {
                             track.getCar(carIndex).increaseWinPoints();
-                    }
-                    else if(start.getY() > finish.getY()) {
+                        } else if (start.getY() > finish.getY()) {
                             track.getCar(carIndex).deductWinPoints();
                         }
                         break;
                     case FINISH_DOWN:
-                    if(start.getY() > finish.getY()){
+                        if (start.getY() > finish.getY()) {
                             track.getCar(carIndex).increaseWinPoints();
-                    }
-                    else if (start.getY() < finish.getY()){
+                        } else if (start.getY() < finish.getY()) {
                             track.getCar(carIndex).deductWinPoints();
                         }
                         break;
                     case FINISH_RIGHT:
-                    if(start.getX() < finish.getX()){
+                        if (start.getX() < finish.getX()) {
                             track.getCar(carIndex).increaseWinPoints();
-                    }
-                    else if (start.getX() > finish.getX()){
+                        } else if (start.getX() > finish.getX()) {
                             track.getCar(carIndex).deductWinPoints();
                         }
                         break;
                     case FINISH_LEFT:
-                    if(start.getX() > finish.getX()){
+                        if (start.getX() > finish.getX()) {
                             track.getCar(carIndex).increaseWinPoints();
-                    }
-                    else if (start.getX() < finish.getX()){
+                        } else if (start.getX() < finish.getX()) {
                             track.getCar(carIndex).increaseWinPoints();
                         }
                         break;
                 }
-            }
 
             }
+        }
+    }
 
 
     /**
      * Does indicate if a car would have a crash with a WALL space or another car at the given position.
+     *
      * @param carIndex The zero-based carIndex number
      * @param position A PositionVector of the possible crash position
      * @return A boolean indicator if the car would crash with a WALL or another car.
@@ -328,12 +375,22 @@ public class Game implements GameSpecification {
         return track.willCrashAtPosition(carIndex, position);
     }
 
-    public boolean allCarsCrashed() {
-        for(int carIndex = 0; carIndex < track.getCarCount(); carIndex ++) {
-            if(! track.getCar(carIndex).isCrashed()) {
-                return false;
+    public boolean onlyOneCarLeft() {
+        int carsLeft = 0;
+        for (int carIndex = 0; carIndex < track.getCarCount(); carIndex++) {
+            if (!track.getCar(carIndex).isCrashed()) {
+                carsLeft++;
             }
         }
+        return !(carsLeft > 1);
+    }
+
+    public boolean carsMoving() {
+        for (int carIndex = 0; carIndex < track.getCarCount(); carIndex++) {
+            if (!(track.getCar(carIndex).isCrashed() || track.getCar(carIndex).getMoveStrategy().getClass() == DoNotMoveStrategy.class)) {
                 return true;
             }
+        }
+        return false;
+    }
 }

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

@@ -1,5 +1,10 @@
 package ch.zhaw.pm2.racetrack;
 
+/**
+ * Class for Exception when invalid Fileformat is used.
+ */
 public class InvalidFileFormatException extends Exception {
-    // TODO: implementation
+    public InvalidFileFormatException(String errorMessage) {
+        super(errorMessage);
+    }
 }

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

@@ -1,5 +1,13 @@
 package ch.zhaw.pm2.racetrack;
 
+/**
+ * Class for Exception when invalid track format is used.
+ */
 public class InvalidTrackFormatException extends Exception {
-    // TODO: implementation
+    public InvalidTrackFormatException(String errorMessage) {
+        super(errorMessage);
+    }
+    public InvalidTrackFormatException() {
+        super();
+    }
 }

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

@@ -6,23 +6,35 @@ import java.util.List;
 
 public class Main {
 
-    public static void main(String[] args) throws InvalidTrackFormatException, FileNotFoundException, PositionVectorNotValid {
-        boolean exit = false;
-        while (!exit) {
-            UserInterface userInterface = new UserInterface("Hello and Welcome");
+    public static void main(String[] args) throws InvalidTrackFormatException, PositionVectorNotValid {
+        UserInterface userInterface = new UserInterface("Hello and Welcome to Racetrack by Team02-\"AngryNerds\"");
+        while (true) {
             Game game = new Game(userInterface);
-            int winner = 0;
+            String winner;
             if (game.initPhase()) {
                 winner = game.gamePhase();
-            }
                 List<String> optionsNewGame = new ArrayList<>();
                 optionsNewGame.add("exit");
                 optionsNewGame.add("new game");
-            int selectedOption = userInterface.selectOption("The Winner was Car : " + winner + "\nStart new Game?", optionsNewGame);
-            if(selectedOption == 0) {
-                exit = true;
+                String winnerText;
+                if(winner == null){
+                    winnerText = "There was no winner.";
                 }
+                else {
+                    winnerText = "The Winner was Car " + winner;
+                }
+                int selectedOption = userInterface.selectOption(winnerText + "\nStart new Game?", optionsNewGame);
+                if(selectedOption == 0) {
+                    userInterface.quit("Thank you and goodbye\npress enter to close the application.");
+                    break;
+                }
+            }
+            else {
+                userInterface.quit("The initialisation of the game failed. Press enter to close the application.");
+                break;
             }
         }
 
+    }
+
 }

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

@@ -60,6 +60,7 @@ public class Track implements TrackSpecification {
     private List<String> track;
     private List<Car> cars;
     private final List<PositionVector> finishLine;
+    private ConfigSpecification.SpaceType finishTyp;
 
     /**
      * Initialize a Track from the given track file.
@@ -132,7 +133,7 @@ public class Track implements TrackSpecification {
         if (finishLine.size() == 0) {
             throw new InvalidTrackFormatException();
         }
-        ConfigSpecification.SpaceType finishTyp = getSpaceType(finishLine.get(0));
+        finishTyp = getSpaceType(finishLine.get(0));
         for (PositionVector positionVector : finishLine) {
             if (getSpaceType(positionVector) != finishTyp) {
                 throw new InvalidTrackFormatException();
@@ -207,12 +208,20 @@ public class Track implements TrackSpecification {
      * @param carIndex of the current car
      */
     private void makeCarMoveInTrack(int carIndex) {
-        PositionVector positionVector = findChar(getCarId(carIndex));
+        PositionVector carPositionVector = findChar(getCarId(carIndex));
         //Removes the Car at Current Pos
-        drawCharOnTrackIndicator(positionVector, ConfigSpecification.SpaceType.TRACK.getValue());
+        drawCharOnTrackIndicator(carPositionVector, ConfigSpecification.SpaceType.TRACK.getValue());
+
+        //Redraw finishline if Car was on finish-line Position
+        for(PositionVector finishLinePositionVector : finishLine){
+            if(finishLinePositionVector.equals(carPositionVector)){
+                drawCharOnTrackIndicator(carPositionVector, finishTyp.getValue());
+            }
+        }
+
         //Adds Car at new Position
-        positionVector = cars.get(carIndex).nextPosition();
-        drawCharOnTrackIndicator(positionVector, cars.get(carIndex).getID());
+        carPositionVector = cars.get(carIndex).nextPosition();
+        drawCharOnTrackIndicator(carPositionVector, cars.get(carIndex).getID());
     }
 
     /**
@@ -222,24 +231,30 @@ public class Track implements TrackSpecification {
      * @return true if car would crash. Else false.
      */
     public boolean willCrashAtPosition(int carIndex, PositionVector positionVector) throws PositionVectorNotValid {
-        isPositionVectorOnTrack(positionVector);
+        isPositionVectorOnTrack(positionVector); //TODO: remove this line? Or Method?
         char charAtPosition = track.get(positionVector.getY()).charAt(positionVector.getX());
         if (getCarId(carIndex) == charAtPosition) return false;
-        return (charAtPosition == ConfigSpecification.SpaceType.WALL.value);
+        return !(charAtPosition == ConfigSpecification.SpaceType.TRACK.value ||
+            charAtPosition == ConfigSpecification.SpaceType.FINISH_RIGHT.value ||
+            charAtPosition == ConfigSpecification.SpaceType.FINISH_LEFT.value ||
+            charAtPosition == ConfigSpecification.SpaceType.FINISH_UP.value ||
+            charAtPosition == ConfigSpecification.SpaceType.FINISH_DOWN.value);
     }
 
     /**
      * This Method will make the Car Crash. In Track and in the Car Object
      *
      * @param carIndex       representing current Car
-     * @param positionVector where the Crash did happen
+     * @param crashPositionVector where the Crash did happen
      */
-    public void carDoesCrash(int carIndex, PositionVector positionVector) throws PositionVectorNotValid{
-        isPositionVectorOnTrack(positionVector);
+    public void carDoesCrash(int carIndex, PositionVector crashPositionVector) throws PositionVectorNotValid{
+        isPositionVectorOnTrack(crashPositionVector); //TODO: remove this line? and Method?
+        PositionVector currentCarPosition = getCarPos(carIndex);
+        drawCharOnTrackIndicator(new PositionVector(currentCarPosition.getX(), currentCarPosition.getY()), ConfigSpecification.SpaceType.TRACK.getValue());
         Car car = cars.get(carIndex);
         car.crash();
-        car.setPosition(positionVector);
-        drawCharOnTrackIndicator(new PositionVector(positionVector.getX(), positionVector.getY()), CRASH_INDICATOR);
+        car.setPosition(crashPositionVector);
+        drawCharOnTrackIndicator(new PositionVector(crashPositionVector.getX(), crashPositionVector.getY()), CRASH_INDICATOR);
     }
 
     /**

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

@@ -97,6 +97,15 @@ public class UserInterface {
             textTerminal.println(track.toString());
     }
 
+    /**
+     * Method to dispose the Textterminal
+     * @param text OUtput Text
+     */
+    public void quit(String text){
+        textIO.newStringInputReader().withMinLength(0).read(text);
+        textTerminal.dispose();
+    }
+
 
 
 }

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

@@ -2,11 +2,44 @@ package ch.zhaw.pm2.racetrack.strategy;
 
 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.List;
+import java.util.Scanner;
+
 public class MoveListStrategy implements MoveStrategy {
 
+    private List<Direction> moveList;
+    private int pointer;
+
+    public MoveListStrategy(String path) throws FileNotFoundException{
+        moveList = new ArrayList<>();
+        pointer = -1;
+        readFile(new File(path));
+    }
+
+    private void readFile(File trackFile) throws FileNotFoundException {
+        Scanner scanner = new Scanner(new FileInputStream(trackFile), "UTF-8");
+        Direction[] directions = Direction.values();
+        while (scanner.hasNextLine()) {
+            String line = scanner.nextLine();
+            for (Direction dir : directions) {
+                if (dir.toString().equals(line)) {
+                    moveList.add(dir);
+                    break;
+                }
+            }
+        }
+    }
+
     @Override
     public Direction nextMove() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        pointer += 1;
+        if (pointer < moveList.size()) {
+            return moveList.get(pointer);
+        }
+        return null;
     }
 }

src/test/java/ch/zhaw/pm2/racetrack/CarTest.java

@@ -0,0 +1,224 @@
+
+package ch.zhaw.pm2.racetrack;
+
+import ch.zhaw.pm2.racetrack.strategy.*;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for Class Car
+ */
+class CarTest {
+
+    Car car;
+
+    // Default coordinates for tests
+    int DEFAULT_X = 10;
+    int DEFAULT_Y = 10;
+    char DEFAULT_ID = 'f';
+
+    /**
+     * Create a new Car Object and set Position to a defined Default Position
+     */
+    @BeforeEach
+    void setUp() {
+        car = new Car(DEFAULT_ID, new PositionVector(DEFAULT_X, DEFAULT_Y));
+    }
+
+    @Test
+    void getID() {
+        assertEquals(DEFAULT_ID, car.getID());
+    }
+
+    /**
+     * Method to check nextPosition with coordinates as int
+     *
+     * @param x the expected value for x coordinate
+     * @param y the expected value for y coordinate
+     */
+    void checkNextPosition(int x, int y) {
+        assertEquals(new PositionVector(x, y), car.nextPosition());
+    }
+
+    /**
+     * - checks if the position of the car can be set and saved correctly with valid positions.
+     * - checks if an exception is throwed and position keeps unchanged if invalid coordinates are entered.
+     */
+    @Test
+    void setPosition() {
+        checkNextPosition(DEFAULT_X, DEFAULT_Y);
+
+        // List of valid Positions
+        List<PositionVector> validPositions = new ArrayList<>();
+        validPositions.add(new PositionVector(20, 20));
+        validPositions.add(new PositionVector(0, 0));
+        validPositions.add(new PositionVector(20, 0));
+        validPositions.add(new PositionVector(0, 20));
+
+        for (PositionVector positionVector : validPositions) {
+            car.setPosition(positionVector);
+            assertEquals(positionVector, car.nextPosition());
+        }
+
+        // List of invalid positions.
+        List<PositionVector> invalidPositions = new ArrayList<>();
+        invalidPositions.add(new PositionVector(0, -20));
+        invalidPositions.add(new PositionVector(-20, 0));
+        invalidPositions.add(new PositionVector(-20, -20));
+
+        for (PositionVector positionVector : invalidPositions) {
+            boolean exception = false;
+            setUp();
+            try {
+                car.setPosition(positionVector);
+            } catch (IllegalArgumentException e) {
+                exception = true;
+            }
+            assertTrue(exception);
+
+            // position should keep unchanged
+            checkNextPosition(DEFAULT_X, DEFAULT_Y);
+        }
+    }
+
+    void checkVelocity(int x, int y) {
+        assertEquals(new PositionVector(x, y), car.getVelocity());
+    }
+
+
+    /**
+     * Checks if the methods accelerate, move and getVelocity are working correctly with acceleration in all directions.
+     * Checks also if velocity is calculated correctly if method accelerate is called a second time.
+     */
+    @Test
+    void movement() {
+        // add all possible directions in a List
+        List<PositionVector.Direction> directions = Arrays.asList(PositionVector.Direction.values());
+
+        //position shouldn't be changed because velocity should be 0.
+        car.move();
+        checkNextPosition(DEFAULT_X, DEFAULT_Y);
+
+
+
+        for (PositionVector.Direction direction1 : directions) {
+            for (PositionVector.Direction direction2 : directions) {
+
+                //create a new instance of Car with default coordinates and velocity 0.
+                setUp();
+
+                //variables to save the actual expected result of method nextPosition
+                int expectedNextPosX = DEFAULT_X;
+                int expectedNextPosY = DEFAULT_Y;
+
+                //variables to save the acutal expected result of method getVelocity
+                int expectedVelocityX = 0;
+                int expectedVelocityY = 0;
+
+                car.accelerate(direction1);
+                expectedVelocityX += direction1.vector.getX();
+                expectedVelocityY += direction1.vector.getY();
+                expectedNextPosX += direction1.vector.getX();
+                expectedNextPosY += direction1.vector.getY();
+                checkVelocity(expectedVelocityX, expectedVelocityY);
+                checkNextPosition(expectedNextPosX, expectedNextPosY);
+
+                car.move();
+                expectedNextPosX += direction1.vector.getX();
+                expectedNextPosY += direction1.vector.getY();
+                checkVelocity(expectedVelocityX, expectedVelocityY);
+                checkNextPosition(expectedNextPosX, expectedNextPosY);
+
+
+                car.accelerate(direction2);
+                expectedVelocityX += direction2.vector.getX();
+                expectedVelocityY += direction2.vector.getY();
+                expectedNextPosX += direction2.vector.getX();
+                expectedNextPosY += direction2.vector.getY();
+                checkVelocity(expectedVelocityX, expectedVelocityY);
+                checkNextPosition(expectedNextPosX, expectedNextPosY);
+
+                car.move();
+                checkVelocity(expectedVelocityX, expectedVelocityY);
+                expectedNextPosX += (direction1.vector.getX() + direction2.vector.getX());
+                expectedNextPosY += (direction1.vector.getY() + direction2.vector.getY());
+                checkNextPosition(expectedNextPosX, expectedNextPosY);
+            }
+        }
+    }
+
+
+    /**
+     * test for methods crash and isCrashed. checks if state crashed is set and returned correctly.
+     */
+    @Test
+    void crash() {
+        assertFalse(car.isCrashed());
+        car.crash();
+        assertTrue(car.isCrashed());
+    }
+
+    /**
+     * test for methods setMoveStrategy. Checks if the MoveStrategy Object is saved and returned correctly
+     * with all Types of MoveStrategy.
+     */
+    @Test
+    void MoveStrategy() {
+        MoveStrategy moveStrategy;
+
+        moveStrategy = new DoNotMoveStrategy();
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+
+        try {
+            moveStrategy = new MoveListStrategy(".\\moves\\challenge-car-a.txt");
+        } catch (FileNotFoundException e) {
+            Assertions.fail();
+        }
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+
+        moveStrategy = new PathFollowerMoveStrategy();
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+
+        moveStrategy = new UserMoveStrategy(new UserInterface("Hello"),0,'a');
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+    }
+
+    /**
+     * Test for get WinPoints
+     */
+    @Test
+    void getWinPoints() {
+        assertEquals(0,car.getWinPoints());
+    }
+
+    /**
+     * Test for increase WinPoints
+     */
+    @Test
+    void increaseWinPoints() {
+        car.increaseWinPoints();
+        assertEquals(1,car.getWinPoints());
+    }
+
+    /**
+     * Test for deduct WinPoints
+     */
+    @Test
+    void deductWinPoints() {
+        car.deductWinPoints();
+        assertEquals(-1,car.getWinPoints());
+    }
+
+}

src/test/java/ch/zhaw/pm2/racetrack/GameTest.java

@@ -0,0 +1,233 @@
+package ch.zhaw.pm2.racetrack;
+
+import ch.zhaw.pm2.racetrack.strategy.UserMoveStrategy;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Assertions;
+import java.io.File;
+import java.util.List;
+import static ch.zhaw.pm2.racetrack.Game.NO_WINNER;
+import static ch.zhaw.pm2.racetrack.PositionVector.Direction.*;
+
+
+/**
+ * Test for Class Game
+ */
+class GameTest {
+    private UserInterface userInterface;
+    private Game game;
+    private Track track;
+
+    private String TRACK_FILE_PATH = ".\\tracks\\challenge.txt";
+    private int CAR_INDEX_ONE = 0;
+    private int CAR_INDEX_TWO = 1;
+
+    /**
+     * This nested Class tests if the game gets initiatet correctly
+     */
+    @Nested
+    @DisplayName("Test correct Setup")
+    class Setup {
+
+        @BeforeEach
+        void setup() {
+            userInterface = new UserInterface("Test");
+            game = new Game(userInterface);
+            track = game.selectTrack(new File(TRACK_FILE_PATH));
+            game.selectMoveStrategy(track.getCar(CAR_INDEX_ONE), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_ONE, track.getCarId(CAR_INDEX_ONE)));
+            game.selectMoveStrategy(track.getCar(CAR_INDEX_TWO), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_TWO, track.getCarId(CAR_INDEX_TWO)));
+
+        }
+
+        @Test
+        void getCurrentCarIndex() {
+            Assertions.assertEquals(CAR_INDEX_ONE, game.getCurrentCarIndex());
+            game.switchToNextActiveCar();
+            Assertions.assertEquals(CAR_INDEX_TWO, game.getCurrentCarIndex());
+        }
+
+        @Test
+        void getCarId() {
+            Assertions.assertEquals('a', game.getCarId(0));
+            Assertions.assertEquals('b', game.getCarId(1));
+        }
+
+        @Test
+        void getCarPosition() {
+            Assertions.assertEquals(new PositionVector(24, 22), game.getCarPosition(0));
+            Assertions.assertEquals(new PositionVector(24, 24), game.getCarPosition(1));
+        }
+
+        @Test
+        void getCarVelocity() {
+            Assertions.assertEquals(new PositionVector(0, 0), game.getCarVelocity(0));
+            Assertions.assertEquals(new PositionVector(0, 0), game.getCarVelocity(1));
+        }
+
+        @Test
+        void getWinner() {
+            Assertions.assertEquals(NO_WINNER, game.getWinner());
+        }
+
+        @Test
+        void onlyOneCarLeft() {
+            Assertions.assertFalse(game.onlyOneCarLeft());
+        }
+
+        @Test
+        void carsMoving() {
+            Assertions.assertTrue(game.carsMoving());
+        }
+    }
+
+    /**
+     * This nested Class makes basic manipulation after Game init.
+     */
+    @Nested
+    @DisplayName("Basic manipulation")
+    class Manipulation {
+
+        @BeforeEach
+        void setup() {
+            userInterface = new UserInterface("Test");
+            game = new Game(userInterface);
+            track = game.selectTrack(new File(TRACK_FILE_PATH));
+            game.selectMoveStrategy(track.getCar(CAR_INDEX_ONE), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_ONE, track.getCarId(CAR_INDEX_ONE)));
+            game.selectMoveStrategy(track.getCar(CAR_INDEX_TWO), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_TWO, track.getCarId(CAR_INDEX_TWO)));
+
+        }
+
+        @Test
+        void carTurnCorrect() {
+            try {
+                game.doCarTurn(RIGHT);
+                Assertions.assertEquals(new PositionVector(1, 0), game.getCarVelocity(0));
+            } catch (PositionVectorNotValid positionVectorNotValid) {
+                positionVectorNotValid.printStackTrace();
+            }
+        }
+
+        @Test
+        void carCrash() {
+            try {
+                game.doCarTurn(PositionVector.Direction.UP);
+                Assertions.assertTrue(game.onlyOneCarLeft());
+            } catch (PositionVectorNotValid positionVectorNotValid) {
+                positionVectorNotValid.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * This nested Class tests a Playtrough. And implements a UserInterface interagtion to pretend a real player
+     */
+    @Nested
+    @DisplayName("Playtrough")
+    class Play {
+        private Game game;
+
+        @Test
+        void winner() {
+            game = new Game(new interFace("Test",new Integer[]{0,2,1},new PositionVector.Direction[]{RIGHT,
+                RIGHT,
+                RIGHT,
+                NONE,
+                NONE,
+                NONE,
+                NONE,
+                UP,
+                LEFT,
+                LEFT,
+                LEFT,
+                LEFT,
+                UP_LEFT,
+                NONE,
+                RIGHT,
+                RIGHT,
+                RIGHT,
+                NONE,
+                LEFT,
+                DOWN_LEFT,
+                DOWN_LEFT,
+                LEFT,
+                LEFT,
+                NONE,
+                RIGHT,
+                NONE,
+                DOWN,
+                DOWN,
+                RIGHT,
+                NONE,
+                RIGHT,
+                DOWN,
+                NONE,
+                UP_RIGHT,
+                RIGHT,
+                UP_RIGHT,
+                UP_RIGHT,
+                RIGHT,
+                RIGHT}));
+            try {
+                game.initPhase();
+                Assertions.assertEquals("a",game.gamePhase());
+            } catch (InvalidTrackFormatException | PositionVectorNotValid e) {
+                e.printStackTrace();
+            }
+        }
+
+        @Test
+        void crashA() {
+            game = new Game(new interFace("Test",new Integer[]{0,2,2},new PositionVector.Direction[]{UP}));
+            try {
+                game.initPhase();
+                Assertions.assertEquals("b",game.gamePhase());
+            } catch (InvalidTrackFormatException | PositionVectorNotValid e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    private class interFace extends UserInterface {
+
+        private final PositionVector.Direction[] directions;
+        private final Integer[] instructions;
+        private int pointerDir,pointerInstruction;
+
+
+        public interFace(String welcometxt, Integer[] instructions, PositionVector.Direction[] directions) {
+            super(welcometxt);
+            pointerDir = -1;
+            pointerInstruction = -1;
+            this.instructions = instructions;
+            this.directions = directions;
+        }
+
+        @Override
+        public int selectOption(String text, List<String> options) {
+            pointerInstruction++;
+            return instructions[pointerInstruction];
+
+        }
+
+        public void printInformation(String text) {
+        }
+
+        public void printTrack(Track track) {
+        }
+
+        public void quit(String text) {
+        }
+
+        public PositionVector.Direction selectDirection(int playingCarIndex, char playingCarID) {
+            pointerDir += 1;
+            if(pointerDir < directions.length) {
+                return directions[pointerDir];
+            }
+            return NONE;
+        }
+
+    }
+}

src/test/java/ch/zhaw/pm2/racetrack/MoveStrategyTest.java

@@ -0,0 +1,40 @@
+package ch.zhaw.pm2.racetrack;
+
+import ch.zhaw.pm2.racetrack.strategy.MoveListStrategy;
+import ch.zhaw.pm2.racetrack.strategy.MoveStrategy;
+import org.junit.jupiter.api.*;
+
+import java.io.FileNotFoundException;
+
+public class MoveStrategyTest {
+
+    private MoveStrategy moveList;
+
+    @Nested
+    @DisplayName("MoveListStrategy")
+    class MoveList {
+
+
+        @BeforeEach
+        void setup() {
+            try {
+                moveList = new MoveListStrategy(".\\moves\\challenge-car-a.txt");
+            }catch (FileNotFoundException e) {
+                e.printStackTrace();
+            }
+        }
+
+        @Test
+        void checkMove() {
+            Assertions.assertEquals(PositionVector.Direction.RIGHT,moveList.nextMove());
+            for (int i = 0; i < 3; i++) {
+                moveList.nextMove();
+            }
+            Assertions.assertEquals(PositionVector.Direction.NONE,moveList.nextMove());
+            for (int i = 0; i < 40; i++) {
+                moveList.nextMove();
+            }
+            Assertions.assertNull(moveList.nextMove());
+        }
+    }
+}