Feedback P1 Ruiz

Feedback P1 Ruiz

README.md

@@ -1,2 +1,51 @@
-# team02-AngryNerds-projekt1-racetrack
-PM2 Team 02 Projekt 1 Racetrack
+
+# PM2 Team 02 Projekt 1 Racetrack
+Racetrack is a pen and paper game that dates back to the early 1960s in this version of the game, the game is digitalized and the math behind it is done automatically rather than calculated by hand and the winner gets informed automatically as well.
+
+The aim of the game is to finish the race faster than your opponent or win by being the only survivor in case the other cars crash.
+
+In order to not crash you have to keep in mind the acceleration and other player's car to get to the finish line safely.
+# Testing
+#### All test can be run by the terminal command:
+    gradlew test
+# Initialization:
+#### The game can be initialized by the terminal command:
+    gradlew run
+You will then be prompted to select a track file from the selection by entering the corresponding number.
+
+#### For each car that is taking part in the race a strategy has to be chosen there are the following options:
+
++ Do not move Strategy
+> This Strategy sets the car stationary, and it won't make any moves during the game staying at the start point indefinitely.
++ User Move Strategy
+> The player is prompted for each move to make a choice the different choices you are able to take are as following:
+> > 1=down-left <br> 2=down<br> 3=down-right<br> 4=left<br> 5=no acceleration<br> 6=right <br> 7=up-left<br> 8=up<br> 9=up-right<br> it is also possible to leave the game when it is your turn by entering 10
++ Move List Strategy
+> For this strategy a predefined list of moves have to be given, the list may contain all allowed moves like mentioned in User Move Strategy
+> > To create your own Move List strategy it needs to be located in /racetrack/moves and be named as *track_name*-car-*character_of_car*.txt and be a txt file.
++ Path Follow Move Strategy
+> A list of points given in a txt file where on each lime a coordinate is placed like (X:24, Y:22) gets used to calculate a path which makes the car cross each point.
+> > To create your own follow move strategy it needs to be located in /racetrack/moves and be named as *track_name*_points.txt and be a txt file.
++ Path Finder Strategy
+> The pathfinder Strategy Calculates a route itself and follows it direction fully automatically.
+
+The shown Track can be interpreted as following:<br>
+'spaces' are part of the raceable track.<br>
+'#' is a Wall<br>
+'>,<,^,v' are finish line components<br>
+'X' is shown if a car crashes at its crash location.<br>
+And every other character represents a car.
+> To create your own track it needs to be located inside /racetrack/tracks and be a txt file. 
+### Determining a winner
+The winner gets determined automatically. <br> The car that first passes the finish line (doing a complete round) is given the win, if all car except one crash the surviving car will be crowned as the winner.<br>The game will inform you of this, and you will have the option to quit the game or play another match.
+
+## Branching Model
+We choose a simple branching model where all starting features got a branch and where merged into the main branch, some branches who needed unfinished code to be completed where taken from the game branch but merged into the main at the end as well.<br> Since there was just one end product  we abstained from using a development branch and merges where done straight into main branch.<br>Commits which contain only documentation and doesn't change any functionality are committed directly into the Main branch.
+
+## Class Diagramm
+To create the best possible insight, all methods that are in the classes that we edited are shown completely. Including the private methods, since they can clearly be distinguished from the public ones through their prefix. <br>
+However, the classes that were already given, i.e. not editable, are also in the class diagram for clarity, but the methods had been omitted since they can be found in the documentation, and the interfaces are just there for grading test purposes. <br><br>
+![Classdiagram of this program](./Klassendiagramm.svg)
+
+## GitHub Project
+Our GitHub Project can be found here: [GitHubProject](https://github.zhaw.ch/PM2-IT21bWIN-ruiz-mach-krea/team02-AngryNerds-projekt1-racetrack/projects)

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,23 @@
+(X:28, Y:22)
+(X:31, Y:22)
+(X:34, Y:22)
+(X:37, Y:22)
+(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)

moves/challenge-car-b.txt

@@ -35,6 +35,3 @@ UP_RIGHT
 UP_RIGHT
 RIGHT
 RIGHT
-
-
-

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

@@ -8,7 +8,7 @@ import ch.zhaw.pm2.racetrack.strategy.MoveStrategy;
  * Uses {@link PositionVector} to store current position on the track grid and current velocity vector.
  * Each car has an identifier character which represents the car on the racetrack board.
  * Also keeps the state, if the car is crashed (not active anymore). The state can not be changed back to uncrashed.
- * The velocity is changed by providing an acelleration vector.
+ * The velocity is changed by providing an acceleration vector.
  * The car is able to calculate the endpoint of its next position and on request moves to it.
  */
 public class Car implements CarSpecification {
@@ -22,6 +22,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}
@@ -40,6 +44,7 @@ public class Car implements CarSpecification {
 
     /**
      * Constructor for class Car
+     *
      * @param id       unique Car identification
      * @param position initial position of the Car
      */
@@ -48,17 +53,62 @@ public class Car implements CarSpecification {
         setPosition(position);
     }
 
+    /**
+     * Returns the id of the car.
+     *
+     * @return id of the car.
+     */
+    public char getID() {
+        return id;
+    }
+
+    /**
+     * Increases the winpoints by one
+     */
+    public void increaseWinPoints() {
+        winPoints++;
+    }
+
+    /**
+     * Decreases the winpoints by one
+     */
+    public void deductWinPoints() {
+        winPoints--;
+    }
+
+    /**
+     * Returns the current value of winpoints.
+     *
+     * @return winpoints of the car
+     */
+    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.
+     * The next position is normally 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 +119,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 +129,17 @@ 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,43 +147,42 @@ 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());
     }
 
     /**
-     * Mark this Car as being crashed.
+     * Marks the car as crashed
      */
     @Override
     public void crash() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        crashed = true;
     }
 
     /**
-     * Returns whether this Car has been marked as crashed.
+     * Returns whether this Car has been marked as crashed or not
      *
      * @return Returns true if crash() has been called on this Car, false otherwise.
      */
     @Override
     public boolean isCrashed() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return crashed;
     }
 
     /**
-     * Set move strategy
-     * @param moveStrategy
-     */
-    public void setMoveStrategy(MoveStrategy moveStrategy) {
-        this.moveStrategy = moveStrategy;
-    }
-
-    /**
-     * Get current move strategy
-     * @return MoveStrategy
+     * Returns the current move Strategy
+     *
+     * @return the current move Strategy
      */
     public MoveStrategy getMoveStrategy() {
         return this.moveStrategy;
     }
+
+    /**
+     * Set the move Strategy of the car.
+     *
+     * @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,12 @@
 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.Arrays;
 import java.util.List;
 
 import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
@@ -13,59 +18,204 @@ 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;
+    private final Config config;
+    private final UserInterface userInterface;
+
+    public Game(UserInterface userInterface, Config config) {
+        this.userInterface = userInterface;
+        this.config = config;
+    }
+
+    /**
+     * This method will initialize the game. Therefore, it interacts with the user via UserInterface
+     *
+     * @return true if the initialization is completed. Returns false if there is an error.
+     */
+    public boolean initPhase() {
+        if (config.getTrackDirectory().listFiles().length > 0) {
+            File selectedTrack = config.getTrackDirectory().listFiles()[userInterface.selectOption("Select Track file", Arrays.asList(config.getTrackDirectory().list()))];
+            try {
+                selectTrack(selectedTrack);
+            } catch (FileNotFoundException e) {
+                userInterface.printInformation("There is an unexpected Error with the track file Path. Add track files only to tracks path. Exit the Game and Fix the Problem");
+                return false;
+            } catch (InvalidTrackFormatException e) {
+                userInterface.printInformation("There is an unexpected Error with the track file. Format does not match specifications! Exit the Game and Fix the Problem");
+                return false;
+            }
+            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");
+            moveStrategies.add("Path Finder Move Strategy");
+            for (int carIndex = 0; carIndex < track.getCarCount(); carIndex++) {
+                Car car = track.getCar(carIndex);
+                MoveStrategy moveStrategy = null;
+                while (moveStrategy == null) {
+                    int moveStrategie = userInterface.selectOption(
+                        "Select Strategy for Car " + carIndex + " (" + track.getCarId(carIndex) + ")", moveStrategies);
+                    switch (moveStrategie) {
+                        case 0 -> moveStrategy = new DoNotMoveStrategy();
+                        case 1 -> moveStrategy = new UserMoveStrategy(userInterface, carIndex, track.getCarId(carIndex));
+                        case 2 -> moveStrategy = getMoveListStrategy(selectedTrack, carIndex);
+                        case 3 -> moveStrategy = getPathFollowerMoveStrategy(selectedTrack, carIndex);
+                        case 4 -> moveStrategy = new PathFinderMoveStrategy(track, carIndex);
+                    }
+                }
+                selectMoveStrategy(car, moveStrategy);
+            }
+            return true;
+        } else {
+            userInterface.printInformation("No track file found!");
+            return false;
+        }
+    }
+
+    /**
+     * creates a PathFollowerMoveStrategy for a specific track and a specific car
+     * @param selectedTrack the selected Track
+     * @param carIndex the Index of the car
+     * @return the created Movestrategy, null if File not found or invalid
+     */
+    private MoveStrategy getPathFollowerMoveStrategy(File selectedTrack, int carIndex) {
+        File selectedFile = null;
+        MoveStrategy moveStrategy = null;
+        for (File file : config.getFollowerDirectory().listFiles()) {
+            if (file.toString().equals(config.getFollowerDirectory().toString() + "\\" + selectedTrack.getName().split("\\.")[0] + "_points.txt")) {
+                selectedFile = file;
+            }
+        }
+        if (selectedFile != null) {
+            try {
+                moveStrategy = new PathFollowerMoveStrategy(selectedFile, track.getCarPos(carIndex));
+            } catch (FileNotFoundException e) {
+                e.printStackTrace();
+                userInterface.printInformation("There is no Point-List implemented. Choose another Strategy!");
+            } catch (InvalidFileFormatException e) {
+                e.printStackTrace();
+                userInterface.printInformation("Invalid Point-List format. Change Strategy and clean Point-List");
+            }
+        } else {
+            userInterface.printInformation("There is no Point-List implemented. Choose another Strategy!");
+        }
+        return moveStrategy;
+    }
+
+    /**
+     * creates a MoveListStrategy for a specific track and a specific car
+     * @param selectedTrack the selected Track
+     * @param carIndex the Index of the car
+     * @return the created Movestrategy, null if File not found or invalid
+     */
+    private MoveStrategy getMoveListStrategy(File selectedTrack, int carIndex) {
+        File selectedFile = null;
+        MoveStrategy moveStrategy = null;
+        for (File file : config.getMoveDirectory().listFiles()) {
+            if (file.toString().equals(config.getMoveDirectory().toString() + "\\" + selectedTrack.getName().split("\\.")[0] + "-car-" + track.getCar(carIndex).getID() + ".txt")) {
+                selectedFile = file;
+            }
+        }
+        if (selectedFile != null) {
+            try {
+                moveStrategy = new MoveListStrategy(selectedFile);
+            } catch (FileNotFoundException e) {
+                userInterface.printInformation("There is no Move-List implemented. Choose another Strategy!");
+                e.printStackTrace();
+            } catch (InvalidFileFormatException e) {
+                userInterface.printInformation("Invalid Data in Move-List. Choose another Strategy and clean the File");
+                e.printStackTrace();
+            }
+        } else {
+            userInterface.printInformation("There is no Move-List implemented. Choose another Strategy!");
+        }
+        return moveStrategy;
+    }
+
+    /**
+     * Selects the desired track and returns it.
+     * The functionality was taken out of init to automate testing.
+     *
+     * @param selectedTrack the Track which was selected by user
+     */
+    Track selectTrack(File selectedTrack) throws InvalidTrackFormatException, FileNotFoundException {
+        track = new Track(selectedTrack);
+        return track;
+    }
+
+    /**
+     * Sets a desired move strategy for a desired car.
+     * 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.
+     * Gets 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();
+        for (int i = 0; i < track.getCarCount(); i++) {
+            if (track.getCar(i).getWinPoints() == 1) {
+                return i;
+            }
+        }
+        if (onlyOneCarLeft()) {
+            return currentCarIndex;
+        }
+        return NO_WINNER;
     }
 
     /**
@@ -91,13 +241,69 @@ public class Game implements GameSpecification {
      * <p>The calling method must check the winner state and decide how to go on. If the winner is different
      * than {@link Game#NO_WINNER}, or the current car is already marked as crashed the method returns immediately.</p>
      *
-     * @param acceleration A Direction containing the current cars acceleration vector (-1,0,1) in x and y direction
+     * @param acceleration A Direction containing the current car's acceleration vector (-1,0,1) in x and y direction
      *                     for this turn
      */
     @Override
     public void doCarTurn(Direction acceleration) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        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;
+            }
+        }
+        int newWinPoints = track.calculateNewWinPoints(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition());
+        if (newWinPoints == 1) {
+            track.getCar(currentCarIndex).increaseWinPoints();
+        } else if (newWinPoints == -1) {
+            track.getCar(currentCarIndex).deductWinPoints();
+        }
+        if (crashPosition != null) {
+            track.carDoesCrash(currentCarIndex, crashPosition);
+        } else {
+            track.moveCar(currentCarIndex);
+        }
+    }
+
+    /**
+     * This method is in charge of changing the players and checking if a winner is found if there is no winner null will be returned.
+     * If a winner is found the game will return the char of the winning player.
+     *
+     * @return the ID of the winning car return null if there is no winner.
+     */
+    public String gamePhase() {
+        boolean quit = false;
+        while (carsMoving() && getWinner() == NO_WINNER && !quit) {
+            userInterface.printInformation("Player " + track.getCar(currentCarIndex).getID() + "'s turn!");
+            userInterface.printTrack(track);
+            Direction direction;
+            direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
+            if (direction == null) {
+                if (track.getCar(currentCarIndex).getMoveStrategy() instanceof UserMoveStrategy) {
+                    quit = true;
+                    direction = Direction.NONE;
+                } else {
+                    track.getCar(currentCarIndex).setMoveStrategy(new DoNotMoveStrategy());
+                    direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
+                }
+            }
+            doCarTurn(direction);
+            switchToNextActiveCar();
+        }
+        userInterface.printInformation("The game has finished!");
+        userInterface.printTrack(track);
+        int indexWinner = getWinner();
+        if (indexWinner == NO_WINNER) {
+            return null;
+        }
+        return String.valueOf(track.getCar(indexWinner).getID());
     }
 
     /**
@@ -105,8 +311,13 @@ 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());
     }
 
     /**
@@ -117,25 +328,54 @@ 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.
      */
     @Override
     public List<PositionVector> calculatePath(PositionVector startPosition, PositionVector endPosition) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return track.calculatePointsOnPath(startPosition, endPosition);
     }
 
     /**
      * 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();
+        return track.willCrashAtPosition(carIndex, position);
+    }
+
+    /**
+     * Checks if there is just one player left in the game being able to make moves.
+     *
+     * @return true if there is just one car left false there are more than one car left in game
+     */
+    public boolean onlyOneCarLeft() {
+        int carsLeft = 0;
+        for (int carIndex = 0; carIndex < track.getCarCount(); carIndex++) {
+            if (!track.getCar(carIndex).isCrashed()) {
+                carsLeft++;
+            }
+        }
+        return !(carsLeft > 1);
+    }
+
+    /**
+     * Checks if all cars have implemented the do not move strategy, so the game can determine it will end in a draw.
+     *
+     * @return true if all players have implemented do not move false otherwise
+     */
+    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,9 +1,18 @@
 package ch.zhaw.pm2.racetrack;
 
 /**
- * Class for Exception when invalid Fileformat is used.
+ * Class for Exception when an invalid file format is used.
  */
 public class InvalidFileFormatException extends Exception {
+    public InvalidFileFormatException() {
+        super();
+    }
+
+    /**
+     * Constructor that is used when an error message is given with the exception.
+     *
+     * @param errorMessage is the message to be displayed
+     */
     public InvalidFileFormatException(String errorMessage) {
         super(errorMessage);
     }

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

@@ -4,7 +4,17 @@ package ch.zhaw.pm2.racetrack;
  * Class for Exception when invalid track format is used.
  */
 public class InvalidTrackFormatException extends Exception {
+    public InvalidTrackFormatException() {
+        super();
+    }
+
+    /**
+     * Constructor that is used when an error message is given with the exception.
+     *
+     * @param errorMessage is the message to be displayed
+     */
     public InvalidTrackFormatException(String errorMessage) {
         super(errorMessage);
     }
+
 }

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

@@ -0,0 +1,49 @@
+package ch.zhaw.pm2.racetrack;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Class containing the main method
+ *
+ * @author Roman Schenk
+ */
+public class Main {
+    /**
+     * Method creating the game and initializing the Configs and Userinterface.
+     * Starts and initializes a new game until the user decides to stop the game.
+     * In charge of closing the user interface when user decides to stop the game
+     *
+     * @param args no arguments needed
+     */
+    public static void main(String[] args) {
+        UserInterface userInterface = new UserInterface("Hello and Welcome to Racetrack by Team02-\"AngryNerds\"");
+        Config config = new Config();
+        while (true) {
+            Game game = new Game(userInterface, config);
+            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/Track.java

@@ -1,9 +1,15 @@
 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.FileInputStream;
 import java.io.FileNotFoundException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
 
 /**
  * This class represents the racetrack board.
@@ -39,9 +45,9 @@ import java.io.FileNotFoundException;
  *       There are 1 to {@link Config#MAX_CARS} allowed. </li>
  * </ul>
  *
- * <p>All lines must have the same length, used to initialize the grid width).
+ * <p>All lines must have the same length, used to initialize the grid width.
  * Beginning empty lines are skipped.
- * The the tracks ends with the first empty line or the file end.<br>
+ * The tracks ends with the first empty line or the file end.<br>
  * An {@link InvalidTrackFormatException} is thrown, if
  * <ul>
  *   <li>not all track lines have the same length</li>
@@ -49,24 +55,216 @@ import java.io.FileNotFoundException;
  *   <li>the file contains more than {@link Config#MAX_CARS} cars</li>
  * </ul>
  *
- * <p>The Track can return a String representing the current state of the race (including car positons)</p>
+ * <p>The Track can return a String representing the current state of the race (including car positions)</p>
  */
 public class Track implements TrackSpecification {
 
     public static final char CRASH_INDICATOR = 'X';
-
-    // TODO: Add necessary variables
+    private final List<String> track;
+    private final List<Car> cars;
+    private final List<PositionVector> finishLine;
+    private ConfigSpecification.SpaceType finishTyp;
 
     /**
-     * Initialize a Track from the given track file.
+     * Initializes the Track from the given track File including the cars.
+     * Throws a corresponding error if one of the conditions are not met to build a track.
      *
      * @param trackFile Reference to a file containing the track data
      * @throws FileNotFoundException       if the given track file could not be found
      * @throws InvalidTrackFormatException if the track file contains invalid data (no track lines, ...)
      */
     public Track(File trackFile) throws FileNotFoundException, InvalidTrackFormatException {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        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), StandardCharsets.UTF_8);
+        while (scanner.hasNextLine()) {
+            track.add(scanner.nextLine());
+        }
+    }
+
+    /**
+     * Goes through the track ArrayList and determines the locations of each car and initializes them at the location.
+     *
+     * @throws InvalidTrackFormatException is thrown if a car is found more than once inside the track.
+     */
+    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 yPosition = 0; yPosition < track.size(); yPosition++) {
+            String line = track.get(yPosition);
+            for (int xPosition = 0; xPosition < line.length(); xPosition++) {
+                char possibleCarChar = line.charAt(xPosition);
+                if (!allSpaceTypesAsChar.contains(possibleCarChar)) {
+                    if (usedSymbolForCar.contains(possibleCarChar)) {
+                        throw new InvalidTrackFormatException("More than one car on track!");
+                    }
+                    usedSymbolForCar.add(possibleCarChar);
+                    cars.add(new Car(possibleCarChar, new PositionVector(xPosition, yPosition)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Determines the finish line and saves it in a list, throws an Exception if none is found.
+     *
+     * @throws InvalidTrackFormatException thrown if no finish line is found
+     */
+    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("No finish line found!");
+        }
+        finishTyp = getSpaceType(finishLine.get(0));
+        for (PositionVector positionVector : finishLine) {
+            if (getSpaceType(positionVector) != finishTyp) {
+                throw new InvalidTrackFormatException("Inconsistent finish line found!");
+            }
+        }
+    }
+
+    /**
+     * Method to find the PositionVector of a chosen character
+     *
+     * @param symbol char that we are looking for on the track
+     * @return the PositionVector of the desired char
+     */
+    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;
+    }
+
+    /**
+     * Method that places a character at a chosen position
+     *
+     * @param positionVector position where char will be placed
+     * @param symbol         char that should be placed at desired position
+     */
+    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);
+    }
+
+    /**
+     * Method that returns the finish line as a List
+     *
+     * @return finishLine List
+     */
+    public List<PositionVector> getFinishLine() {
+        return finishLine;
+    }
+
+    /**
+     * Returns the whole Track as List of Strings
+     *
+     * @return track as List of Strings
+     */
+    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 Method does change the Position of the car inside the track object.
+     *
+     * @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 finish line 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 would crash at the specific position
+     *
+     * @param positionVector the position to check if the car would crash
+     * @return true if crash otherwise false
+     */
+    public boolean willCrashAtPosition(int carIndex, PositionVector positionVector) {
+        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 mark the Car as crashed inside the track and the car Object.
+     *
+     * @param carIndex            of car that will be marked as crashed
+     * @param crashPositionVector of the location of the crash
+     */
+    public void carDoesCrash(int carIndex, PositionVector crashPositionVector) {
+        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);
     }
 
     /**
@@ -74,23 +272,29 @@ public class Track implements TrackSpecification {
      * If the location is outside the track bounds, it is considered a wall.
      *
      * @param position The coordinates of the position to examine
-     * @return The type of track position at the given location
+     * @return The type of space at the desired position
      */
     @Override
     public Config.SpaceType getSpaceType(PositionVector position) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        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 ConfigSpecification.SpaceType.WALL;
     }
 
     /**
-     * Return the number of cars.
+     * Return the number of cars that are located in a track
      *
-     * @return Number of cars
+     * @return number of cars as int
      */
     @Override
     public int getCarCount() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return cars.size();
     }
 
     /**
@@ -101,8 +305,7 @@ public class Track implements TrackSpecification {
      */
     @Override
     public Car getCar(int carIndex) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return cars.get(carIndex);
     }
 
     /**
@@ -113,20 +316,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 +339,7 @@ public class Track implements TrackSpecification {
      */
     @Override
     public PositionVector getCarVelocity(int carIndex) {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return cars.get(carIndex).getVelocity();
     }
 
     /**
@@ -146,14 +347,133 @@ public class Track implements TrackSpecification {
      * If there is a crashed car at the position, {@link #CRASH_INDICATOR} is returned.
      *
      * @param y            position Y-value
-     * @param x            position X-vlaue
+     * @param x            position X-value
      * @param currentSpace char to return if no car is at position (x,y)
      * @return character representing position (x,y) on the track
      */
     @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();
+    }
+
+    /**
+     * Determines all points that lie between the two position vectors including the endpoint VectorPosition using the  Bresenham algorithm.
+     *
+     * @param startPosition PositionVector of the finish coordinate
+     * @param endPosition   PositionVector of the start coordinate
+     * @return ArrayList containing PositionVectors of all position that are between the start and finish including the finish position.
+     */
+    public ArrayList<PositionVector> calculatePointsOnPath(PositionVector startPosition, PositionVector endPosition) {
+        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;
+    }
+
+    /**
+     * This method will check if a car is passing the finish line.
+     * If the car is passing the finish line in the wrong direction, the car will lose a winpoint.
+     * If the car is passing the finish line in the correct direction, the car will gain a winpoint.
+     *
+     * @param start  the start position of the car
+     * @param finish the expected finish position of the car after the move
+     * @return Number of new winpoints for the current player.
+     */
+    public int calculateNewWinPoints(PositionVector start, PositionVector finish) {
+        List<PositionVector> path = calculatePointsOnPath(start, finish);
+        for (PositionVector point : path) {
+            switch (getSpaceType(point)) {
+                case FINISH_UP:
+                    if (start.getY() > finish.getY()) {
+                        return 1;
+                    } else if (start.getY() < finish.getY()) {
+                        return -1;
+                    }
+                    break;
+                case FINISH_DOWN:
+                    if (start.getY() < finish.getY()) {
+                        return 1;
+                    } else if (start.getY() > finish.getY()) {
+                        return -1;
+                    }
+                    break;
+                case FINISH_RIGHT:
+                    if (start.getX() < finish.getX()) {
+                        return 1;
+                    } else if (start.getX() > finish.getX()) {
+                        return -1;
+                    }
+                    break;
+                case FINISH_LEFT:
+                    if (start.getX() > finish.getX()) {
+                        return 1;
+                    } else if (start.getX() < finish.getX()) {
+                        return -1;
+                    }
+                    break;
+            }
+        }
+        return 0;
     }
 
     /**
@@ -163,7 +483,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,120 @@
+package ch.zhaw.pm2.racetrack;
+
+import org.beryx.textio.TextIO;
+import org.beryx.textio.TextIoFactory;
+import org.beryx.textio.TextTerminal;
+
+import java.util.List;
+
+/**
+ * Class representing the Userinterface.
+ * Used to get inputs from users via text io.
+ *
+ * @author Roman Schenk
+ */
+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);
+    }
+
+    /**
+     * Method which asks the user to choose one of the options given.
+     *
+     * @param text    Text which is printed before 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 is at turn and asks for the direction to accelerate or quit the game.
+     *
+     * @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;
+    }
+
+    /**
+     * Method which returns 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;
+        };
+    }
+
+    /**
+     * Method to print 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 of 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/DoNotMoveStrategy.java

@@ -1,15 +1,21 @@
 package ch.zhaw.pm2.racetrack.strategy;
 
+import ch.zhaw.pm2.racetrack.PositionVector;
+
 import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
 
 /**
- * Do not accelerate in any direction.
+ * This Class represents the DoNotMoveStrategy.
  */
 public class DoNotMoveStrategy implements MoveStrategy {
 
+    /**
+     * This method will be used to return the next Direction for the car.
+     *
+     * @return a NONE Direction
+     */
     @Override
     public Direction nextMove() {
-        // TODO: implementation
-        throw new UnsupportedOperationException();
+        return PositionVector.Direction.NONE;
     }
 }

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

@@ -1,12 +1,68 @@
 package ch.zhaw.pm2.racetrack.strategy;
 
+import ch.zhaw.pm2.racetrack.InvalidFileFormatException;
 import ch.zhaw.pm2.racetrack.PositionVector.Direction;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ * This Class represent the MoveListStrategy. The Directions returned by the
+ * nextMove() are written down in a List.
+ */
 public class MoveListStrategy implements MoveStrategy {
 
+    private final List<Direction> moveList;
+    private int pointer;
+
+    public MoveListStrategy(File moveListFile) throws FileNotFoundException, InvalidFileFormatException {
+        moveList = new ArrayList<>();
+        pointer = -1;
+        readFile(moveListFile);
+    }
+
+    /**
+     * This Method will read in a File and checks line by line if the file contains a valid direction.
+     * If so the direction will be added to the moveList.
+     *
+     * @param trackFile the file to read in the directions
+     * @throws FileNotFoundException if the file does not exist.
+     */
+    private void readFile(File trackFile) throws FileNotFoundException, InvalidFileFormatException {
+        Scanner scanner = new Scanner(new FileInputStream(trackFile), StandardCharsets.UTF_8);
+        Direction[] directions = Direction.values();
+        while (scanner.hasNextLine()) {
+            boolean validLine = false;
+            String line = scanner.nextLine();
+            for (Direction direction : directions) {
+                if (direction.toString().equals(line)) {
+                    moveList.add(direction);
+                    validLine = true;
+                    break;
+                }
+            }
+            if (!(validLine || line.equals(""))) {
+                throw new InvalidFileFormatException("The File contains invalid data!");
+            }
+        }
+    }
+
+    /**
+     * This method will be used to return the next Direction for the car.
+     *
+     * @return the next direction from the list. Returns null if the list is empty.
+     */
     @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/PathFinderMoveStrategy.java

@@ -0,0 +1,223 @@
+package ch.zhaw.pm2.racetrack.strategy;
+
+import ch.zhaw.pm2.racetrack.PositionVector;
+import ch.zhaw.pm2.racetrack.Track;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Strategy which calculates the path automatically
+ */
+public class PathFinderMoveStrategy implements MoveStrategy {
+    private final Track track;
+    private final int carIndex;
+    private List<PositionVector.Direction> moveList;
+    // the index of the next move in moveList
+    private int pointer;
+    // all Directions which can be used for acceleration
+    private final PositionVector.Direction[] allDirections;
+    // List of all States (combination of Position and Velocity) which are already reached with a calculated move.
+    private List<State> calculatedStates;
+
+
+    /**
+     * Constructor which initialises the needed variables and creates the MoveList
+     *
+     * @param track track instance of the game
+     * @param carIndex index of the car which owns this moveStrategy
+     */
+    public PathFinderMoveStrategy(Track track, int carIndex) {
+        this.track = track;
+        this.carIndex = carIndex;
+        allDirections = PositionVector.Direction.values();
+        createMoveList();
+    }
+
+    /**
+     * Method to create a working moveList
+     */
+    private void createMoveList() {
+        // if Movelist is recreated next move will be the first move in moveList
+        pointer = 0;
+        calculatedStates = new ArrayList<>();
+        PossibleMove finishedMove = null;
+        List<PossibleMove> possibleMoves = new ArrayList<>();
+
+        // create a PossibleMove object for each direction which doesn't end with a crash.
+        for (PositionVector.Direction direction : allDirections) {
+            PossibleMove newMove = new PossibleMove(null, direction);
+            if (!newMove.crashed()) {
+                possibleMoves.add(newMove);
+            }
+
+        }
+
+        // while no PossibleMove crosses the finish line
+        // every PossibleMove will be accelerated in each direction to find a Move which finishes.
+        while (finishedMove == null) {
+            List<PossibleMove> newMoves = new ArrayList<>();
+            for (PossibleMove previousMove : possibleMoves) {
+                for (PositionVector.Direction direction : allDirections) {
+                    PossibleMove newMove = new PossibleMove(previousMove, direction);
+                    State newState = new State(newMove.endPosition, newMove.endVelocity);
+                    //only use the new created Possible Move if it doesn't crash, end State isn't in List of calculatedStates
+                    // and if there is no move found yet which is finished.
+                    if (!(newMove.crashed() || alreadyCalculated(newState) || finishedMove != null)) {
+                        if (newMove.finished()) {
+                            finishedMove = newMove;
+                        } else {
+                            calculatedStates.add(newState);
+                            newMoves.add(newMove);
+                        }
+                    }
+                }
+            }
+            possibleMoves = newMoves;
+
+        }
+
+        // if a finished Move is found save its directions as moveList
+        moveList = finishedMove.directions;
+    }
+
+    /**
+     * Method to check if a State is already in List calculatedStates
+     *
+     * @param state the State which should be checked
+     * @return true if it is in List, false if it isn't in List
+     */
+    private boolean alreadyCalculated(State state) {
+        for (State calculatedState : calculatedStates) {
+            if (state.equals(calculatedState)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Combination of position and velocity
+     */
+    public static class State {
+        final PositionVector position;
+        final PositionVector velocity;
+
+        /**
+         * Constructor of State
+         *
+         * @param position the PositionVector object with coordinates of the Position
+         * @param velocity the PositionVector object with coordinates of the Velocity
+         */
+        public State(PositionVector position, PositionVector velocity) {
+            this.position = position;
+            this.velocity = velocity;
+        }
+
+        /**
+         * Checks if a state has the same Position and the same Velocity
+         *
+         * @param compareState the State object to compare
+         * @return true if it is equal, false if it is not equal
+         */
+        public boolean equals(State compareState) {
+            return compareState.position.equals(position) && compareState.velocity.equals(velocity);
+        }
+    }
+
+    /**
+     * PossibleMove represents a move which can be done by the player.
+     */
+    public class PossibleMove {
+        // List of all directions used for the previous moves and the direction of the current move (the highest Index).
+        final List<PositionVector.Direction> directions;
+        // Position of the car bevor the move is executed
+        final PositionVector startPosition;
+        // Position of the car after the move is executed
+        final PositionVector endPosition;
+        // Velocity of the car after the move is executed
+        final PositionVector endVelocity;
+
+        /**
+         * Constructor of PossibleMove
+         *
+         * @param previousMove  The move which must be executed bevor this move can be executed
+         * @param nextDirection The direction of the move
+         */
+        public PossibleMove(PossibleMove previousMove, PositionVector.Direction nextDirection) {
+            // Velocity of the car bevor the move is executed
+            PositionVector startVelocity;
+
+            directions = new ArrayList<>();
+            // check if there was a previousMove.
+            if (previousMove != null) {
+                directions.addAll(previousMove.directions); //copy the LIst of Directions from the previousMove
+                startPosition = previousMove.endPosition; //use the endPosition from previousMove as startPosition
+                startVelocity = previousMove.endVelocity; //use the endVelocity from previousMove as startVelocity
+            } else { //if there was no previousMove
+                startPosition = track.getCarPos(carIndex); //use the current Position of the car from track as startPosition
+                startVelocity = track.getCar(carIndex).getVelocity(); //use the current Velocity of the car from track as startVelocity
+            }
+            directions.add(nextDirection);
+            endVelocity = new PositionVector(startVelocity.getX() + nextDirection.vector.getX(), startVelocity.getY() + nextDirection.vector.getY());
+            endPosition = new PositionVector(startPosition.getX() + endVelocity.getX(), startPosition.getY() + endVelocity.getY());
+        }
+
+        /**
+         * check if the finish line is crossed (in correct direction) if this move is executed
+         *
+         * @return true if finish line will be crossed
+         */
+        public boolean finished() {
+            return track.calculateNewWinPoints(startPosition, endPosition) == 1;
+        }
+
+        /**
+         * checks if the car will crash or finishline will be crossed in wrong direction if this move is executed
+         *
+         * @return true if car will crash
+         */
+        public boolean crashed() {
+            List<PositionVector> points = track.calculatePointsOnPath(startPosition, endPosition);
+            for (PositionVector point : points) {
+                if (track.willCrashAtPosition(carIndex, point)) {
+                    return true;
+                }
+            }
+            return track.calculateNewWinPoints(startPosition, endPosition) == -1;
+        }
+
+    }
+
+
+    /**
+     * Checks if the next Move in moveList will crash. If no crash next move in moveList will be executed.
+     * If crash the moveList will be recreated.
+     *
+     * @return the direction of acceleration which should be executed.
+     */
+    @Override
+    public PositionVector.Direction nextMove() {
+        if (pointer < moveList.size()) {
+            PositionVector.Direction direction = moveList.get(pointer);
+            PositionVector currentVelocity = track.getCarVelocity(carIndex);
+            PositionVector newVelocity = new PositionVector(currentVelocity.getX() + direction.vector.getX(), currentVelocity.getY() + direction.vector.getY());
+            PositionVector currentPosition = track.getCarPos(carIndex);
+            PositionVector newPosition = new PositionVector(currentPosition.getX() + newVelocity.getX(), currentPosition.getY() + newVelocity.getY());
+            for (PositionVector point : track.calculatePointsOnPath(currentPosition, newPosition)) {
+                if (track.willCrashAtPosition(carIndex, point)) {
+                    createMoveList();
+                    pointer = 0;
+                    direction = moveList.get(pointer);
+                    break;
+                }
+            }
+
+            pointer += 1;
+            return direction;
+        }
+        return null;
+    }
+
+
+}

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

@@ -1,15 +1,133 @@
 package ch.zhaw.pm2.racetrack.strategy;
 
+import ch.zhaw.pm2.racetrack.InvalidFileFormatException;
+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.nio.charset.StandardCharsets;
+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 final 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 trackFile     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(File trackFile, PositionVector startPosition) throws FileNotFoundException, InvalidFileFormatException {
+        pointList = new ArrayList<>();
+        pointer = 0;
+        readFile(trackFile);
+        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, InvalidFileFormatException {
+        Scanner scanner = new Scanner(new FileInputStream(trackFile), StandardCharsets.UTF_8);
+        while (scanner.hasNextLine()) {
+            String line = scanner.nextLine();
+            String[] coordinates = line.split("(\\(X:|, Y:|\\))");
+            try {
+                pointList.add(new PositionVector(Integer.parseInt(coordinates[1]), Integer.parseInt(coordinates[2])));
+            } catch (NumberFormatException e) {
+                throw new InvalidFileFormatException("Invalid File Format");
+            }
+        }
+    }
+
+    /**
+     * 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,30 @@
 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.
+ * Therefore, it uses the UserInterface class to ask for a direction.
  */
 public class UserMoveStrategy implements MoveStrategy {
+    private final UserInterface userInterface;
+    private final int carIndex;
+    private final char carID;
 
+    public UserMoveStrategy(UserInterface userInterface, int carIndex, char carID) {
+        this.userInterface = userInterface;
+        this.carIndex = carIndex;
+        this.carID = carID;
+    }
+
+    /**
+     * Uses the interface to determine which move the user takes.
+     *
+     * @return the next taken move as Direction
+     */
     @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

@@ -0,0 +1,233 @@
+
+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.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Class that contains all test for the Class Car
+ *
+ * @author Roman Schenk
+ */
+class CarTest {
+
+    Car car;
+
+    // Default coordinates for tests
+    final int DEFAULT_X = 10;
+    final int DEFAULT_Y = 10;
+    final char DEFAULT_ID = 'f';
+
+    /**
+     * Creates 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));
+    }
+
+    /**
+     * Checks if the method getID returns the correct value
+     */
+    @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 thrown and position kept 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
+        PositionVector.Direction[] directions = 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 actual 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(new File(".\\moves\\challenge-car-a.txt"));
+        } catch (FileNotFoundException | InvalidFileFormatException e) {
+            Assertions.fail();
+        }
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+
+        try {
+            moveStrategy = new PathFollowerMoveStrategy(new File(".\\follower\\challenge_points.txt"), new PositionVector(0, 0));
+        } catch (FileNotFoundException | InvalidFileFormatException e) {
+            e.printStackTrace();
+        }
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+
+        moveStrategy = new UserMoveStrategy(new UserInterface("Hello"), 0, 'a');
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+    }
+
+    /**
+     * Tests if getWinPoints returns the correct value.
+     */
+    @Test
+    void getWinPoints() {
+        assertEquals(0, car.getWinPoints());
+    }
+
+    /**
+     * Tests if winpoints increase functions properly.
+     */
+    @Test
+    void increaseWinPoints() {
+        car.increaseWinPoints();
+        assertEquals(1, car.getWinPoints());
+    }
+
+    /**
+     * Tests if the deductions of winpoints functions properly.
+     */
+    @Test
+    void deductWinPoints() {
+        car.deductWinPoints();
+        assertEquals(-1, car.getWinPoints());
+    }
+
+}

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

@@ -0,0 +1,317 @@
+package ch.zhaw.pm2.racetrack;
+
+import ch.zhaw.pm2.racetrack.strategy.UserMoveStrategy;
+import org.junit.jupiter.api.*;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+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. The Class is split up in nested classes.
+ *
+ * @author Andrin Fassbind
+ */
+class GameTest {
+    private UserInterface userInterface;
+    private Game game;
+    private Track track;
+
+    private final String TRACK_FILE_PATH = ".\\tracks\\challenge.txt";
+    private final int CAR_INDEX_ONE = 0;
+    private final int CAR_INDEX_TWO = 1;
+
+    /**
+     * This nested Class tests if the game gets initiated correctly.
+     */
+    @Nested
+    @DisplayName("Test correct Setup")
+    class Setup {
+
+        /**
+         * Sets up getting the Config, Game and Userinterface for the following tests.
+         */
+        @BeforeEach
+        void setup() {
+            userInterface = new UserInterface("Test");
+            Config config = new Config();
+            game = new Game(userInterface, config);
+            try {
+                track = game.selectTrack(new File(TRACK_FILE_PATH));
+            } catch (InvalidTrackFormatException | FileNotFoundException e) {
+                e.printStackTrace();
+                Assertions.fail();
+            }
+            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)));
+
+        }
+
+        /**
+         * Tests if car index is correct
+         */
+        @Test
+        void getCurrentCarIndex() {
+            Assertions.assertEquals(CAR_INDEX_ONE, game.getCurrentCarIndex());
+            game.switchToNextActiveCar();
+            Assertions.assertEquals(CAR_INDEX_TWO, game.getCurrentCarIndex());
+        }
+
+        /**
+         * Checks if CarId matches char given in track file
+         */
+        @Test
+        void getCarId() {
+            Assertions.assertEquals('a', game.getCarId(0));
+            Assertions.assertEquals('b', game.getCarId(1));
+        }
+
+        /**
+         * Checks initial car position
+         */
+        @Test
+        void getCarPosition() {
+            Assertions.assertEquals(new PositionVector(24, 22), game.getCarPosition(0));
+            Assertions.assertEquals(new PositionVector(24, 24), game.getCarPosition(1));
+        }
+
+        /**
+         * Checks if initial car velocity is 0,0
+         */
+        @Test
+        void getCarVelocity() {
+            Assertions.assertEquals(new PositionVector(0, 0), game.getCarVelocity(0));
+            Assertions.assertEquals(new PositionVector(0, 0), game.getCarVelocity(1));
+        }
+
+        /**
+         * Checks initial winner
+         */
+        @Test
+        void getWinner() {
+            Assertions.assertEquals(NO_WINNER, game.getWinner());
+        }
+
+        /**
+         * Checks correct initial state
+         */
+        @Test
+        void onlyOneCarLeft() {
+            Assertions.assertFalse(game.onlyOneCarLeft());
+        }
+
+        /**
+         * Checks if cars are able to move
+         */
+        @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");
+            Config config = new Config();
+            game = new Game(userInterface, config);
+            try {
+                track = game.selectTrack(new File(TRACK_FILE_PATH));
+            } catch (InvalidTrackFormatException | FileNotFoundException e) {
+                e.printStackTrace();
+                Assertions.fail();
+            }
+            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)));
+
+        }
+
+        /**
+         * Checks if car does change velocity specified by direction input
+         */
+        @Test
+        void carTurnCorrect() {
+            game.doCarTurn(RIGHT);
+            Assertions.assertEquals(new PositionVector(1, 0), game.getCarVelocity(0));
+        }
+
+        /**
+         *  Checks if car crash is set if a car crashes.
+         */
+        @Test
+        void carCrash() {
+            game.doCarTurn(PositionVector.Direction.UP);
+            Assertions.assertTrue(game.onlyOneCarLeft());
+        }
+    }
+
+    /**
+     * This nested Class tests a play trough and implements a userInterface which pretends to be a real player.
+     * At the end of every Test the user interface stays open for 10 more sec to visualize the game.
+     */
+    @Nested
+    @DisplayName("Playtrough")
+    class Play {
+        private Game game;
+
+        /**
+         * This method will start a game instance on the challenge track. Car a uses MoveListStrategy. Car b uses DoNotMoveStrategy
+         */
+        @Test
+        void winner() {
+            game = new Game(new Interface("Test",new Integer[]{0,2,0},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}), new Config());
+            game.initPhase();
+            Assertions.assertEquals("a",game.gamePhase());
+        }
+
+        /**
+         * Will start a game instance where car a does crash.
+         */
+        @Test
+        void crashA() {
+            game = new Game(new Interface("Test",new Integer[]{0,1,0},new PositionVector.Direction[]{UP}), new Config());
+            game.initPhase();
+            Assertions.assertEquals("b",game.gamePhase());
+        }
+
+        /**
+         * Checks that a car cant win before finishing a complete round around the track.
+         */
+        @Test
+        void passFinishLineInWrongDirection() {
+            game = new Game(new Interface("Test",new Integer[]{1,0,1},new PositionVector.Direction[]{LEFT,NONE,NONE,RIGHT,RIGHT}), new Config());
+            game.initPhase();
+            Assertions.assertEquals("a",game.gamePhase());
+        }
+
+        /**
+         * Does wait 10 seconds before closing the textio.
+         */
+        @AfterEach
+        void cleanUp() {
+            try {
+                Thread.sleep(10000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    /**
+     * This Class is used to communicate with the UserInterface. It overrides crucial methods and returns an instruction based on the instructions' data field.
+     * To implement the right instructions the user has to be aware of the game sequence.
+     */
+    private class Interface extends UserInterface {
+
+        private final PositionVector.Direction[] directions;
+        private final Integer[] instructions;
+        private int pointerDir,pointerInstruction;
+
+        /**
+         * Constructor to create a new Interface Object
+         * @param welcometext The first Text which will be printed in the UserInterface Window
+         * @param instructions list of instructions to simulate userinput
+         * @param directions list of Directions to simulate userinput
+         */
+        public Interface(String welcometext, Integer[] instructions, PositionVector.Direction[] directions) {
+            super(welcometext);
+            pointerDir = -1;
+            pointerInstruction = -1;
+            this.instructions = instructions;
+            this.directions = directions;
+        }
+
+        /**
+         * Overwriting Method for testing without userinteraction
+         * @param text    Text which is printed before the options are printed. Example: "Select Track file:"
+         * @param options List with the options which can be selected.
+         * @return the selected Option
+         */
+        @Override
+        public int selectOption(String text, List<String> options) {
+            pointerInstruction++;
+            return instructions[pointerInstruction];
+
+        }
+
+        /**
+         * Overwriting Method for testing without userinteraction
+         * @param text The Text which should be printed.
+         */
+        @Override
+        public void printInformation(String text) {
+        }
+
+        /**
+         * Overwriting Method for testing without userinteraction
+         * @param text Output Text
+         */
+        @Override
+        public void quit(String text) {
+        }
+
+        /**
+         * Overwriting Method for testing without userinteraction
+         * @param playingCarIndex the index of the player
+         * @param playingCarID    the ID of the player
+         * @return the direction to accelerate
+         */
+        @Override
+        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/MoveListStrategyTest.java

@@ -0,0 +1,52 @@
+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.File;
+import java.io.FileNotFoundException;
+
+/**
+ * This Class tests the MoveStrategy.
+ *
+ * @author Andrin Fassbind
+ */
+public class MoveListStrategyTest {
+
+    private MoveStrategy moveList;
+
+
+    @Nested
+    @DisplayName("MoveListStrategy")
+    class MoveList {
+
+        /**
+         * Creates a new MoveListStrategy
+         */
+        @BeforeEach
+        void setup() {
+            try {
+                moveList = new MoveListStrategy(new File(".\\moves\\challenge-car-a.txt"));
+            }catch (FileNotFoundException | InvalidFileFormatException e) {
+                e.printStackTrace();
+            }
+        }
+
+        /**
+         * Checks if the directions are returned correct by method nextMove
+         */
+        @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,204 @@
+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;
+
+/**
+ * This Class tests the track
+ *
+ * @author Andrin Fassbind
+ */
+public class TrackTest {
+    Track trackObj;
+
+    @Nested
+    @DisplayName("Positive Test Cases")
+    class positiveClass {
+
+        /**
+         * Sets up the Test cases by loading the file and setting a new track.
+         */
+        @BeforeEach
+        void setup() {
+            File file = new File(".\\tracks\\challenge.txt");
+            try {
+                trackObj = new Track(file);
+            } catch (FileNotFoundException | InvalidTrackFormatException e) {
+                e.printStackTrace();
+                Assertions.fail();
+            }
+
+        }
+
+        /**
+         * Checks if correct amount of cars has been instantiated
+         */
+        @Test
+        @DisplayName("Create correct amount of Car instance")
+        void checkCars() {
+            Assertions.assertEquals(2, trackObj.getCarCount());
+        }
+
+        /**
+         * Checks if car id matches track file symbol
+         */
+        @Test
+        @DisplayName("Create Car instance with correct Symbols / Id")
+        void checkCarId() {
+            Assertions.assertEquals('a', trackObj.getCarId(0));
+            Assertions.assertEquals('b', trackObj.getCarId(1));
+        }
+
+        /**
+         * checks if track reads space typ from track file correctly
+         */
+        @Test
+        @DisplayName("Check getSpaceTyp")
+        void getSpaceTyp() {
+            Assertions.assertEquals(ConfigSpecification.SpaceType.FINISH_RIGHT, trackObj.getSpaceType(new PositionVector(22, 24)));
+        }
+
+        /**
+         * checks if track finds the finish line at the correct positions
+         */
+        @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());
+        }
+
+        /**
+         * Checks if track does read in track file correctly
+         */
+        @Test
+        @DisplayName("Converts track file 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 e) {
+                e.printStackTrace();
+            }
+        }
+
+        /**
+         * checks if track does process car move correctly
+         */
+        @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());
+        }
+
+        /**
+         * Checks if car does not move if there is no acceleration
+         */
+        @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());
+        }
+
+        /**
+         * Checks if car does crash
+         */
+        @Test
+        @DisplayName("Will Car Crash")
+        void willCarCrash() {
+            //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)));
+
+        }
+
+        /**
+         * checks if track is updated after car crash
+         */
+        @Test
+        @DisplayName("Make Car Crash")
+        void makeCarCrash() {
+            trackObj.carDoesCrash(0, new PositionVector(6, 22));
+            Assertions.assertEquals(Track.CRASH_INDICATOR, trackObj.getTrack().get(22).charAt(6));
+            Assertions.assertTrue(trackObj.getCar(0).isCrashed());
+        }
+    }
+
+    /**
+     * This testcase does check for negative test cases
+     */
+    @Nested
+    @DisplayName("Negative TestCase")
+    class negativeClass {
+        File file;
+
+        /**
+         * Sets up the negative Test cases by loading the file and setting a new track.
+         */
+        @BeforeEach
+        void setup() {
+            file = new File(".\\tracks\\challenge.txt");
+            try {
+                trackObj = new Track(file);
+
+            } catch (InvalidTrackFormatException | FileNotFoundException e) {
+                System.err.println("Error in Test compareTrack" + e.getMessage());
+            }
+        }
+
+        /**
+         * Tries to read not valid file
+         */
+        @Test
+        @DisplayName("Throw error if File not found")
+        void canReadFile() {
+            file = new File(".\\tracks\\NotExisting.txt");
+            Assertions.assertThrows(FileNotFoundException.class, () -> new Track(file));
+        }
+
+        /**
+         * Tries to read not valid file with 2 cars with same symbol
+         */
+        @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));
+        }
+    }
+}

tracks/.gitignore

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