ZHAW-IT21b_WIN
/
team02-AngryNerds-projekt1-racetrack
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: ZHAW-IT21b_WIN:main
Branches Tags
ZHAW-IT21b_WIN:main
ZHAW-IT21b_WIN:Strategy
ZHAW-IT21b_WIN:Game
ZHAW-IT21b_WIN:GameTest
ZHAW-IT21b_WIN:PathFollowerMoveStrategy
ZHAW-IT21b_WIN:MoveListFeature
ZHAW-IT21b_WIN:track-feature
ZHAW-IT21b_WIN:fixTrack
ZHAW-IT21b_WIN:Exception
ZHAW-IT21b_WIN:car
ZHAW-IT21b_WIN:Class_UserInterface
ZHAW-IT21b_WIN:CarTest
..
compare: ZHAW-IT21b_WIN:Strategy
Branches Tags
ZHAW-IT21b_WIN:main
ZHAW-IT21b_WIN:Strategy
ZHAW-IT21b_WIN:Game
ZHAW-IT21b_WIN:GameTest
ZHAW-IT21b_WIN:PathFollowerMoveStrategy
ZHAW-IT21b_WIN:MoveListFeature
ZHAW-IT21b_WIN:track-feature
ZHAW-IT21b_WIN:fixTrack
ZHAW-IT21b_WIN:Exception
ZHAW-IT21b_WIN:car
ZHAW-IT21b_WIN:Class_UserInterface
ZHAW-IT21b_WIN:CarTest

No commits in common. "main" and "Strategy" have entirely different histories.
main ... Strategy

23 changed files with 330 additions and 629 deletions
Show Stats Expand all files Collapse all files

BIN
FeedbackP1_ruiz.md.pdf
View File

Binary file not shown.

1
Klassendiagramm.drawio Normal file
View File

File diff suppressed because one or more lines are too long

1
Klassendiagramm.svg
View File

File diff suppressed because one or more lines are too long
Side by Side

Before

Width:  |  Height:  |  Size: 115 KiB

23
README.md
View File

@ -1,22 +1,20 @@
# PM2 Team 02 Projekt 1 Racetrack
# team02-AngryNerds-projekt1-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
In order to not crash you have to keep in mind the acceleration and other players car to get to the finish line safely.
# Initialization:
#### The game can be initialized by the terminal command:
gradlew run
./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.
> This Strategy sets the car stationary, and it won't make any moves during the game staying at the startpoint 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
@ -40,12 +38,7 @@ And every other character represents a car.
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.
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.
## 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)
![Classdiagramm of this program](/Klassendiagramm.drawio)

4
follower/challenge_points.txt
View File

@ -1,7 +1,3 @@
(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)

3
moves/challenge-car-b.txt
View File

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

37
src/main/java/ch/zhaw/pm2/racetrack/Car.java
View File

@ -62,25 +62,14 @@ public class Car implements CarSpecification {
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;
}
@ -97,7 +86,7 @@ public class Car implements CarSpecification {
/**
* 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 normally automatically calculated and set in the {@link #move()} method.
* The next position is normaly automatically calculated and set in the {@link #move()} method.
*
* @param position The new position to set the car directly to.
* @throws IllegalArgumentException if invalid PositionVector is given.
@ -151,7 +140,7 @@ public class Car implements CarSpecification {
}
/**
* Marks the car as crashed
* Mark this Car as being crashed.
*/
@Override
public void crash() {
@ -159,7 +148,7 @@ public class Car implements CarSpecification {
}
/**
* Returns whether this Car has been marked as crashed or not
* Returns whether this Car has been marked as crashed.
*
* @return Returns true if crash() has been called on this Car, false otherwise.
*/
@ -169,20 +158,20 @@ public class Car implements CarSpecification {
}
/**
* Returns the current move Strategy
*
* @return the current move Strategy
*/
public MoveStrategy getMoveStrategy() {
return this.moveStrategy;
}
/**
* Set the move Strategy of the car.
* Set move strategy
*
* @param moveStrategy Strategy to be implemented
*/
public void setMoveStrategy(MoveStrategy moveStrategy) {
this.moveStrategy = moveStrategy;
}
/**
* Get current move strategy
*
* @return MoveStrategy
*/
public MoveStrategy getMoveStrategy() {
return this.moveStrategy;
}
}

215
src/main/java/ch/zhaw/pm2/racetrack/Game.java
View File

@ -6,7 +6,6 @@ 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;
@ -20,29 +19,34 @@ 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) {
UserInterface userInterface;
public Game(UserInterface userInterface) {
this.userInterface = userInterface;
this.config = config;
}
/**
* This method will initialize the game. Therefore, it interacts with the user via UserInterface
*
* 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()))];
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 {
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");
userInterface.printInformation("There is an unexpected Error with the trackfile Path. Add trackfiles 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");
userInterface.printInformation("There is an unexpected Error with the trackfile. Format does not match specifications! Exit the Game and Fix the Problem");
return false;
}
List<String> moveStrategies = new ArrayList<>();
@ -51,102 +55,60 @@ public class Game implements GameSpecification {
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);
for (int i = 0; i < track.getCarCount(); i++) {
Car car = track.getCar(i);
MoveStrategy moveStrategy = null;
while (moveStrategy == null) {
String filePath;
int moveStrategie = userInterface.selectOption(
"Select Strategy for Car " + carIndex + " (" + track.getCarId(carIndex) + ")", moveStrategies);
"Select Strategy for Car " + i + " (" + track.getCarId(i) + ")", 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);
case 0:
moveStrategy = new DoNotMoveStrategy();
break;
case 1:
moveStrategy = new UserMoveStrategy(userInterface, i, track.getCarId(i));
break;
case 2:
filePath = ".\\moves\\" + selectedTrack.getName().split("\\.")[0] + "-car-" + track.getCar(i).getID() + ".txt";
try {
moveStrategy = new MoveListStrategy(filePath);
} catch (FileNotFoundException e) {
userInterface.printInformation("There is no Move-List implemented. Choose another Strategy!");
}
break;
case 3:
filePath = ".\\follower\\" + selectedTrack.getName().split("\\.")[0] + "_points.txt";
try {
moveStrategy = new PathFollowerMoveStrategy(filePath, track.getCarPos(i));
} catch (FileNotFoundException e) {
userInterface.printInformation("There is no Point-List implemented. Choose another Strategy!");
}
break;
case 4:
moveStrategy = new PathFinderMoveStrategy(track, i);
break;
}
}
selectMoveStrategy(car, moveStrategy);
}
return true;
} else {
userInterface.printInformation("No track file found!");
userInterface.printInformation("No Trackfile 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
* The functionality was taken out of init to automate testing
* @param selectedTrack
*/
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 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
@ -168,7 +130,7 @@ public class Game implements GameSpecification {
}
/**
* Gets the id of the specified car.
* Get the id of the specified car.
*
* @param carIndex The zero-based carIndex number
* @return A char containing the id of the car
@ -241,7 +203,7 @@ 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 car's acceleration vector (-1,0,1) in x and y direction
* @param acceleration A Direction containing the current cars acceleration vector (-1,0,1) in x and y direction
* for this turn
*/
@Override
@ -260,9 +222,9 @@ public class Game implements GameSpecification {
}
}
int newWinPoints = track.calculateNewWinPoints(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition());
if (newWinPoints == 1) {
if(newWinPoints == 1){
track.getCar(currentCarIndex).increaseWinPoints();
} else if (newWinPoints == -1) {
}else if(newWinPoints == -1){
track.getCar(currentCarIndex).deductWinPoints();
}
if (crashPosition != null) {
@ -273,31 +235,22 @@ public class Game implements GameSpecification {
}
/**
* 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.
* This method implements the gameflow in a while loop. If there is a winner. The method will return its carid.
*
* @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!");
while (carsMoving() && getWinner() == NO_WINNER) {
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();
}
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) {
@ -318,6 +271,7 @@ public class Game implements GameSpecification {
currentCarIndex++;
}
} while (track.getCar(currentCarIndex).isCrashed());
// TODO: evtl andere Kapselung
}
/**
@ -338,6 +292,51 @@ public class Game implements GameSpecification {
return track.calculatePointsOnPath(startPosition, endPosition);
}
/**
* This method will check if a car is passing the finishline.
* If the car is passing the finishline in the wrong direction, the car will lose a winpoint.
* If the car is passing the finishline in the correct direction, the car will gain a winpoint.
* @param start the startposition of the car
* @param finish the expected finishpositon of the car after the move
*/
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();
} 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.
*
@ -350,11 +349,6 @@ public class Game implements GameSpecification {
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++) {
@ -365,11 +359,6 @@ public class Game implements GameSpecification {
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)) {

12
src/main/java/ch/zhaw/pm2/racetrack/InvalidFileFormatException.java
View File

@ -1,18 +1,10 @@
package ch.zhaw.pm2.racetrack;
/**
* Class for Exception when an invalid file format is used.
* Class for Exception when invalid Fileformat 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(){super();}
public InvalidFileFormatException(String errorMessage) {
super(errorMessage);
}

13
src/main/java/ch/zhaw/pm2/racetrack/InvalidTrackFormatException.java
View File

@ -4,17 +4,10 @@ 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);
}
public InvalidTrackFormatException() {
super();
}
}

16
src/main/java/ch/zhaw/pm2/racetrack/Main.java
View File

@ -3,24 +3,12 @@ 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);
Game game = new Game(userInterface);
String winner;
if (game.initPhase()) {
winner = game.gamePhase();

4
src/main/java/ch/zhaw/pm2/racetrack/PositionVector.java
View File

@ -7,8 +7,8 @@ package ch.zhaw.pm2.racetrack;
* Created by mach 21.01.2020
*/
public final class PositionVector {
private int x; // horizontal component (position / velocity)
private int y; // vertical component (position / velocity)
private final int x; // horizontal component (position / velocity)
private final int y; // vertical component (position / velocity)
/**
* Enum representing a direction on the track grid.

56
src/main/java/ch/zhaw/pm2/racetrack/Track.java
View File

@ -45,9 +45,9 @@ import java.util.Scanner;
* 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 tracks ends with the first empty line or the file end.<br>
* The 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>
@ -55,7 +55,7 @@ import java.util.Scanner;
* <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 positions)</p>
* <p>The Track can return a String representing the current state of the race (including car positons)</p>
*/
public class Track implements TrackSpecification {
@ -67,11 +67,10 @@ public class Track implements TrackSpecification {
/**
* 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.
*
* Throws an 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, ...)
* @throws InvalidTrackFormatException if the track file contains invalid data (no tracklines, ...)
*/
public Track(File trackFile) throws FileNotFoundException, InvalidTrackFormatException {
track = new ArrayList<>();
@ -96,7 +95,7 @@ public class Track implements TrackSpecification {
}
/**
* Goes through the track ArrayList and determines the locations of each car and initializes them at the location.
* Goes through the track ArrayList and determines the locations of each cars and initializes them at the location.
*
* @throws InvalidTrackFormatException is thrown if a car is found more than once inside the track.
*/
@ -115,17 +114,19 @@ public class Track implements TrackSpecification {
char possibleCarChar = line.charAt(xPosition);
if (!allSpaceTypesAsChar.contains(possibleCarChar)) {
if (usedSymbolForCar.contains(possibleCarChar)) {
throw new InvalidTrackFormatException("More than one car on track!");
throw new InvalidTrackFormatException();
}
usedSymbolForCar.add(possibleCarChar);
cars.add(new Car(possibleCarChar, new PositionVector(xPosition, yPosition)));
}
}
}
}
//TODO: THIS
/**
* Determines the finish line and saves it in a list, throws an Exception if none is found.
* 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
*/
@ -142,12 +143,12 @@ public class Track implements TrackSpecification {
}
}
if (finishLine.size() == 0) {
throw new InvalidTrackFormatException("No finish line found!");
throw new InvalidTrackFormatException();
}
finishTyp = getSpaceType(finishLine.get(0));
for (PositionVector positionVector : finishLine) {
if (getSpaceType(positionVector) != finishTyp) {
throw new InvalidTrackFormatException("Inconsistent finish line found!");
throw new InvalidTrackFormatException();
}
}
}
@ -185,7 +186,7 @@ public class Track implements TrackSpecification {
}
/**
* Method that returns the finish line as a List
* Method that returns the finishline as a List
*
* @return finishLine List
*/
@ -224,7 +225,7 @@ public class Track implements TrackSpecification {
//Removes the Car at Current Pos
drawCharOnTrackIndicator(carPositionVector, ConfigSpecification.SpaceType.TRACK.getValue());
//Redraw finish line if Car was on finish-line Position
//Redraw finishline if Car was on finish-line Position
for (PositionVector finishLinePositionVector : finishLine) {
if (finishLinePositionVector.equals(carPositionVector)) {
drawCharOnTrackIndicator(carPositionVector, finishTyp.getValue());
@ -255,7 +256,7 @@ public class Track implements TrackSpecification {
/**
* 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 carIndex of car that will be marked as crashed
* @param crashPositionVector of the location of the crash
*/
public void carDoesCrash(int carIndex, PositionVector crashPositionVector) {
@ -347,7 +348,7 @@ 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-value
* @param x position X-vlaue
* @param currentSpace char to return if no car is at position (x,y)
* @return character representing position (x,y) on the track
*/
@ -368,7 +369,7 @@ public class Track implements TrackSpecification {
* 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
* @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) {
@ -377,11 +378,11 @@ public class Track implements TrackSpecification {
int x = startPosition.getX();
int y = startPosition.getY();
// Relative Distance (x & y-axis) between end- and starting position
// 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
// Absolute distance (x & y axis) between end- and starting position
int distX = Math.abs(diffX);
int distY = Math.abs(diffY);
@ -394,7 +395,7 @@ public class Track implements TrackSpecification {
int diagonalStepX, diagonalStepY;
int distanceSlowAxis, distanceFastAxis;
if (distX > distY) {
// x-axis is the 'fast' direction
// x axis is the 'fast' direction
parallelStepX = dirX;
parallelStepY = 0; // parallel step only moves in x direction
diagonalStepX = dirX;
@ -402,7 +403,7 @@ public class Track implements TrackSpecification {
distanceSlowAxis = distY;
distanceFastAxis = distX;
} else {
// y-axis is the 'fast' direction
// y axis is the 'fast' direction
parallelStepX = 0;
parallelStepY = dirY; // parallel step only moves in y direction
diagonalStepX = dirX;
@ -431,13 +432,12 @@ public class Track implements TrackSpecification {
}
/**
* 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.
* This method will check if a car is passing the finishline.
* If the car is passing the finishline in the wrong direction, the car will lose a winpoint.
* If the car is passing the finishline in the correct direction, the car will gain a winpoint.
* @param start the startposition of the car
* @param finish the expected finishpositon 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);
@ -472,6 +472,8 @@ public class Track implements TrackSpecification {
}
break;
}
}
return 0;
}

2
src/main/java/ch/zhaw/pm2/racetrack/UserInterface.java
View File

@ -8,7 +8,7 @@ import java.util.List;
/**
* Class representing the Userinterface.
* Used to get inputs from users via text io.
* Used to get inputs from users via textio.
*
* @author Roman Schenk
*/

7
src/main/java/ch/zhaw/pm2/racetrack/strategy/DoNotMoveStrategy.java
View File

@ -5,15 +5,10 @@ import ch.zhaw.pm2.racetrack.PositionVector;
import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
/**
* This Class represents the DoNotMoveStrategy.
* Do not accelerate in any direction.
*/
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() {
return PositionVector.Direction.NONE;

28
src/main/java/ch/zhaw/pm2/racetrack/strategy/MoveListStrategy.java
View File

@ -1,6 +1,5 @@
package ch.zhaw.pm2.racetrack.strategy;
import ch.zhaw.pm2.racetrack.InvalidFileFormatException;
import ch.zhaw.pm2.racetrack.PositionVector.Direction;
import java.io.File;
@ -11,52 +10,31 @@ 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 {
public MoveListStrategy(String path) throws FileNotFoundException{
moveList = new ArrayList<>();
pointer = -1;
readFile(moveListFile);
readFile(new File(path));
}
/**
* 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 {
private void readFile(File trackFile) throws FileNotFoundException {
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() {
pointer += 1;

204
src/main/java/ch/zhaw/pm2/racetrack/strategy/PathFinderMoveStrategy.java
View File

@ -4,217 +4,163 @@ import ch.zhaw.pm2.racetrack.PositionVector;
import ch.zhaw.pm2.racetrack.Track;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Strategy which calculates the path automatically
*/
public class PathFinderMoveStrategy implements MoveStrategy {
private final Track track;
private final int carIndex;
public class PathFinderMoveStrategy implements MoveStrategy{
private Track track;
private 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<PositionVector.Direction> allDirections;
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();
allDirections = Arrays.asList(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;
private void createMoveList(){
pointer = -1;
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) {
List<PossibleMove> possibleMoves= new ArrayList<>();
for(PositionVector.Direction direction : allDirections){
PossibleMove newMove = new PossibleMove(null, direction);
if (!newMove.crashed()) {
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) {
while(finishedMove == null){
List<PossibleMove> newMoves = new ArrayList<>();
for (PossibleMove previousMove : possibleMoves) {
for (PositionVector.Direction direction : allDirections) {
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);
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)) {
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;
public class State{
PositionVector position;
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) {
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);
public boolean equals(State compareState){
if(compareState.position.equals(position) && compareState.velocity.equals(velocity)){
return true;
} else{
return false;
}
}
}
/**
* 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
public class PossibleMove {
List<PositionVector.Direction> directions;
PositionVector startPosition;
PositionVector endPosition;
PositionVector endVelocity;
public PossibleMove(PossibleMove previousMove, PositionVector.Direction nextDirection){
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
if(previousMove != null){
directions.addAll(previousMove.directions);
startPosition = previousMove.endPosition;
startVelocity = previousMove.endVelocity;
}
else {
startPosition = track.getCarPos(carIndex);
startVelocity = track.getCar(carIndex).getVelocity();
}
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;
public boolean finished(){
if(track.calculateNewWinPoints(startPosition, endPosition) == 1){
return true;
}
else{
return false;
}
}
/**
* 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)) {
for(PositionVector point : points) {
if (track.willCrashAtPosition(carIndex, point)){
return true;
}
}
return track.calculateNewWinPoints(startPosition, endPosition) == -1;
if(track.calculateNewWinPoints(startPosition, endPosition) == -1){
return true;
}
return false;
}
}
/**
* 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() {
public PositionVector.Direction nextMove() { //TODO check for crash and recreate movelist if crash
pointer += 1;
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)) {
System.out.println("currentVelocity:" + currentVelocity.getX()+ ","+ currentVelocity.getY());
System.out.println("newVelocity:" + newVelocity.getX()+ ","+ 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 moveList.get(pointer);
}
return null;
}

60
src/main/java/ch/zhaw/pm2/racetrack/strategy/PathFollowerMoveStrategy.java
View File

@ -1,6 +1,5 @@
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;
@ -35,41 +34,34 @@ public class PathFollowerMoveStrategy implements MoveStrategy {
/**
* Constructor to create a new PathFollowerMoveStrategy for a car.
*
* @param trackFile The location where the file is saved
* @param path The location where the file is saved
* @param startPosition The start position of the car
* @throws FileNotFoundException If the file with the given path does not exist.
*/
public PathFollowerMoveStrategy(File trackFile, PositionVector startPosition) throws FileNotFoundException, InvalidFileFormatException {
public PathFollowerMoveStrategy(String path, PositionVector startPosition) throws FileNotFoundException {
pointList = new ArrayList<>();
pointer = 0;
readFile(trackFile);
readFile(new File(path));
currentPosition = startPosition;
currentVelocity = new PositionVector(0, 0);
}
/**
* Method to read the given File and add the points to the pointList
*
* @param trackFile the File Object which should be read
* @throws FileNotFoundException If the file with the given path does not exist.
*/
public void readFile(File trackFile) throws FileNotFoundException, InvalidFileFormatException {
public void readFile(File trackFile) throws FileNotFoundException {
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");
}
pointList.add(new PositionVector(Integer.parseInt(coordinates[1]), Integer.parseInt(coordinates[2])));
}
}
/**
* Method to select the direction for the next move.
*
* @return The direction for the next move. null if there are no points left in the list.
*/
@Override
@ -81,7 +73,7 @@ public class PathFollowerMoveStrategy implements MoveStrategy {
// increase pointer variable if the next point is reached.
if (pointList.get(pointer).equals(currentPosition)) {
pointer++;
pointer ++;
}
// calculate Vector from current Position to next Point
@ -89,29 +81,31 @@ public class PathFollowerMoveStrategy implements MoveStrategy {
// 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
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
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;
}
@ -127,7 +121,7 @@ public class PathFollowerMoveStrategy implements MoveStrategy {
return direction;
}
}
return null;
return null;
}
}

6
src/main/java/ch/zhaw/pm2/racetrack/strategy/UserMoveStrategy.java
View File

@ -5,7 +5,6 @@ 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;
@ -18,11 +17,6 @@ public class UserMoveStrategy implements MoveStrategy {
this.carID = carID;
}
/**
* Uses the interface to determine which move the user takes.
*
* @return the next taken move as Direction
*/
@Override
public Direction nextMove() {
return userInterface.selectDirection(carIndex, carID);

53
src/test/java/ch/zhaw/pm2/racetrack/CarTest.java
View File

@ -6,38 +6,33 @@ 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.Arrays;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
/**
* Class that contains all test for the Class Car
*
* @author Roman Schenk
* Tests for Class Car
*/
class CarTest {
Car car;
// Default coordinates for tests
final int DEFAULT_X = 10;
final int DEFAULT_Y = 10;
final char DEFAULT_ID = 'f';
int DEFAULT_X = 10;
int DEFAULT_Y = 10;
char DEFAULT_ID = 'f';
/**
* Creates a new Car Object and set Position to a defined Default Position
* 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));
}
/**
* Checks if the method getID returns the correct value
*/
@Test
void getID() {
assertEquals(DEFAULT_ID, car.getID());
@ -54,8 +49,8 @@ class CarTest {
}
/**
* 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.
* - 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() {
@ -113,6 +108,7 @@ class CarTest {
checkNextPosition(DEFAULT_X, DEFAULT_Y);
for (PositionVector.Direction direction1 : directions) {
for (PositionVector.Direction direction2 : directions) {
@ -123,7 +119,7 @@ class CarTest {
int expectedNextPosX = DEFAULT_X;
int expectedNextPosY = DEFAULT_Y;
//variables to save the actual expected result of method getVelocity
//variables to save the acutal expected result of method getVelocity
int expectedVelocityX = 0;
int expectedVelocityY = 0;
@ -161,8 +157,7 @@ class CarTest {
/**
* Test for methods crash and isCrashed.
* Checks if state crashed is set and returned correctly.
* test for methods crash and isCrashed. checks if state crashed is set and returned correctly.
*/
@Test
void crash() {
@ -172,8 +167,8 @@ class CarTest {
}
/**
* Test for methods setMoveStrategy.
* Checks if the MoveStrategy Object is saved and returned correctly with all Types of MoveStrategy.
* test for methods setMoveStrategy. Checks if the MoveStrategy Object is saved and returned correctly
* with all Types of MoveStrategy.
*/
@Test
void MoveStrategy() {
@ -184,50 +179,50 @@ class CarTest {
assertEquals(moveStrategy, car.getMoveStrategy());
try {
moveStrategy = new MoveListStrategy(new File(".\\moves\\challenge-car-a.txt"));
} catch (FileNotFoundException | InvalidFileFormatException e) {
moveStrategy = new MoveListStrategy(".\\moves\\challenge-car-a.txt");
} catch (FileNotFoundException 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) {
moveStrategy = new PathFollowerMoveStrategy(".\\follower\\challenge_points.txt", new PositionVector(0, 0));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy());
moveStrategy = new UserMoveStrategy(new UserInterface("Hello"), 0, 'a');
moveStrategy = new UserMoveStrategy(new UserInterface("Hello"),0,'a');
car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy());
}
/**
* Tests if getWinPoints returns the correct value.
* Test for get WinPoints
*/
@Test
void getWinPoints() {
assertEquals(0, car.getWinPoints());
assertEquals(0,car.getWinPoints());
}
/**
* Tests if winpoints increase functions properly.
* Test for increase WinPoints
*/
@Test
void increaseWinPoints() {
car.increaseWinPoints();
assertEquals(1, car.getWinPoints());
assertEquals(1,car.getWinPoints());
}
/**
* Tests if the deductions of winpoints functions properly.
* Test for deduct WinPoints
*/
@Test
void deductWinPoints() {
car.deductWinPoints();
assertEquals(-1, car.getWinPoints());
assertEquals(-1,car.getWinPoints());
}
}

133
src/test/java/ch/zhaw/pm2/racetrack/GameTest.java
View File

@ -1,8 +1,11 @@
package ch.zhaw.pm2.racetrack;
import ch.zhaw.pm2.racetrack.strategy.UserMoveStrategy;
import org.junit.jupiter.api.*;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Assertions;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.List;
@ -11,9 +14,7 @@ import static ch.zhaw.pm2.racetrack.PositionVector.Direction.*;
/**
* Test for Class Game. The Class is split up in nested classes.
*
* @author Andrin Fassbind
* Test for Class Game
*/
class GameTest {
private UserInterface userInterface;
@ -25,20 +26,16 @@ class GameTest {
private final int CAR_INDEX_TWO = 1;
/**
* This nested Class tests if the game gets initiated correctly.
* This nested Class tests if the game gets initiatet 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);
game = new Game(userInterface);
try {
track = game.selectTrack(new File(TRACK_FILE_PATH));
} catch (InvalidTrackFormatException | FileNotFoundException e) {
@ -50,9 +47,6 @@ class GameTest {
}
/**
* Tests if car index is correct
*/
@Test
void getCurrentCarIndex() {
Assertions.assertEquals(CAR_INDEX_ONE, game.getCurrentCarIndex());
@ -60,52 +54,34 @@ class GameTest {
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());
@ -122,8 +98,7 @@ class GameTest {
@BeforeEach
void setup() {
userInterface = new UserInterface("Test");
Config config = new Config();
game = new Game(userInterface, config);
game = new Game(userInterface);
try {
track = game.selectTrack(new File(TRACK_FILE_PATH));
} catch (InvalidTrackFormatException | FileNotFoundException e) {
@ -135,18 +110,12 @@ class GameTest {
}
/**
* 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);
@ -155,20 +124,16 @@ class GameTest {
}
/**
* 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.
* This nested Class tests a Playtrough. And implements a UserInterface interagtion to pretend a real player
*/
@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,
game = new Game(new interFace("Test",new Integer[]{0,2,0},new PositionVector.Direction[]{RIGHT,
RIGHT,
RIGHT,
NONE,
@ -206,75 +171,35 @@ class GameTest {
UP_RIGHT,
UP_RIGHT,
RIGHT,
RIGHT}), new Config());
RIGHT}));
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 = new Game(new interFace("Test",new Integer[]{0,1,0},new PositionVector.Direction[]{UP}));
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 class interFace extends UserInterface {
private final PositionVector.Direction[] directions;
private final Integer[] instructions;
private PositionVector.Direction[] directions;
private 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);
public interFace(String welcometxt, Integer[] instructions, PositionVector.Direction[] directions) {
super(welcometxt);
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++;
@ -282,29 +207,15 @@ class GameTest {
}
/**
* 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 printTrack(Track track) {
}
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) {

20
src/test/java/ch/zhaw/pm2/racetrack/MoveListStrategyTest.java → src/test/java/ch/zhaw/pm2/racetrack/MoveStrategyTest.java
View File

@ -4,38 +4,26 @@ 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 {
public class MoveStrategyTest {
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) {
moveList = new MoveListStrategy(".\\moves\\challenge-car-a.txt");
}catch (FileNotFoundException e) {
e.printStackTrace();
}
}
/**
* Checks if the directions are returned correct by method nextMove
*/
@Test
void checkMove() {
Assertions.assertEquals(PositionVector.Direction.RIGHT,moveList.nextMove());

61
src/test/java/ch/zhaw/pm2/racetrack/TrackTest.java
View File

@ -2,26 +2,20 @@ 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 {
@DisplayName("Positiv Test Cases")
class positivClass {
/**
* Sets up the Test cases by loading the file and setting a new track.
*/
@BeforeEach
void setup() {
File file = new File(".\\tracks\\challenge.txt");
@ -34,18 +28,12 @@ public class TrackTest {
}
/**
* 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() {
@ -53,18 +41,13 @@ public class TrackTest {
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() {
@ -75,11 +58,8 @@ public class TrackTest {
Assertions.assertEquals(expected, trackObj.getFinishLine());
}
/**
* Checks if track does read in track file correctly
*/
@Test
@DisplayName("Converts track file correctly to List<String>")
@DisplayName("Converts Trackfile correctly to List<String>")
void checkTrack() {
Track trackObj;
try {
@ -105,9 +85,6 @@ public class TrackTest {
}
}
/**
* checks if track does process car move correctly
*/
@Test
@DisplayName("Make Car move down on track")
void makeCarMoveDown() {
@ -119,9 +96,6 @@ public class TrackTest {
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() {
@ -132,9 +106,6 @@ public class TrackTest {
Assertions.assertEquals(beforeMove.getX(), afterMove.getX());
}
/**
* Checks if car does crash
*/
@Test
@DisplayName("Will Car Crash")
void willCarCrash() {
@ -147,9 +118,6 @@ public class TrackTest {
}
/**
* checks if track is updated after car crash
*/
@Test
@DisplayName("Make Car Crash")
void makeCarCrash() {
@ -159,17 +127,10 @@ public class TrackTest {
}
}
/**
* 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");
@ -181,9 +142,6 @@ public class TrackTest {
}
}
/**
* Tries to read not valid file
*/
@Test
@DisplayName("Throw error if File not found")
void canReadFile() {
@ -191,14 +149,11 @@ public class TrackTest {
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));
File testfile = new File(".\\src\\test\\InvalidTracks\\sameCar.txt");
Assertions.assertThrows(InvalidTrackFormatException.class, () -> new Track(testfile));
}
}
}