fix in CardoesCrash in Track.java (remove Car when crash)

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

@@ -33,9 +33,9 @@ public class Game implements GameSpecification {
     public boolean initPhase() throws InvalidTrackFormatException, FileNotFoundException {
         File folder = new File("tracks");
         File[] listOfFiles = folder.listFiles();
-        if(listOfFiles.length > 0) {
+        if (listOfFiles.length > 0) {
             List<String> tracks = new ArrayList<>();
-            for(File file : listOfFiles){
+            for (File file : listOfFiles) {
                 tracks.add(file.getName());
             }
             File selectedTrack = listOfFiles[userInterface.selectOption("Select Track file", tracks)];
@@ -49,15 +49,15 @@ public class Game implements GameSpecification {
             moveStrategies.add("User Move Strategy");
             moveStrategies.add("Move List Strategy");
             moveStrategies.add("Path Follow Move Strategy");
-            for(int i = 0; i < track.getCarCount() ; i++ ) {
+            for (int i = 0; i < track.getCarCount(); i++) {
                 int moveStrategie = userInterface.selectOption(
                     "Select Strategy for Car " + i + " (" + track.getCarId(i) + ")", moveStrategies);
-                switch (moveStrategie + 1) { //TODO: set Movestrategy with method in Track
+                switch (moveStrategie + 1) {
                     case 1:
-                        track.getCar(i).setMoveStrategy(new DoNotMoveStrategy()); //TODO: add Arguments
+                        track.getCar(i).setMoveStrategy(new DoNotMoveStrategy());
                         break;
                     case 2:
-                        track.getCar(i).setMoveStrategy(new UserMoveStrategy(userInterface, i, track.getCarId(i))); //TODO: add Arguments
+                        track.getCar(i).setMoveStrategy(new UserMoveStrategy(userInterface, i, track.getCarId(i)));
                         break;
                     case 3:
                         track.getCar(i).setMoveStrategy(new MoveListStrategy()); //TODO: add Arguments
@@ -68,8 +68,7 @@ public class Game implements GameSpecification {
                 }
             }
             return true;
-        }
-        else{
+        } else {
             userInterface.printInformation("No Trackfile found!");
             return false;
         }
@@ -78,6 +77,7 @@ public class Game implements GameSpecification {
     /**
      * Return the index of the current active car.
      * Car indexes are zero-based, so the first car is 0, and the last car is getCarCount() - 1.
+     *
      * @return The zero-based number of the current car
      */
     @Override
@@ -87,6 +87,7 @@ public class Game implements GameSpecification {
 
     /**
      * Get the id of the specified car.
+     *
      * @param carIndex The zero-based carIndex number
      * @return A char containing the id of the car
      */
@@ -97,6 +98,7 @@ public class Game implements GameSpecification {
 
     /**
      * Get the position of the specified car.
+     *
      * @param carIndex The zero-based carIndex number
      * @return A PositionVector containing the car's current position
      */
@@ -107,6 +109,7 @@ public class Game implements GameSpecification {
 
     /**
      * Get the velocity of the specified car.
+     *
      * @param carIndex The zero-based carIndex number
      * @return A PositionVector containing the car's current velocity
      */
@@ -117,14 +120,17 @@ public class Game implements GameSpecification {
 
     /**
      * Return the winner of the game. If the game is still in progress, returns NO_WINNER.
+     *
      * @return The winning car's index (zero-based, see getCurrentCar()), or NO_WINNER if the game is still in progress
      */
     @Override
     public int getWinner() {
-        List<Car> cars = track.getCars();
-        for (Car car: cars) {
-            if(car.getWinPoints() == 1){
-                return car.getID();
+        if (onlyOneCarLeft()) {
+            return currentCarIndex;
+        }
+        for (int i = 0; i < track.getCarCount(); i++) {
+            if (track.getCar(i).getWinPoints() == 1) {
+                return i;
             }
         }
         return NO_WINNER;
@@ -158,36 +164,40 @@ public class Game implements GameSpecification {
      */
     @Override
     public void doCarTurn(Direction acceleration) throws PositionVectorNotValid {
-        // TODO: implementation
         track.getCar(currentCarIndex).accelerate(acceleration);
 
         PositionVector crashPosition = null;
-        List<PositionVector> positionList  = calculatePath(track.getCarPos(currentCarIndex),track.getCar(currentCarIndex).nextPosition());
-        //TODO: check if Method calculatePath contains endposition
-        for(PositionVector location : positionList) { //todo: check if order must be reversed
-            if(willCarCrash(currentCarIndex, location)) {
-                crashPosition = location;
+        List<PositionVector> positionList = calculatePath(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition());
+        for (int i = 0; i < positionList.size(); i++) {
+            if (willCarCrash(currentCarIndex, positionList.get(i))) {
+                if (i == 0) {
+                    crashPosition = track.getCarPos(currentCarIndex);
+                } else {
+                    crashPosition = positionList.get(i - 1);
+                }
             }
         }
-        if(crashPosition != null) {
+        if (crashPosition != null) {
             track.carDoesCrash(currentCarIndex, crashPosition);
-        }
-        else {
-            track.moveCar(currentCarIndex);
+        } else {
             calculateWinner(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition(), currentCarIndex);
+            track.moveCar(currentCarIndex);
         }
     }
 
     public int gamePhase() throws PositionVectorNotValid {
-        while (getWinner() == NO_WINNER) {
+        while (CarsMoving() && getWinner() == NO_WINNER) {
             userInterface.printTrack(track);
-            Direction direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
-            doCarTurn(direction);
-            if(allCarsCrashed()) {
-                return NO_WINNER;
+            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();
     }
 
@@ -199,9 +209,8 @@ public class Game implements GameSpecification {
         do {
             if ((currentCarIndex + 1) == track.getCarCount()) {
                 currentCarIndex = 0;
-            }
-            else {
-                currentCarIndex ++;
+            } else {
+                currentCarIndex++;
             }
         } while (track.getCar(currentCarIndex).isCrashed());
         // TODO: evtl andere Kapselung
@@ -215,8 +224,9 @@ public class Game implements GameSpecification {
      * - Detect which axis of the distance vector is longer (faster movement)
      * - for each pixel on the 'faster' axis calculate the position on the 'slower' axis.
      * Direction of the movement has to correctly considered
+     *
      * @param startPosition Starting position as a PositionVector
-     * @param endPosition Ending position as a PositionVector
+     * @param endPosition   Ending position as a PositionVector
      * @return Intervening grid positions as a List of PositionVector's, including the starting and ending positions.
      */
     @Override
@@ -244,20 +254,24 @@ public class Game implements GameSpecification {
         int distanceSlowAxis, distanceFastAxis;
         if (distX > distY) {
             // x axis is the 'fast' direction
-            parallelStepX = dirX; parallelStepY = 0; // parallel step only moves in x direction
-            diagonalStepX = dirX; diagonalStepY = dirY; // diagonal step moves in both directions
+            parallelStepX = dirX;
+            parallelStepY = 0; // parallel step only moves in x direction
+            diagonalStepX = dirX;
+            diagonalStepY = dirY; // diagonal step moves in both directions
             distanceSlowAxis = distY;
             distanceFastAxis = distX;
         } else {
             // y axis is the 'fast' direction
-            parallelStepX = 0; parallelStepY = dirY; // parallel step only moves in y direction
-            diagonalStepX = dirX; diagonalStepY = dirY; // diagonal step moves in both directions
+            parallelStepX = 0;
+            parallelStepY = dirY; // parallel step only moves in y direction
+            diagonalStepX = dirX;
+            diagonalStepY = dirY; // diagonal step moves in both directions
             distanceSlowAxis = distX;
             distanceFastAxis = distY;
         }
 
-        int error = distanceFastAxis/2;
-        for(int step = 0; step < distanceFastAxis; step ++) {
+        int error = distanceFastAxis / 2;
+        for (int step = 0; step < distanceFastAxis; step++) {
             error -= distanceSlowAxis;
             if (error < 0) {
                 error += distanceFastAxis; // correct error value to be positive again
@@ -270,50 +284,49 @@ public class Game implements GameSpecification {
                 y += parallelStepY;
             }
 
-        pathList.add(new PositionVector(x,y));
+            pathList.add(new PositionVector(x, y));
         }
         return pathList;
     }
 
-    private void calculateWinner(PositionVector start, PositionVector finish, int carIndex ) {
+    private void calculateWinner(PositionVector start, PositionVector finish, int carIndex) {
         List<PositionVector> path = calculatePath(start, finish);
-        for (PositionVector point : path){
-            switch (track.getSpaceType(point)) {
-                case FINISH_UP:
-                    if(start.getY() < finish.getY()) {
-                        track.getCar(carIndex).increaseWinPoints();
+        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;
                     }
-                    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;
-                }
-            }
 
+                }
+        }
     }
 
 
@@ -328,12 +341,22 @@ public class Game implements GameSpecification {
         return track.willCrashAtPosition(carIndex, position);
     }
 
-    public boolean allCarsCrashed() {
+    public boolean onlyOneCarLeft() {
+        int carsLeft = 0;
         for(int carIndex = 0; carIndex < track.getCarCount(); carIndex ++) {
             if(! track.getCar(carIndex).isCrashed()) {
-                return false;
+                carsLeft++;
             }
         }
-        return true;
+        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

@@ -8,8 +8,8 @@ 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) {
-            UserInterface userInterface = new UserInterface("Hello and Welcome");
             Game game = new Game(userInterface);
             int winner = 0;
             if (game.initPhase()) {
@@ -23,6 +23,7 @@ public class Main {
                 exit = true;
             }
         }
+        userInterface.printInformation("Thank you and goodbye");
     }
 
 }

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

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