fix in CarTest.java

@Test setPosition

build.gradle

@@ -29,7 +29,6 @@ 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'

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

@@ -24,10 +24,6 @@ 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}
@@ -63,18 +59,6 @@ public class Car implements CarSpecification {
         return id;
     }
 
-    public void increaseWinPoints() {
-        winPoints ++;
-    }
-
-    public void deductWinPoints() {
-        winPoints --;
-    }
-
-    public int getWinPoints() {
-        return winPoints;
-    }
-
     /**
      * Returns the current velocity of the car as a PositionVector.
      *

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

@@ -1,14 +1,7 @@
 package ch.zhaw.pm2.racetrack;
 
 import ch.zhaw.pm2.racetrack.given.GameSpecification;
-import ch.zhaw.pm2.racetrack.strategy.DoNotMoveStrategy;
-import ch.zhaw.pm2.racetrack.strategy.MoveListStrategy;
-import ch.zhaw.pm2.racetrack.strategy.PathFollowerMoveStrategy;
-import ch.zhaw.pm2.racetrack.strategy.UserMoveStrategy;
 
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.util.ArrayList;
 import java.util.List;
 
 import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
@@ -20,120 +13,59 @@ import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
  */
 public class Game implements GameSpecification {
     public static final int NO_WINNER = -1;
-    private Track track;
-    int currentCarIndex;
-
-    UserInterface userInterface;
-
-    public Game(UserInterface userInterface) {
-        this.userInterface = userInterface;
-    }
-
-
-    public boolean initPhase() throws InvalidTrackFormatException, FileNotFoundException {
-        File folder = new File("tracks");
-        File[] listOfFiles = folder.listFiles();
-        if (listOfFiles.length > 0) {
-            List<String> tracks = new ArrayList<>();
-            for (File file : listOfFiles) {
-                tracks.add(file.getName());
-            }
-            File selectedTrack = listOfFiles[userInterface.selectOption("Select Track file", tracks)];
-            try {
-                track = new Track(selectedTrack);
-            } catch (FileNotFoundException | PositionVectorNotValid e) {
-                e.printStackTrace();
-            }
-            List<String> moveStrategies = new ArrayList<>();
-            moveStrategies.add("Do not move Strategy");
-            moveStrategies.add("User Move Strategy");
-            moveStrategies.add("Move List Strategy");
-            moveStrategies.add("Path Follow Move Strategy");
-            for (int i = 0; i < track.getCarCount(); i++) {
-                int moveStrategie = userInterface.selectOption(
-                    "Select Strategy for Car " + i + " (" + track.getCarId(i) + ")", moveStrategies);
-                switch (moveStrategie + 1) {
-                    case 1:
-                        track.getCar(i).setMoveStrategy(new DoNotMoveStrategy());
-                        break;
-                    case 2:
-                        track.getCar(i).setMoveStrategy(new UserMoveStrategy(userInterface, i, track.getCarId(i)));
-                        break;
-                    case 3:
-                        track.getCar(i).setMoveStrategy(new MoveListStrategy()); //TODO: add Arguments
-                        break;
-                    case 4:
-                        track.getCar(i).setMoveStrategy(new PathFollowerMoveStrategy()); //TODO: add Arguments
-                        break;
-                }
-            }
-            return true;
-        } else {
-            userInterface.printInformation("No Trackfile found!");
-            return false;
-        }
-    }
 
     /**
      * 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() {
-        return currentCarIndex;
+        // TODO: implementation
+        throw new UnsupportedOperationException();
     }
 
     /**
      * Get the id of the specified car.
-     *
      * @param carIndex The zero-based carIndex number
      * @return A char containing the id of the car
      */
     @Override
     public char getCarId(int carIndex) {
-        return track.getCarId(carIndex);
+        // TODO: implementation
+        throw new UnsupportedOperationException();
     }
 
     /**
      * 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) {
-        return track.getCarPos(carIndex);
+        // TODO: implementation
+        throw new UnsupportedOperationException();
     }
 
     /**
      * 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) {
-        return track.getCarVelocity(carIndex);
+        // TODO: implementation
+        throw new UnsupportedOperationException();
     }
 
     /**
      * 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() {
-        if (onlyOneCarLeft()) {
+        // TODO: implementation
-            return currentCarIndex;
+        throw new UnsupportedOperationException();
-        }
-        for (int i = 0; i < track.getCarCount(); i++) {
-            if (track.getCar(i).getWinPoints() == 1) {
-                return i;
-            }
-        }
-        return NO_WINNER;
     }
 
     /**
@@ -163,42 +95,9 @@ public class Game implements GameSpecification {
      *                     for this turn
      */
     @Override
-    public void doCarTurn(Direction acceleration) throws PositionVectorNotValid {
+    public void doCarTurn(Direction acceleration) {
-        track.getCar(currentCarIndex).accelerate(acceleration);
+        // TODO: implementation
-
+        throw new UnsupportedOperationException();
-        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);
-                }
-            }
-        }
-        if (crashPosition != null) {
-            track.carDoesCrash(currentCarIndex, crashPosition);
-        } else {
-            calculateWinner(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition(), currentCarIndex);
-            track.moveCar(currentCarIndex);
-        }
-    }
-
-    public int gamePhase() throws PositionVectorNotValid {
-        while (CarsMoving() && getWinner() == NO_WINNER) {
-            userInterface.printTrack(track);
-            Direction direction = null;
-            direction= track.getCar(currentCarIndex).getMoveStrategy().nextMove();
-            if(direction == null) {
-                track.getCar(currentCarIndex).setMoveStrategy(new DoNotMoveStrategy());
-                direction= track.getCar(currentCarIndex).getMoveStrategy().nextMove();
-            }
-            doCarTurn(direction);
-            switchToNextActiveCar();
-        }
-        userInterface.printTrack(track);
-        return getWinner();
     }
 
     /**
@@ -206,14 +105,8 @@ public class Game implements GameSpecification {
      */
     @Override
     public void switchToNextActiveCar() {
-        do {
+        // TODO: implementation
-            if ((currentCarIndex + 1) == track.getCarCount()) {
+        throw new UnsupportedOperationException();
-                currentCarIndex = 0;
-            } else {
-                currentCarIndex++;
-            }
-        } while (track.getCar(currentCarIndex).isCrashed());
-        // TODO: evtl andere Kapselung
     }
 
     /**
@@ -224,112 +117,16 @@ 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) {
-        ArrayList<PositionVector> pathList = new ArrayList<>();
+        // TODO: implementation
-        // Use Bresenham's algorithm to determine positions.
+        throw new UnsupportedOperationException();
-        int x = startPosition.getX();
-        int y = startPosition.getY();
-
-        // Relative Distance (x & y axis) between end- and starting position
-        int diffX = endPosition.getX() - startPosition.getX();
-        int diffY = endPosition.getY() - startPosition.getY();
-
-        // Absolute distance (x & y axis) between end- and starting position
-        int distX = Math.abs(diffX);
-        int distY = Math.abs(diffY);
-
-        // Direction of vector on x & y axis (-1: to left/down, 0: none, +1 : to right/up)
-        int dirX = Integer.signum(diffX);
-        int dirY = Integer.signum(diffY);
-
-        // Determine which axis is the fast direction and set parallel/diagonal step values
-        int parallelStepX, parallelStepY;
-        int diagonalStepX, diagonalStepY;
-        int distanceSlowAxis, distanceFastAxis;
-        if (distX > distY) {
-            // x axis is the 'fast' direction
-            parallelStepX = dirX;
-            parallelStepY = 0; // parallel step only moves in x direction
-            diagonalStepX = dirX;
-            diagonalStepY = dirY; // diagonal step moves in both directions
-            distanceSlowAxis = distY;
-            distanceFastAxis = distX;
-        } else {
-            // y axis is the 'fast' direction
-            parallelStepX = 0;
-            parallelStepY = dirY; // parallel step only moves in y direction
-            diagonalStepX = dirX;
-            diagonalStepY = dirY; // diagonal step moves in both directions
-            distanceSlowAxis = distX;
-            distanceFastAxis = distY;
     }
 
-        int error = distanceFastAxis / 2;
-        for (int step = 0; step < distanceFastAxis; step++) {
-            error -= distanceSlowAxis;
-            if (error < 0) {
-                error += distanceFastAxis; // correct error value to be positive again
-                // step into slow direction; diagonal step
-                x += diagonalStepX;
-                y += diagonalStepY;
-            } else {
-                // step into fast direction; parallel step
-                x += parallelStepX;
-                y += parallelStepY;
-            }
-
-            pathList.add(new PositionVector(x, y));
-        }
-        return pathList;
-    }
-
-    private void calculateWinner(PositionVector start, PositionVector finish, int carIndex) {
-        List<PositionVector> path = calculatePath(start, finish);
-        for (PositionVector point : path) {
-            if (track.getSpaceType(point) != null)
-                {
-                switch (track.getSpaceType(point)) {
-                    case FINISH_UP:
-                        if (start.getY() < finish.getY()) {
-                            track.getCar(carIndex).increaseWinPoints();
-                        } else if (start.getY() > finish.getY()) {
-                            track.getCar(carIndex).deductWinPoints();
-                        }
-                        break;
-                    case FINISH_DOWN:
-                        if (start.getY() > finish.getY()) {
-                            track.getCar(carIndex).increaseWinPoints();
-                        } else if (start.getY() < finish.getY()) {
-                            track.getCar(carIndex).deductWinPoints();
-                        }
-                        break;
-                    case FINISH_RIGHT:
-                        if (start.getX() < finish.getX()) {
-                            track.getCar(carIndex).increaseWinPoints();
-                        } else if (start.getX() > finish.getX()) {
-                            track.getCar(carIndex).deductWinPoints();
-                        }
-                        break;
-                    case FINISH_LEFT:
-                        if (start.getX() > finish.getX()) {
-                            track.getCar(carIndex).increaseWinPoints();
-                        } else if (start.getX() < finish.getX()) {
-                            track.getCar(carIndex).increaseWinPoints();
-                        }
-                        break;
-                    }
-
-                }
-        }
-    }
-
-
     /**
      * Does indicate if a car would have a crash with a WALL space or another car at the given position.
      * @param carIndex The zero-based carIndex number
@@ -337,26 +134,8 @@ public class Game implements GameSpecification {
      * @return A boolean indicator if the car would crash with a WALL or another car.
      */
     @Override
-    public boolean willCarCrash(int carIndex, PositionVector position) throws PositionVectorNotValid {
+    public boolean willCarCrash(int carIndex, PositionVector position) {
-        return track.willCrashAtPosition(carIndex, position);
+        // TODO: implementation
-    }
+        throw new UnsupportedOperationException();
-
-    public boolean onlyOneCarLeft() {
-        int carsLeft = 0;
-        for(int carIndex = 0; carIndex < track.getCarCount(); carIndex ++) {
-            if(! track.getCar(carIndex).isCrashed()) {
-                carsLeft++;
-            }
-        }
-        return !(carsLeft > 1);
-    }
-
-    public boolean CarsMoving() {
-        for(int carIndex = 0; carIndex < track.getCarCount(); carIndex ++) {
-            if(! (track.getCar(carIndex).isCrashed() || track.getCar(carIndex).getMoveStrategy().getClass() == DoNotMoveStrategy.class)) {
-                return true;
-            }
-        }
-        return false;
     }
 }

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

@@ -1,29 +0,0 @@
-package ch.zhaw.pm2.racetrack;
-
-import java.io.FileNotFoundException;
-import java.util.ArrayList;
-import java.util.List;
-
-public class Main {
-
-    public static void main(String[] args) throws InvalidTrackFormatException, FileNotFoundException, PositionVectorNotValid {
-        boolean exit = false;
-        UserInterface userInterface = new UserInterface("Hello and Welcome");
-        while (!exit) {
-            Game game = new Game(userInterface);
-            int winner = 0;
-            if (game.initPhase()) {
-                winner = game.gamePhase();
-            }
-            List<String> optionsNewGame = new ArrayList<>();
-            optionsNewGame.add("exit");
-            optionsNewGame.add("new game");
-            int selectedOption = userInterface.selectOption("The Winner was Car : " + winner + "\nStart new Game?", optionsNewGame);
-            if(selectedOption == 0) {
-                exit = true;
-            }
-        }
-        userInterface.printInformation("Thank you and goodbye");
-    }
-
-}

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

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

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

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

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

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

src/main/java/ch/zhaw/pm2/racetrack/given/GameSpecification.java

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

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

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

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

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

src/test/InvalidTracks/sameCar.txt

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

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

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

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

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

tracks/.gitignore

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