Javadoc in PathFollowerMoveStrategy.java

GameTest startet

build.gradle

@@ -29,6 +29,7 @@ dependencies {
 
     // beryx uses SLF4J. To remove warning, we add the implementation "no operation"
     implementation 'org.slf4j:slf4j-nop:2.+'
+    implementation 'junit:junit:4.13.1'
 
     // Use JUnit Jupiter API for testing.
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
@@ -43,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 {

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/Car.java

@@ -3,6 +3,8 @@ package ch.zhaw.pm2.racetrack;
 import ch.zhaw.pm2.racetrack.given.CarSpecification;
 import ch.zhaw.pm2.racetrack.strategy.MoveStrategy;
 
+import java.util.Vector;
+
 /**
  * Class representing a car on the racetrack.
  * Uses {@link PositionVector} to store current position on the track grid and current velocity vector.
@@ -22,6 +24,10 @@ public class Car implements CarSpecification {
      * Current position of the car on the track grid using a {@link PositionVector}
      */
     private PositionVector position;
+    /**
+     * Points that car is holding for determining winner.
+     */
+    private int winPoints;
 
     /**
      * Current velocity of the car using a {@link PositionVector}
@@ -48,17 +54,51 @@ public class Car implements CarSpecification {
         setPosition(position);
     }
 
+    /**
+     * Returns the id of the car.
+     *
+     * @return id of the car.
+     */
+    public char getID(){
+        return id;
+    }
+
+    public void increaseWinPoints() {
+        winPoints ++;
+    }
+
+    public void deductWinPoints() {
+        winPoints --;
+    }
+
+    public int getWinPoints() {
+        return winPoints;
+    }
+
+    /**
+     * Returns the current velocity of the car as a PositionVector.
+     *
+     * @return velocity current velocity of the car.
+     */
+    public PositionVector getVelocity(){
+        return velocity;
+    }
     /**
      * Set this Car position directly, regardless of current position and velocity.
      * This should only be used by the game controller in rare cases to set the crash or winning position.
      * The next position is normaly automatically calculated and set in the {@link #move()} method.
      *
      * @param position The new position to set the car directly to.
+     * @throws IllegalArgumentException if invalid PositionVector is given.
      */
     @Override
     public void setPosition(final PositionVector position) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        if (position.getX() < 0 || position.getY() < 0) {
+            throw new IllegalArgumentException();
+        }
+        else {
+            this.position = position;
+        }
     }
 
     /**
@@ -69,8 +109,7 @@ public class Car implements CarSpecification {
      */
     @Override
     public PositionVector nextPosition() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return new PositionVector(position.getX() + velocity.getX(),position.getY() + velocity.getY());
     }
 
     /**
@@ -80,11 +119,18 @@ public class Car implements CarSpecification {
      * Changes only velocity, not position.
      *
      * @param acceleration A Direction vector containing the amounts to add to the velocity in x and y dimension
+     * @throws IllegalArgumentException if PositionVector is not in allowed area.
      */
     @Override
     public void accelerate(PositionVector.Direction acceleration) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        if(acceleration.vector.getX() < -1 || acceleration.vector.getX() > 1||
+            acceleration.vector.getY() < -1 || acceleration.vector.getY() > 1) {
+            throw new IllegalArgumentException();
+        }
+        else {
+            velocity = new PositionVector(velocity.getX() + acceleration.vector.getX(),
+                velocity.getY() + acceleration.vector.getY());
+        }
     }
 
     /**
@@ -92,8 +138,7 @@ public class Car implements CarSpecification {
      */
     @Override
     public void move() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        position = new PositionVector(position.getX() + velocity.getX(), position.getY() + velocity.getY());
     }
 
     /**
@@ -101,8 +146,7 @@ public class Car implements CarSpecification {
      */
     @Override
     public void crash() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        crashed = true;
     }
 
     /**
@@ -112,13 +156,12 @@ public class Car implements CarSpecification {
      */
     @Override
     public boolean isCrashed() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return crashed;
     }
 
     /**
      * Set move strategy
-     * @param moveStrategy
+     * @param moveStrategy Strategy to be implemented
      */
     public void setMoveStrategy(MoveStrategy moveStrategy) {
         this.moveStrategy = moveStrategy;

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

@@ -1,7 +1,11 @@
 package ch.zhaw.pm2.racetrack;
 
 import ch.zhaw.pm2.racetrack.given.GameSpecification;
+import ch.zhaw.pm2.racetrack.strategy.*;
 
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
 import java.util.List;
 
 import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
@@ -13,59 +17,158 @@ import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
  */
 public class Game implements GameSpecification {
     public static final int NO_WINNER = -1;
+    private Track track;
+    private int currentCarIndex;
+
+    UserInterface userInterface;
+
+    public Game(UserInterface userInterface) {
+        this.userInterface = userInterface;
+    }
+
+
+    public boolean initPhase() throws InvalidTrackFormatException {
+        File folder = new File("tracks");
+        File[] listOfFiles = folder.listFiles();
+        if (listOfFiles.length > 0) {
+            List<String> tracks = new ArrayList<>();
+            for (File file : listOfFiles) {
+                tracks.add(file.getName());
+            }
+            File selectedTrack = listOfFiles[userInterface.selectOption("Select Track file", tracks)];
+            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++) {
+                Car car = track.getCar(i);
+                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:
+                            moveStrategy = new DoNotMoveStrategy();
+                            break;
+                        case 2:
+                            moveStrategy = new UserMoveStrategy(userInterface, i, track.getCarId(i));
+                            break;
+                        case 3:
+                            filePath = ".\\moves\\" + selectedTrack.getName().split("\\.")[0] + "-car-" + track.getCar(i).getID() + ".txt";
+                            try {
+                                moveStrategy = new MoveListStrategy(filePath);
+                            } catch (FileNotFoundException e) {
+                                userInterface.printInformation("There is no Move-List implemented. Choose another Strategy!");
+                            }
+                            //TODO: Backslash kompatibel für Linux
+                            break;
+                        case 4:
+                            filePath = ".\\follower\\" + selectedTrack.getName().split("\\.")[0] + "_points.txt";
+                            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 {
+            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
     public int getCurrentCarIndex() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return currentCarIndex;
     }
 
     /**
      * Get the id of the specified car.
+     *
      * @param carIndex The zero-based carIndex number
      * @return A char containing the id of the car
      */
     @Override
     public char getCarId(int carIndex) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return track.getCarId(carIndex);
     }
 
     /**
      * Get the position of the specified car.
+     *
      * @param carIndex The zero-based carIndex number
      * @return A PositionVector containing the car's current position
      */
     @Override
     public PositionVector getCarPosition(int carIndex) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return track.getCarPos(carIndex);
     }
 
     /**
      * Get the velocity of the specified car.
+     *
      * @param carIndex The zero-based carIndex number
      * @return A PositionVector containing the car's current velocity
      */
     @Override
     public PositionVector getCarVelocity(int carIndex) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return track.getCarVelocity(carIndex);
     }
 
     /**
      * 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() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        if (onlyOneCarLeft()) {
+            return currentCarIndex;
+        }
+        for (int i = 0; i < track.getCarCount(); i++) {
+            if (track.getCar(i).getWinPoints() == 1) {
+                return i;
+            }
+        }
+        return NO_WINNER;
     }
 
     /**
@@ -95,9 +198,48 @@ public class Game implements GameSpecification {
      *                     for this turn
      */
     @Override
-    public void doCarTurn(Direction acceleration) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+    public void doCarTurn(Direction acceleration) throws PositionVectorNotValid {
+        track.getCar(currentCarIndex).accelerate(acceleration);
+
+        PositionVector crashPosition = null;
+        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) {
+            track.carDoesCrash(currentCarIndex, crashPosition);
+        } else {
+            calculateWinner(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition(), currentCarIndex);
+            track.moveCar(currentCarIndex);
+        }
+    }
+
+    public String gamePhase() throws PositionVectorNotValid {
+        while (carsMoving() && getWinner() == NO_WINNER) {
+            userInterface.printTrack(track);
+            Direction direction;
+            direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
+            if (direction == null) {
+                track.getCar(currentCarIndex).setMoveStrategy(new DoNotMoveStrategy());
+                direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove(); //TODO: Entfernen?
+            }else {
+                doCarTurn(direction);
+            }
+            switchToNextActiveCar();
+        }
+        userInterface.printTrack(track);
+        int indexWinner = getWinner();
+        if (indexWinner == NO_WINNER) {
+            return null;
+        }
+        return String.valueOf(track.getCar(indexWinner).getID());
     }
 
     /**
@@ -105,8 +247,14 @@ public class Game implements GameSpecification {
      */
     @Override
     public void switchToNextActiveCar() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        do {
+            if ((currentCarIndex + 1) == track.getCarCount()) {
+                currentCarIndex = 0;
+            } else {
+                currentCarIndex++;
+            }
+        } while (track.getCar(currentCarIndex).isCrashed());
+        // TODO: evtl andere Kapselung
     }
 
     /**
@@ -117,25 +265,139 @@ 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
+     * @param endPosition   Ending position as a PositionVector
      * @return Intervening grid positions as a List of PositionVector's, including the starting and ending positions.
      */
     @Override
     public List<PositionVector> calculatePath(PositionVector startPosition, PositionVector endPosition) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        ArrayList<PositionVector> pathList = new ArrayList<>();
+        // Use Bresenham's algorithm to determine positions.
+        int x = startPosition.getX();
+        int y = startPosition.getY();
+
+        // Relative Distance (x & y axis) between end- and starting position
+        int diffX = endPosition.getX() - startPosition.getX();
+        int diffY = endPosition.getY() - startPosition.getY();
+
+        // Absolute distance (x & y axis) between end- and starting position
+        int distX = Math.abs(diffX);
+        int distY = Math.abs(diffY);
+
+        // Direction of vector on x & y axis (-1: to left/down, 0: none, +1 : to right/up)
+        int dirX = Integer.signum(diffX);
+        int dirY = Integer.signum(diffY);
+
+        // Determine which axis is the fast direction and set parallel/diagonal step values
+        int parallelStepX, parallelStepY;
+        int diagonalStepX, diagonalStepY;
+        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
+            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
+            distanceSlowAxis = distX;
+            distanceFastAxis = distY;
+        }
+
+        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
+                // step into slow direction; diagonal step
+                x += diagonalStepX;
+                y += diagonalStepY;
+            } else {
+                // step into fast direction; parallel step
+                x += parallelStepX;
+                y += parallelStepY;
+            }
+
+            pathList.add(new PositionVector(x, y));
+        }
+        return pathList;
     }
 
+    private void calculateWinner(PositionVector start, PositionVector finish, int carIndex) {
+        List<PositionVector> path = calculatePath(start, finish);
+        for (PositionVector point : path) {
+            if (track.getSpaceType(point) != null) {
+                switch (track.getSpaceType(point)) {
+                    case FINISH_UP:
+                        if (start.getY() < finish.getY()) {
+                            track.getCar(carIndex).increaseWinPoints();
+                        } else if (start.getY() > finish.getY()) {
+                            track.getCar(carIndex).deductWinPoints();
+                        }
+                        break;
+                    case FINISH_DOWN:
+                        if (start.getY() > finish.getY()) {
+                            track.getCar(carIndex).increaseWinPoints();
+                        } else if (start.getY() < finish.getY()) {
+                            track.getCar(carIndex).deductWinPoints();
+                        }
+                        break;
+                    case FINISH_RIGHT:
+                        if (start.getX() < finish.getX()) {
+                            track.getCar(carIndex).increaseWinPoints();
+                        } else if (start.getX() > finish.getX()) {
+                            track.getCar(carIndex).deductWinPoints();
+                        }
+                        break;
+                    case FINISH_LEFT:
+                        if (start.getX() > finish.getX()) {
+                            track.getCar(carIndex).increaseWinPoints();
+                        } 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.
      */
     @Override
-    public boolean willCarCrash(int carIndex, PositionVector position) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+    public boolean willCarCrash(int carIndex, PositionVector position) throws PositionVectorNotValid {
+        return track.willCrashAtPosition(carIndex, position);
+    }
+
+    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/Main.java

@@ -0,0 +1,40 @@
+package ch.zhaw.pm2.racetrack;
+
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Main {
+
+    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);
+            String winner;
+            if (game.initPhase()) {
+                winner = game.gamePhase();
+                List<String> optionsNewGame = new ArrayList<>();
+                optionsNewGame.add("exit");
+                optionsNewGame.add("new game");
+                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/PositionVectorNotValid.java

@@ -0,0 +1,9 @@
+package ch.zhaw.pm2.racetrack;
+
+public class PositionVectorNotValid extends Throwable {
+    public PositionVectorNotValid(String message) {
+        super(message);
+    }
+
+    public PositionVectorNotValid() {}
+}

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

@@ -1,9 +1,12 @@
 package ch.zhaw.pm2.racetrack;
 
+import ch.zhaw.pm2.racetrack.given.ConfigSpecification;
 import ch.zhaw.pm2.racetrack.given.TrackSpecification;
 
-import java.io.File;
-import java.io.FileNotFoundException;
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
 
 /**
  * This class represents the racetrack board.
@@ -54,8 +57,10 @@ import java.io.FileNotFoundException;
 public class Track implements TrackSpecification {
 
     public static final char CRASH_INDICATOR = 'X';
-
-    // TODO: Add necessary variables
+    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.
@@ -64,9 +69,192 @@ public class Track implements TrackSpecification {
      * @throws FileNotFoundException       if the given track file could not be found
      * @throws InvalidTrackFormatException if the track file contains invalid data (no tracklines, ...)
      */
-    public Track(File trackFile) throws FileNotFoundException, InvalidTrackFormatException {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+    public Track(File trackFile) throws FileNotFoundException, InvalidTrackFormatException, PositionVectorNotValid {
+        track = new ArrayList<>();
+        cars = new ArrayList<>();
+        finishLine = new ArrayList<>();
+        readFile(trackFile);
+        findFinish();
+        addCars();
+    }
+
+    /**
+     * This method reads the File and saves it to the track ArrayList Line by Line
+     *
+     * @param trackFile the File where the track has been documented
+     * @throws FileNotFoundException if the FilePath is invalid.
+     */
+    private void readFile(File trackFile) throws FileNotFoundException {
+        Scanner scanner = new Scanner(new FileInputStream(trackFile),"UTF-8");
+        while (scanner.hasNextLine()) {
+            track.add(scanner.nextLine());
+        }
+    }
+
+
+    private void addCars() throws InvalidTrackFormatException {
+        ConfigSpecification.SpaceType[] spaceTypes = ConfigSpecification.SpaceType.values();
+        List<Character> allSpaceTypesAsChar = new ArrayList<>();
+        List<Character> usedSymbolForCar = new ArrayList<>();
+
+        for (ConfigSpecification.SpaceType spaceType : spaceTypes) {
+            allSpaceTypesAsChar.add(spaceType.getValue());
+        }
+
+
+        for (int j = 0; j < track.size(); j++) {
+            String line = track.get(j);
+            for (int i = 0; i < line.length(); i++) {
+                char possibleCarChar = line.charAt(i);
+                if (!allSpaceTypesAsChar.contains(possibleCarChar)) {
+                    if (usedSymbolForCar.contains(possibleCarChar)) {
+                        throw new InvalidTrackFormatException();
+                    }
+                    usedSymbolForCar.add(possibleCarChar);
+                    cars.add(new Car(possibleCarChar, new PositionVector(i, j)));
+                }
+            }
+        }
+
+    }
+
+    private void findFinish() throws InvalidTrackFormatException {
+        for (int i = 0; i < track.size(); i++) {
+            String line = track.get(i);
+            for (int j = 0; j < line.length(); j++) {
+                if (line.charAt(j) == ConfigSpecification.SpaceType.FINISH_LEFT.getValue() ||
+                    line.charAt(j) == ConfigSpecification.SpaceType.FINISH_RIGHT.getValue() ||
+                    line.charAt(j) == ConfigSpecification.SpaceType.FINISH_DOWN.getValue() ||
+                    line.charAt(j) == ConfigSpecification.SpaceType.FINISH_UP.getValue()) {
+                    finishLine.add(new PositionVector(j, i));
+                }
+            }
+        }
+        if (finishLine.size() == 0) {
+            throw new InvalidTrackFormatException();
+        }
+        finishTyp = getSpaceType(finishLine.get(0));
+        for (PositionVector positionVector : finishLine) {
+            if (getSpaceType(positionVector) != finishTyp) {
+                throw new InvalidTrackFormatException();
+            }
+        }
+    }
+
+    private PositionVector findChar(char symbol) {
+        PositionVector vector = null;
+        for (int i = 0; i < track.size(); i++) {
+            String line = track.get(i);
+            for (int j = 0; j < line.length(); j++) {
+                if (line.charAt(j) == symbol) {
+                    vector = new PositionVector(j, i);
+                }
+            }
+        }
+        return vector;
+    }
+
+    private void drawCharOnTrackIndicator(PositionVector positionVector, char symbol) {
+        String line = track.get(positionVector.getY());
+        line = line.substring(0, positionVector.getX()) + symbol + line.substring(positionVector.getX() + 1);
+        track.remove(positionVector.getY());
+        track.add(positionVector.getY(), line);
+    }
+
+    private void isPositionVectorOnTrack(PositionVector positionVector) throws PositionVectorNotValid {
+        try{
+            track.get(positionVector.getY()).charAt(positionVector.getX());
+        }catch (IndexOutOfBoundsException e) {
+            throw new PositionVectorNotValid();
+        }
+    }
+
+    /**
+     * @return all Cars
+     */
+    public List<Car> getCars() {
+        return cars;
+    }
+
+    /**
+     * @return finishLine
+     */
+    public List<PositionVector> getFinishLine() {
+        return finishLine;
+    }
+
+    /**
+     * @return the track
+     */
+    public List<String> getTrack() {
+        return track;
+    }
+
+    /**
+     * This Method will update the Car on the track
+     * and will make the Car move to the next position
+     *
+     * @param carIndex representing the current Car
+     */
+    public void moveCar(int carIndex) {
+        makeCarMoveInTrack(carIndex);
+        //Change position of car
+        getCar(carIndex).move();
+    }
+
+    /**
+     * This class does change the Position of the car only in the track.
+     *
+     * @param carIndex of the current car
+     */
+    private void makeCarMoveInTrack(int carIndex) {
+        PositionVector carPositionVector = findChar(getCarId(carIndex));
+        //Removes the Car at Current Pos
+        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
+        carPositionVector = cars.get(carIndex).nextPosition();
+        drawCharOnTrackIndicator(carPositionVector, cars.get(carIndex).getID());
+    }
+
+    /**
+     * This Method will check if the Car could crash at the specific position
+     *
+     * @param positionVector the position to check if the car could crash
+     * @return true if car would crash. Else false.
+     */
+    public boolean willCrashAtPosition(int carIndex, PositionVector positionVector) throws PositionVectorNotValid {
+        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.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 crashPositionVector where the Crash did happen
+     */
+    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(crashPositionVector);
+        drawCharOnTrackIndicator(new PositionVector(crashPositionVector.getX(), crashPositionVector.getY()), CRASH_INDICATOR);
     }
 
     /**
@@ -78,8 +266,16 @@ public class Track implements TrackSpecification {
      */
     @Override
     public Config.SpaceType getSpaceType(PositionVector position) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        //isPositionVectorOnTrack(position); Should be used but we are not allowed to change method head. We don't use function anyway
+        char charAtPosition = track.get(position.getY()).charAt(position.getX());
+        ConfigSpecification.SpaceType[] spaceTypes = ConfigSpecification.SpaceType.values();
+        for (ConfigSpecification.SpaceType spaceType : spaceTypes) {
+            if (spaceType.getValue() == charAtPosition) {
+                return spaceType;
+            }
+        }
+
+        return null;
     }
 
     /**
@@ -89,8 +285,7 @@ public class Track implements TrackSpecification {
      */
     @Override
     public int getCarCount() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return cars.size();
     }
 
     /**
@@ -101,8 +296,7 @@ public class Track implements TrackSpecification {
      */
     @Override
     public Car getCar(int carIndex) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return cars.get(carIndex);
     }
 
     /**
@@ -113,20 +307,19 @@ public class Track implements TrackSpecification {
      */
     @Override
     public char getCarId(int carIndex) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return cars.get(carIndex).getID();
     }
 
     /**
      * Get the position of the specified car.
+     * Returns Null if carIndex not valid
      *
      * @param carIndex The zero-based carIndex number
      * @return A PositionVector containing the car's current position
      */
     @Override
     public PositionVector getCarPos(int carIndex) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return findChar(cars.get(carIndex).getID());
     }
 
     /**
@@ -137,8 +330,7 @@ public class Track implements TrackSpecification {
      */
     @Override
     public PositionVector getCarVelocity(int carIndex) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return cars.get(carIndex).getVelocity();
     }
 
     /**
@@ -152,8 +344,15 @@ public class Track implements TrackSpecification {
      */
     @Override
     public char getCharAtPosition(int y, int x, Config.SpaceType currentSpace) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        char charAtPos = track.get(y).charAt(x);
+        PositionVector positionVector = new PositionVector(x, y);
+        for (Car car : cars) {
+            if (charAtPos == car.getID()) {
+                return charAtPos;
+            }
+        }
+        if (positionVector.equals(findChar(CRASH_INDICATOR))) return CRASH_INDICATOR;
+        return currentSpace.getValue();
     }
 
     /**
@@ -163,7 +362,8 @@ public class Track implements TrackSpecification {
      */
     @Override
     public String toString() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        StringBuilder str = new StringBuilder();
+        for (String line : track) str.append(line).append("\n");
+        return str.toString();
     }
 }

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

@@ -0,0 +1,111 @@
+package ch.zhaw.pm2.racetrack;
+
+import org.beryx.textio.TextIO;
+import org.beryx.textio.TextIoFactory;
+import org.beryx.textio.TextTerminal;
+
+import java.util.List;
+
+public class UserInterface {
+
+    private final TextIO textIO;
+    private final TextTerminal<?> textTerminal;
+
+    /**
+     * Opens a new Terminal Window and prints the welcome Text
+     * @param welcomeText The Text which will be printed after the windows is opened.
+     */
+    public UserInterface(String welcomeText) {
+        textIO = TextIoFactory.getTextIO();
+        textTerminal = textIO.getTextTerminal();
+
+        textTerminal.println(welcomeText + "\n");
+    }
+
+    /**
+     * Prints the given Text in textTerminal
+     * @param text The Text which should be printed.
+     */
+    public void printInformation(String text) {
+        textTerminal.println(text);
+    }
+
+    /**
+     * asks the user to choose one of the options given.
+     * @param text Text which is printed befor the options are printed. Example: "Select Track file:"
+     * @param options List with the options which can be selected.
+     * @return the list index of the selected option
+     */
+    public int selectOption(String text, List<String> options) {
+        textTerminal.println(text + ":");
+        for(int option = 0; option < options.size(); option ++) {
+            textTerminal.println(" " + (option + 1) +  ": " + options.get(option));
+        }
+        return textIO.newIntInputReader().withMinVal(1).withMaxVal(options.size()).read("Enter your choice: ") - 1;
+    }
+
+    /**
+     * gives information which player's turn it is and asks for the direction to accelerate
+     * @param playingCarIndex the index of the player
+     * @param playingCarID the ID of the player
+     * @return the direction which is selected by the player. If null -> quit game
+     */
+    public PositionVector.Direction selectDirection(int playingCarIndex, char playingCarID) {
+        PositionVector.Direction direction = null;
+        textTerminal.println("Playing Car " + playingCarIndex + ": " + playingCarID);
+        textTerminal.println("Directions are based on the number pad:");
+        textTerminal.println("7 8 9    7=up-left,    8=up,               9=up-right");
+        textTerminal.println("4 5 6    4=left,       5=no acceleration,  6=right");
+        textTerminal.println("1 2 3    1=down-left,  2=down,             3=down-right");
+        textTerminal.println("\n10 = quit \n");
+
+        while (direction == null) { //asks until a valid input in entered
+            int number = textIO.newIntInputReader().withMinVal(1).withMaxVal(10).read("choose your Acceleration direction: ");
+            if (number == 10) { //quit game
+                return null;
+            }
+            direction = getDirection(number);
+        }
+        return direction;
+    }
+
+    /**
+     * returns the the associated direction Object
+     * @param number the number which was typed by the user
+     * @return the associated direction. If null -> unknown number
+     */
+    private PositionVector.Direction getDirection(int number) {
+        return switch (number) {
+            case 1 -> PositionVector.Direction.DOWN_LEFT;
+            case 2 -> PositionVector.Direction.DOWN;
+            case 3 -> PositionVector.Direction.DOWN_RIGHT;
+            case 4 -> PositionVector.Direction.LEFT;
+            case 5 -> PositionVector.Direction.NONE;
+            case 6 -> PositionVector.Direction.RIGHT;
+            case 7 -> PositionVector.Direction.UP_LEFT;
+            case 8 -> PositionVector.Direction.UP;
+            case 9 -> PositionVector.Direction.UP_RIGHT;
+            default -> null;
+        };
+    }
+
+    /**
+     * prints the given Track in the terminal
+     * @param track the track which should be printed
+     */
+    public void printTrack(Track track) {
+            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/given/GameSpecification.java

@@ -1,6 +1,7 @@
 package ch.zhaw.pm2.racetrack.given;
 
 import ch.zhaw.pm2.racetrack.PositionVector;
+import ch.zhaw.pm2.racetrack.PositionVectorNotValid;
 
 import java.util.List;
 
@@ -18,11 +19,11 @@ public interface GameSpecification {
 
     int getWinner();
 
-    void doCarTurn(PositionVector.Direction acceleration);
+    void doCarTurn(PositionVector.Direction acceleration) throws PositionVectorNotValid;
 
     void switchToNextActiveCar();
 
     List<PositionVector> calculatePath(PositionVector startPosition, PositionVector endPosition);
 
-    boolean willCarCrash(int carIndex, PositionVector position);
+    boolean willCarCrash(int carIndex, PositionVector position) throws PositionVectorNotValid;
 }

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

@@ -1,5 +1,7 @@
 package ch.zhaw.pm2.racetrack.strategy;
 
+import ch.zhaw.pm2.racetrack.PositionVector;
+
 import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
 
 /**
@@ -9,7 +11,6 @@ public class DoNotMoveStrategy implements MoveStrategy {
 
     @Override
     public Direction nextMove() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return PositionVector.Direction.NONE;
     }
 }

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 direction : directions) {
+                if (direction.toString().equals(line)) {
+                    moveList.add(direction);
+                    break;
+                }
+            }
+        }
+    }
+
     @Override
     public Direction nextMove() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        pointer += 1;
+        if (pointer < moveList.size()) {
+            return moveList.get(pointer);
+        }
+        return null;
     }
 }

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
-        throw new UnsupportedOperationException();
+        // if no more points in the list --> return null
+        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;
+
     }
 }

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

@@ -1,15 +1,24 @@
 package ch.zhaw.pm2.racetrack.strategy;
 
 import ch.zhaw.pm2.racetrack.PositionVector.Direction;
+import ch.zhaw.pm2.racetrack.UserInterface;
 
 /**
  * Let the user decide the next move.
  */
 public class UserMoveStrategy implements MoveStrategy {
+    private UserInterface userInterface;
+    private int carIndex;
+    private char carID;
+
+    public UserMoveStrategy(UserInterface userInterface, int carIndex, char carID) {
+        this.userInterface = userInterface;
+        this.carIndex = carIndex;
+        this.carID = carID;
+    }
 
     @Override
     public Direction nextMove() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return userInterface.selectDirection(carIndex, carID);
     }
 }

src/test/InvalidTracks/sameCar.txt

@@ -0,0 +1,26 @@
+###############################################################
+#################                                 #############
+###############                                     ###########
+###############                                       #########
+###############         ##################            #########
+###############        ####################           #########
+##############        #####################           #########
+############        ######################           ##########
+#########         ######################           ############
+#########       ######################           ##############
+#########      #####################           ################
+#########        #################           ##################
+#########         ################           ##################
+##########         ##################           ###############
+###########         ####################          #############
+###########         #######################          ##########
+##########         ##########################         #########
+#########         ############################         ########
+########         #############################         ########
+#######         ##############################         ########
+######         #############################           ########
+######         ############################           #########
+######                > a                           ###########
+######                > a                        ##############
+########              > b                     #################
+###############################################################

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

@@ -1,187 +0,0 @@
-
-package ch.zhaw.pm2.racetrack;
-
-import ch.zhaw.pm2.racetrack.strategy.*;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-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;
-            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) {
-
-            //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);
-
-            for (PositionVector.Direction direction2 : directions) {
-                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());
-
-        moveStrategy = new MoveListStrategy();
-        car.setMoveStrategy(moveStrategy);
-        assertEquals(moveStrategy, car.getMoveStrategy());
-
-        moveStrategy = new PathFollowerMoveStrategy();
-        car.setMoveStrategy(moveStrategy);
-        assertEquals(moveStrategy, car.getMoveStrategy());
-
-        moveStrategy = new UserMoveStrategy();
-        car.setMoveStrategy(moveStrategy);
-        assertEquals(moveStrategy, car.getMoveStrategy());
-    }
-}

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

@@ -0,0 +1,104 @@
+package ch.zhaw.pm2.racetrack;
+
+import ch.zhaw.pm2.racetrack.strategy.UserMoveStrategy;
+import org.junit.jupiter.api.*;
+
+import java.io.File;
+
+import static ch.zhaw.pm2.racetrack.Game.NO_WINNER;
+
+class GameTest {
+    private UserInterface userInterface;
+    private Game game;
+    private Track track;
+
+    @Nested
+    @DisplayName("Test correct Setup")
+    class Setup {
+        @BeforeEach
+        void setup() {
+            userInterface = new UserInterface("Test");
+            game = new Game(userInterface);
+            track = game.selectTrack(new File(".\\tracks\\challenge.txt"));
+            game.selectMoveStrategy(track.getCar(0),new UserMoveStrategy(new UserInterface("Testing"),0, track.getCarId(0)));
+            game.selectMoveStrategy(track.getCar(1),new UserMoveStrategy(new UserInterface("Testing"),1, track.getCarId(1)));
+
+        }
+
+
+        @Test
+        void getCurrentCarIndex() {
+            Assertions.assertEquals(0,game.getCurrentCarIndex());
+            game.switchToNextActiveCar();
+            Assertions.assertEquals(1,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());
+        }
+    }
+
+    @Nested
+    @DisplayName("Basic manipulation")
+    class manipulation {
+        @BeforeEach
+        void setup() {
+            userInterface = new UserInterface("Test");
+            game = new Game(userInterface);
+            track = game.selectTrack(new File(".\\tracks\\challenge.txt"));
+            game.selectMoveStrategy(track.getCar(0),new UserMoveStrategy(new UserInterface("Testing"),0, track.getCarId(0)));
+            game.selectMoveStrategy(track.getCar(1),new UserMoveStrategy(new UserInterface("Testing"),1, track.getCarId(1)));
+
+        }
+
+        @Test
+        void carTurnCorrect() {
+            try {
+                game.doCarTurn(PositionVector.Direction.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();
+            }
+        }
+
+    }
+}

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());
+        }
+    }
+}

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

@@ -0,0 +1,177 @@
+package ch.zhaw.pm2.racetrack;
+
+import ch.zhaw.pm2.racetrack.given.ConfigSpecification;
+import org.junit.jupiter.api.*;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class TrackTest {
+    Track trackObj;
+
+    @Nested
+    @DisplayName("Positiv Test Cases")
+    class positivClass {
+
+        @BeforeEach
+        void setup() {
+            File file = new File(".\\tracks\\challenge.txt");
+            try {
+                trackObj = new Track(file);
+
+            } catch (Exception | PositionVectorNotValid e) {
+                System.err.println("Error in Test compareTrack" + e.getMessage());
+            }
+        }
+
+        @Test
+        @DisplayName("Create correct amount of Car instance")
+        void checkCars() {
+            Assertions.assertEquals(2, trackObj.getCarCount());
+        }
+
+        @Test
+        @DisplayName("Create Car instance with correct Symbols / Id")
+        void checkCarId() {
+            Assertions.assertEquals('a', trackObj.getCarId(0));
+            Assertions.assertEquals('b', trackObj.getCarId(1));
+        }
+
+
+        @Test
+        @DisplayName("Check getSpaceTyp")
+        void getSpaceTyp() {
+            Assertions.assertEquals(ConfigSpecification.SpaceType.FINISH_RIGHT, trackObj.getSpaceType(new PositionVector(22, 24)));
+        }
+
+        @Test
+        @DisplayName("Find FinishLine")
+        void findFinish() {
+            List<PositionVector> expected = new ArrayList<>();
+            expected.add(new PositionVector(22, 22));
+            expected.add(new PositionVector(22, 23));
+            expected.add(new PositionVector(22, 24));
+            Assertions.assertEquals(expected, trackObj.getFinishLine());
+        }
+
+        @Test
+        @DisplayName("Converts Trackfile correctly to List<String>")
+        void checkTrack() {
+            Track trackObj;
+            try {
+                trackObj = new Track(new File(".\\tracks\\oval-anticlock-right.txt"));
+                List<String> track = new ArrayList<>();
+                track.add("##################################################");
+                track.add("##################################################");
+                track.add("##############                       #############");
+                track.add("##########                              ##########");
+                track.add("#######                                    #######");
+                track.add("######          #################           ######");
+                track.add("#####          ###################           #####");
+                track.add("#####          ###################           #####");
+                track.add("######          #################           ######");
+                track.add("#######             > a                    #######");
+                track.add("##########          >                   ##########");
+                track.add("##############      > b             ##############");
+                track.add("##################################################");
+                track.add("##################################################");
+                Assertions.assertLinesMatch(track, trackObj.getTrack());
+            } catch (FileNotFoundException | InvalidTrackFormatException | PositionVectorNotValid e) {
+                e.printStackTrace();
+            }
+        }
+
+        @Test
+        @DisplayName("Make Car move down on track")
+        void makeCarMoveDown() {
+            PositionVector beforeMove = trackObj.getCarPos(0);
+            trackObj.getCar(0).accelerate(PositionVector.Direction.DOWN);
+            trackObj.moveCar(0);
+            PositionVector afterMove = trackObj.getCarPos(0);
+            Assertions.assertEquals(beforeMove.getY() + 1, afterMove.getY());
+            Assertions.assertEquals(beforeMove.getX(), afterMove.getX());
+        }
+
+        @Test
+        @DisplayName("Make Car move with (0,0) acceleration on track")
+        void makeCarStay() {
+            PositionVector beforeMove = trackObj.getCarPos(0);
+            trackObj.moveCar(0);
+            PositionVector afterMove = trackObj.getCarPos(0);
+            Assertions.assertEquals(beforeMove.getY(), afterMove.getY());
+            Assertions.assertEquals(beforeMove.getX(), afterMove.getX());
+        }
+
+        @Test
+        @DisplayName("Will Car Crash")
+        void willCarCrash() {
+            try {
+                //Car will Crash
+                Assertions.assertTrue(trackObj.willCrashAtPosition(0, new PositionVector(25, 21)));
+                //Car will not Crash and is on track
+                Assertions.assertFalse(trackObj.willCrashAtPosition(0, new PositionVector(7, 22)));
+                //Car will not Crash and is on finishLine
+                Assertions.assertFalse(trackObj.willCrashAtPosition(0, trackObj.getFinishLine().get(0)));
+            } catch (PositionVectorNotValid positionVectorNotValid) {
+                positionVectorNotValid.printStackTrace();
+                Assertions.fail("Test should not throw error");
+            }
+        }
+
+        @Test
+        @DisplayName("Make Car Crash")
+        void makeCarCrash() {
+            try {
+                trackObj.carDoesCrash(0, new PositionVector(6, 22));
+            } catch (PositionVectorNotValid positionVectorNotValid) {
+                positionVectorNotValid.printStackTrace();
+                Assertions.fail("Test should not throw exception");
+            }
+            Assertions.assertEquals(Track.CRASH_INDICATOR, trackObj.getTrack().get(22).charAt(6));
+            Assertions.assertTrue(trackObj.getCar(0).isCrashed());
+        }
+    }
+
+    @Nested
+    @DisplayName("Negative TestCase")
+    class negativeClass {
+        File file;
+
+        @BeforeEach
+        void setup() {
+            file = new File(".\\tracks\\challenge.txt");
+            try {
+                trackObj = new Track(file);
+
+            } catch (Exception | PositionVectorNotValid e) {
+                System.err.println("Error in Test compareTrack" + e.getMessage());
+            }
+        }
+
+        @Test
+        @DisplayName("Throw error if File not found")
+        void canReadFile() {
+            file = new File(".\\tracks\\NotExisting.txt");
+            Assertions.assertThrows(FileNotFoundException.class, () -> new Track(file));
+        }
+
+        @Test
+        @DisplayName("Throw error if File is invalid")
+        void invalidTrackFile() {
+            File testfile = new File(".\\src\\test\\InvalidTracks\\sameCar.txt");
+            Assertions.assertThrows(InvalidTrackFormatException.class, () -> new Track(testfile));
+        }
+
+        @Test
+        @DisplayName("Invalid Position Vector used")
+        void invalidPositionVector() {
+            Assertions.assertThrows(PositionVectorNotValid.class, () -> trackObj.willCrashAtPosition(0, new PositionVector(100, 200)));
+            Assertions.assertThrows(PositionVectorNotValid.class, () -> trackObj.carDoesCrash(1,new PositionVector(200,100)));
+        }
+
+    }
+
+}

tracks/.gitignore

@@ -1 +0,0 @@
-challenge_points.txt