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:CarTest
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 "CarTest" have entirely different histories.
main ... CarTest

24 changed files with 137 additions and 2083 deletions
Show Stats Expand all files Collapse all files

BIN
FeedbackP1_ruiz.md.pdf
View File

Binary file not shown.

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

53
README.md
View File

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

3
build.gradle
View File

@ -29,7 +29,6 @@ dependencies {
// beryx uses SLF4J. To remove warning, we add the implementation "no operation" // beryx uses SLF4J. To remove warning, we add the implementation "no operation"
implementation 'org.slf4j:slf4j-nop:2.+' implementation 'org.slf4j:slf4j-nop:2.+'
implementation 'junit:junit:4.13.1'
// Use JUnit Jupiter API for testing. // Use JUnit Jupiter API for testing.
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2' testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
@ -44,7 +43,7 @@ version = '2022.1'
application { application {
// Define the main class for the application. // Define the main class for the application.
mainClass = 'ch.zhaw.pm2.racetrack.Main' mainClass = 'ch.zhaw.pm2.racetrack.ConsoleApp'
} }
run { run {

23
follower/challenge_points.txt
View File

@ -1,23 +0,0 @@
(X:28, Y:22)
(X:31, Y:22)
(X:34, Y:22)
(X:37, Y:22)
(X:40, Y:22)
(X:43, Y:22)
(X:46, Y:21)
(X:48, Y:19)
(X:48, Y:17)
(X:46, Y:15)
(X:41, Y:13)
(X:41, Y:10)
(X:46, Y:9)
(X:49, Y:4)
(X:40, Y:2)
(X:30, Y:2)
(X:21, Y:3)
(X:16, Y:7)
(X:13, Y:10)
(X:14, Y:14)
(X:11, Y:19)
(X:13, Y:22)
(X:24, Y:22)

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

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

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

@ -6,9 +6,9 @@ import ch.zhaw.pm2.racetrack.strategy.MoveStrategy;
/** /**
* Class representing a car on the racetrack. * Class representing a car on the racetrack.
* Uses {@link PositionVector} to store current position on the track grid and current velocity vector. * Uses {@link PositionVector} to store current position on the track grid and current velocity vector.
* Each car has an identifier character which represents the car on the racetrack board. * Each car has an identifier character which represents the car on the race track board.
* Also keeps the state, if the car is crashed (not active anymore). The state can not be changed back to uncrashed. * Also keeps the state, if the car is crashed (not active anymore). The state can not be changed back to uncrashed.
* The velocity is changed by providing an acceleration vector. * The velocity is changed by providing an acelleration vector.
* The car is able to calculate the endpoint of its next position and on request moves to it. * The car is able to calculate the endpoint of its next position and on request moves to it.
*/ */
public class Car implements CarSpecification { public class Car implements CarSpecification {
@ -22,10 +22,6 @@ public class Car implements CarSpecification {
* Current position of the car on the track grid using a {@link PositionVector} * Current position of the car on the track grid using a {@link PositionVector}
*/ */
private PositionVector position; private PositionVector position;
/**
* Points that car is holding for determining winner.
*/
private int winPoints;
/** /**
* Current velocity of the car using a {@link PositionVector} * Current velocity of the car using a {@link PositionVector}
@ -44,8 +40,7 @@ public class Car implements CarSpecification {
/** /**
* Constructor for class Car * Constructor for class Car
* * @param id unique Car identification
* @param id unique Car identification
* @param position initial position of the Car * @param position initial position of the Car
*/ */
public Car(char id, PositionVector position) { public Car(char id, PositionVector position) {
@ -53,62 +48,17 @@ public class Car implements CarSpecification {
setPosition(position); setPosition(position);
} }
/**
* Returns the id of the car.
*
* @return id of the car.
*/
public char getID() {
return id;
}
/**
* Increases the winpoints by one
*/
public void increaseWinPoints() {
winPoints++;
}
/**
* Decreases the winpoints by one
*/
public void deductWinPoints() {
winPoints--;
}
/**
* Returns the current value of winpoints.
*
* @return winpoints of the car
*/
public int getWinPoints() {
return winPoints;
}
/**
* Returns the current velocity of the car as a PositionVector.
*
* @return velocity current velocity of the car.
*/
public PositionVector getVelocity() {
return velocity;
}
/** /**
* Set this Car position directly, regardless of current position and velocity. * 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. * 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. * @param position The new position to set the car directly to.
* @throws IllegalArgumentException if invalid PositionVector is given.
*/ */
@Override @Override
public void setPosition(final PositionVector position) { public void setPosition(final PositionVector position) {
if (position.getX() < 0 || position.getY() < 0) { // TODO: implementation
throw new IllegalArgumentException(); throw new UnsupportedOperationException();
} else {
this.position = position;
}
} }
/** /**
@ -119,7 +69,8 @@ public class Car implements CarSpecification {
*/ */
@Override @Override
public PositionVector nextPosition() { public PositionVector nextPosition() {
return new PositionVector(position.getX() + velocity.getX(), position.getY() + velocity.getY()); // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
@ -129,17 +80,11 @@ public class Car implements CarSpecification {
* Changes only velocity, not position. * Changes only velocity, not position.
* *
* @param acceleration A Direction vector containing the amounts to add to the velocity in x and y dimension * @param acceleration A Direction vector containing the amounts to add to the velocity in x and y dimension
* @throws IllegalArgumentException if PositionVector is not in allowed area.
*/ */
@Override @Override
public void accelerate(PositionVector.Direction acceleration) { public void accelerate(PositionVector.Direction acceleration) {
if (acceleration.vector.getX() < -1 || acceleration.vector.getX() > 1 || // TODO: implementation
acceleration.vector.getY() < -1 || acceleration.vector.getY() > 1) { throw new UnsupportedOperationException();
throw new IllegalArgumentException();
} else {
velocity = new PositionVector(velocity.getX() + acceleration.vector.getX(),
velocity.getY() + acceleration.vector.getY());
}
} }
/** /**
@ -147,42 +92,43 @@ public class Car implements CarSpecification {
*/ */
@Override @Override
public void move() { public void move() {
position = new PositionVector(position.getX() + velocity.getX(), position.getY() + velocity.getY()); // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
* Marks the car as crashed * Mark this Car as being crashed.
*/ */
@Override @Override
public void crash() { public void crash() {
crashed = true; // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
* 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. * @return Returns true if crash() has been called on this Car, false otherwise.
*/ */
@Override @Override
public boolean isCrashed() { public boolean isCrashed() {
return crashed; // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
* Returns the current move Strategy * Set move strategy
* * @param moveStrategy
* @return the current move Strategy
*/
public MoveStrategy getMoveStrategy() {
return this.moveStrategy;
}
/**
* Set the move Strategy of the car.
*
* @param moveStrategy Strategy to be implemented
*/ */
public void setMoveStrategy(MoveStrategy moveStrategy) { public void setMoveStrategy(MoveStrategy moveStrategy) {
this.moveStrategy = moveStrategy; this.moveStrategy = moveStrategy;
} }
/**
* Get current move strategy
* @return MoveStrategy
*/
public MoveStrategy getMoveStrategy() {
return this.moveStrategy;
}
} }

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

@ -1,12 +1,7 @@
package ch.zhaw.pm2.racetrack; package ch.zhaw.pm2.racetrack;
import ch.zhaw.pm2.racetrack.given.GameSpecification; import ch.zhaw.pm2.racetrack.given.GameSpecification;
import ch.zhaw.pm2.racetrack.strategy.*;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List; import java.util.List;
import static ch.zhaw.pm2.racetrack.PositionVector.Direction; import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
@ -18,204 +13,59 @@ import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
*/ */
public class Game implements GameSpecification { public class Game implements GameSpecification {
public static final int NO_WINNER = -1; public static final int NO_WINNER = -1;
private Track track;
private int currentCarIndex;
private final Config config;
private final UserInterface userInterface;
public Game(UserInterface userInterface, Config config) {
this.userInterface = userInterface;
this.config = config;
}
/**
* This method will initialize the game. Therefore, it interacts with the user via UserInterface
*
* @return true if the initialization is completed. Returns false if there is an error.
*/
public boolean initPhase() {
if (config.getTrackDirectory().listFiles().length > 0) {
File selectedTrack = config.getTrackDirectory().listFiles()[userInterface.selectOption("Select Track file", Arrays.asList(config.getTrackDirectory().list()))];
try {
selectTrack(selectedTrack);
} catch (FileNotFoundException e) {
userInterface.printInformation("There is an unexpected Error with the track file Path. Add track files only to tracks path. Exit the Game and Fix the Problem");
return false;
} catch (InvalidTrackFormatException e) {
userInterface.printInformation("There is an unexpected Error with the track file. Format does not match specifications! Exit the Game and Fix the Problem");
return false;
}
List<String> moveStrategies = new ArrayList<>();
moveStrategies.add("Do not move Strategy");
moveStrategies.add("User Move Strategy");
moveStrategies.add("Move List Strategy");
moveStrategies.add("Path Follow Move Strategy");
moveStrategies.add("Path Finder Move Strategy");
for (int carIndex = 0; carIndex < track.getCarCount(); carIndex++) {
Car car = track.getCar(carIndex);
MoveStrategy moveStrategy = null;
while (moveStrategy == null) {
int moveStrategie = userInterface.selectOption(
"Select Strategy for Car " + carIndex + " (" + track.getCarId(carIndex) + ")", moveStrategies);
switch (moveStrategie) {
case 0 -> moveStrategy = new DoNotMoveStrategy();
case 1 -> moveStrategy = new UserMoveStrategy(userInterface, carIndex, track.getCarId(carIndex));
case 2 -> moveStrategy = getMoveListStrategy(selectedTrack, carIndex);
case 3 -> moveStrategy = getPathFollowerMoveStrategy(selectedTrack, carIndex);
case 4 -> moveStrategy = new PathFinderMoveStrategy(track, carIndex);
}
}
selectMoveStrategy(car, moveStrategy);
}
return true;
} else {
userInterface.printInformation("No track file found!");
return false;
}
}
/**
* creates a PathFollowerMoveStrategy for a specific track and a specific car
* @param selectedTrack the selected Track
* @param carIndex the Index of the car
* @return the created Movestrategy, null if File not found or invalid
*/
private MoveStrategy getPathFollowerMoveStrategy(File selectedTrack, int carIndex) {
File selectedFile = null;
MoveStrategy moveStrategy = null;
for (File file : config.getFollowerDirectory().listFiles()) {
if (file.toString().equals(config.getFollowerDirectory().toString() + "\\" + selectedTrack.getName().split("\\.")[0] + "_points.txt")) {
selectedFile = file;
}
}
if (selectedFile != null) {
try {
moveStrategy = new PathFollowerMoveStrategy(selectedFile, track.getCarPos(carIndex));
} catch (FileNotFoundException e) {
e.printStackTrace();
userInterface.printInformation("There is no Point-List implemented. Choose another Strategy!");
} catch (InvalidFileFormatException e) {
e.printStackTrace();
userInterface.printInformation("Invalid Point-List format. Change Strategy and clean Point-List");
}
} else {
userInterface.printInformation("There is no Point-List implemented. Choose another Strategy!");
}
return moveStrategy;
}
/**
* creates a MoveListStrategy for a specific track and a specific car
* @param selectedTrack the selected Track
* @param carIndex the Index of the car
* @return the created Movestrategy, null if File not found or invalid
*/
private MoveStrategy getMoveListStrategy(File selectedTrack, int carIndex) {
File selectedFile = null;
MoveStrategy moveStrategy = null;
for (File file : config.getMoveDirectory().listFiles()) {
if (file.toString().equals(config.getMoveDirectory().toString() + "\\" + selectedTrack.getName().split("\\.")[0] + "-car-" + track.getCar(carIndex).getID() + ".txt")) {
selectedFile = file;
}
}
if (selectedFile != null) {
try {
moveStrategy = new MoveListStrategy(selectedFile);
} catch (FileNotFoundException e) {
userInterface.printInformation("There is no Move-List implemented. Choose another Strategy!");
e.printStackTrace();
} catch (InvalidFileFormatException e) {
userInterface.printInformation("Invalid Data in Move-List. Choose another Strategy and clean the File");
e.printStackTrace();
}
} else {
userInterface.printInformation("There is no Move-List implemented. Choose another Strategy!");
}
return moveStrategy;
}
/**
* Selects the desired track and returns it.
* The functionality was taken out of init to automate testing.
*
* @param selectedTrack the Track which was selected by user
*/
Track selectTrack(File selectedTrack) throws InvalidTrackFormatException, FileNotFoundException {
track = new Track(selectedTrack);
return track;
}
/**
* Sets a desired move strategy for a desired car.
* The functionality was taken out of init to automate testing
*
* @param car to set the MoveStrategy
* @param strategy The movestrategy to set
*/
void selectMoveStrategy(Car car, MoveStrategy strategy) {
car.setMoveStrategy(strategy);
}
/** /**
* Return the index of the current active car. * 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. * 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 * @return The zero-based number of the current car
*/ */
@Override @Override
public int getCurrentCarIndex() { public int getCurrentCarIndex() {
return currentCarIndex; // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
* Gets the id of the specified car. * Get the id of the specified car.
*
* @param carIndex The zero-based carIndex number * @param carIndex The zero-based carIndex number
* @return A char containing the id of the car * @return A char containing the id of the car
*/ */
@Override @Override
public char getCarId(int carIndex) { public char getCarId(int carIndex) {
return track.getCarId(carIndex); // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
* Get the position of the specified car. * Get the position of the specified car.
*
* @param carIndex The zero-based carIndex number * @param carIndex The zero-based carIndex number
* @return A PositionVector containing the car's current position * @return A PositionVector containing the car's current position
*/ */
@Override @Override
public PositionVector getCarPosition(int carIndex) { public PositionVector getCarPosition(int carIndex) {
return track.getCarPos(carIndex); // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
* Get the velocity of the specified car. * Get the velocity of the specified car.
*
* @param carIndex The zero-based carIndex number * @param carIndex The zero-based carIndex number
* @return A PositionVector containing the car's current velocity * @return A PositionVector containing the car's current velocity
*/ */
@Override @Override
public PositionVector getCarVelocity(int carIndex) { 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 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 * @return The winning car's index (zero-based, see getCurrentCar()), or NO_WINNER if the game is still in progress
*/ */
@Override @Override
public int getWinner() { public int getWinner() {
for (int i = 0; i < track.getCarCount(); i++) { // TODO: implementation
if (track.getCar(i).getWinPoints() == 1) { throw new UnsupportedOperationException();
return i;
}
}
if (onlyOneCarLeft()) {
return currentCarIndex;
}
return NO_WINNER;
} }
/** /**
@ -241,69 +91,13 @@ 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 * <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> * 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 * for this turn
*/ */
@Override @Override
public void doCarTurn(Direction acceleration) { public void doCarTurn(Direction acceleration) {
track.getCar(currentCarIndex).accelerate(acceleration); // TODO: implementation
PositionVector crashPosition = null; throw new UnsupportedOperationException();
List<PositionVector> positionList = calculatePath(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition());
for (int i = 0; i < positionList.size(); i++) {
if (willCarCrash(currentCarIndex, positionList.get(i))) {
if (i == 0) {
crashPosition = track.getCarPos(currentCarIndex);
} else {
crashPosition = positionList.get(i - 1);
}
break;
}
}
int newWinPoints = track.calculateNewWinPoints(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition());
if (newWinPoints == 1) {
track.getCar(currentCarIndex).increaseWinPoints();
} else if (newWinPoints == -1) {
track.getCar(currentCarIndex).deductWinPoints();
}
if (crashPosition != null) {
track.carDoesCrash(currentCarIndex, crashPosition);
} else {
track.moveCar(currentCarIndex);
}
}
/**
* This method is in charge of changing the players and checking if a winner is found if there is no winner null will be returned.
* If a winner is found the game will return the char of the winning player.
*
* @return the ID of the winning car return null if there is no winner.
*/
public String gamePhase() {
boolean quit = false;
while (carsMoving() && getWinner() == NO_WINNER && !quit) {
userInterface.printInformation("Player " + track.getCar(currentCarIndex).getID() + "'s turn!");
userInterface.printTrack(track);
Direction direction;
direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
if (direction == null) {
if (track.getCar(currentCarIndex).getMoveStrategy() instanceof UserMoveStrategy) {
quit = true;
direction = Direction.NONE;
} else {
track.getCar(currentCarIndex).setMoveStrategy(new DoNotMoveStrategy());
direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
}
}
doCarTurn(direction);
switchToNextActiveCar();
}
userInterface.printInformation("The game has finished!");
userInterface.printTrack(track);
int indexWinner = getWinner();
if (indexWinner == NO_WINNER) {
return null;
}
return String.valueOf(track.getCar(indexWinner).getID());
} }
/** /**
@ -311,13 +105,8 @@ public class Game implements GameSpecification {
*/ */
@Override @Override
public void switchToNextActiveCar() { public void switchToNextActiveCar() {
do { // TODO: implementation
if ((currentCarIndex + 1) == track.getCarCount()) { throw new UnsupportedOperationException();
currentCarIndex = 0;
} else {
currentCarIndex++;
}
} while (track.getCar(currentCarIndex).isCrashed());
} }
/** /**
@ -328,54 +117,25 @@ public class Game implements GameSpecification {
* - Detect which axis of the distance vector is longer (faster movement) * - 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. * - for each pixel on the 'faster' axis calculate the position on the 'slower' axis.
* Direction of the movement has to correctly considered * Direction of the movement has to correctly considered
*
* @param startPosition Starting position as a PositionVector * @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. * @return Intervening grid positions as a List of PositionVector's, including the starting and ending positions.
*/ */
@Override @Override
public List<PositionVector> calculatePath(PositionVector startPosition, PositionVector endPosition) { public List<PositionVector> calculatePath(PositionVector startPosition, PositionVector endPosition) {
return track.calculatePointsOnPath(startPosition, endPosition); // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
* Does indicate if a car would have a crash with a WALL space or another car at the given position. * Does indicate if a car would have a crash with a WALL space or another car at the given position.
*
* @param carIndex The zero-based carIndex number * @param carIndex The zero-based carIndex number
* @param position A PositionVector of the possible crash position * @param position A PositionVector of the possible crash position
* @return A boolean indicator if the car would crash with a WALL or another car. * @return A boolean indicator if the car would crash with a WALL or another car.
*/ */
@Override @Override
public boolean willCarCrash(int carIndex, PositionVector position) { public boolean willCarCrash(int carIndex, PositionVector position) {
return track.willCrashAtPosition(carIndex, position); // TODO: implementation
} throw new UnsupportedOperationException();
/**
* Checks if there is just one player left in the game being able to make moves.
*
* @return true if there is just one car left false there are more than one car left in game
*/
public boolean onlyOneCarLeft() {
int carsLeft = 0;
for (int carIndex = 0; carIndex < track.getCarCount(); carIndex++) {
if (!track.getCar(carIndex).isCrashed()) {
carsLeft++;
}
}
return !(carsLeft > 1);
}
/**
* Checks if all cars have implemented the do not move strategy, so the game can determine it will end in a draw.
*
* @return true if all players have implemented do not move false otherwise
*/
public boolean carsMoving() {
for (int carIndex = 0; carIndex < track.getCarCount(); carIndex++) {
if (!(track.getCar(carIndex).isCrashed() || track.getCar(carIndex).getMoveStrategy().getClass() == DoNotMoveStrategy.class)) {
return true;
}
}
return false;
} }
} }

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

@ -1,19 +1,5 @@
package ch.zhaw.pm2.racetrack; package ch.zhaw.pm2.racetrack;
/**
* Class for Exception when an invalid file format is used.
*/
public class InvalidFileFormatException extends Exception { public class InvalidFileFormatException extends Exception {
public InvalidFileFormatException() { // TODO: implementation
super();
}
/**
* Constructor that is used when an error message is given with the exception.
*
* @param errorMessage is the message to be displayed
*/
public InvalidFileFormatException(String errorMessage) {
super(errorMessage);
}
} }

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

@ -1,20 +1,5 @@
package ch.zhaw.pm2.racetrack; package ch.zhaw.pm2.racetrack;
/**
* Class for Exception when invalid track format is used.
*/
public class InvalidTrackFormatException extends Exception { public class InvalidTrackFormatException extends Exception {
public InvalidTrackFormatException() { // TODO: implementation
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);
}
} }

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

@ -1,49 +0,0 @@
package ch.zhaw.pm2.racetrack;
import java.util.ArrayList;
import java.util.List;
/**
* Class containing the main method
*
* @author Roman Schenk
*/
public class Main {
/**
* Method creating the game and initializing the Configs and Userinterface.
* Starts and initializes a new game until the user decides to stop the game.
* In charge of closing the user interface when user decides to stop the game
*
* @param args no arguments needed
*/
public static void main(String[] args) {
UserInterface userInterface = new UserInterface("Hello and Welcome to Racetrack by Team02-\"AngryNerds\"");
Config config = new Config();
while (true) {
Game game = new Game(userInterface, config);
String winner;
if (game.initPhase()) {
winner = game.gamePhase();
List<String> optionsNewGame = new ArrayList<>();
optionsNewGame.add("exit");
optionsNewGame.add("new game");
String winnerText;
if (winner == null) {
winnerText = "There was no winner.";
} else {
winnerText = "The Winner was Car " + winner;
}
int selectedOption = userInterface.selectOption(winnerText + "\nStart new Game?", optionsNewGame);
if (selectedOption == 0) {
userInterface.quit("Thank you and goodbye\npress enter to close the application.");
break;
}
} else {
userInterface.quit("The initialisation of the game failed. Press enter to close the application.");
break;
}
}
}
}

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

@ -1,15 +1,9 @@
package ch.zhaw.pm2.racetrack; package ch.zhaw.pm2.racetrack;
import ch.zhaw.pm2.racetrack.given.ConfigSpecification;
import ch.zhaw.pm2.racetrack.given.TrackSpecification; import ch.zhaw.pm2.racetrack.given.TrackSpecification;
import java.io.File; import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException; import java.io.FileNotFoundException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/** /**
* This class represents the racetrack board. * This class represents the racetrack board.
@ -45,9 +39,9 @@ import java.util.Scanner;
* There are 1 to {@link Config#MAX_CARS} allowed. </li> * There are 1 to {@link Config#MAX_CARS} allowed. </li>
* </ul> * </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. * 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 * An {@link InvalidTrackFormatException} is thrown, if
* <ul> * <ul>
* <li>not all track lines have the same length</li> * <li>not all track lines have the same length</li>
@ -55,216 +49,24 @@ import java.util.Scanner;
* <li>the file contains more than {@link Config#MAX_CARS} cars</li> * <li>the file contains more than {@link Config#MAX_CARS} cars</li>
* </ul> * </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 { public class Track implements TrackSpecification {
public static final char CRASH_INDICATOR = 'X'; public static final char CRASH_INDICATOR = 'X';
private final List<String> track;
private final List<Car> cars; // TODO: Add necessary variables
private final List<PositionVector> finishLine;
private ConfigSpecification.SpaceType finishTyp;
/** /**
* Initializes the Track from the given track File including the cars. * Initialize a Track from the given track file.
* Throws a corresponding error if one of the conditions are not met to build a track.
* *
* @param trackFile Reference to a file containing the track data * @param trackFile Reference to a file containing the track data
* @throws FileNotFoundException if the given track file could not be found * @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 { 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), StandardCharsets.UTF_8);
while (scanner.hasNextLine()) {
track.add(scanner.nextLine());
}
}
/**
* Goes through the track ArrayList and determines the locations of each car and initializes them at the location.
*
* @throws InvalidTrackFormatException is thrown if a car is found more than once inside the track.
*/
private void addCars() throws InvalidTrackFormatException {
ConfigSpecification.SpaceType[] spaceTypes = ConfigSpecification.SpaceType.values();
List<Character> allSpaceTypesAsChar = new ArrayList<>();
List<Character> usedSymbolForCar = new ArrayList<>();
for (ConfigSpecification.SpaceType spaceType : spaceTypes) {
allSpaceTypesAsChar.add(spaceType.getValue());
}
for (int yPosition = 0; yPosition < track.size(); yPosition++) {
String line = track.get(yPosition);
for (int xPosition = 0; xPosition < line.length(); xPosition++) {
char possibleCarChar = line.charAt(xPosition);
if (!allSpaceTypesAsChar.contains(possibleCarChar)) {
if (usedSymbolForCar.contains(possibleCarChar)) {
throw new InvalidTrackFormatException("More than one car on track!");
}
usedSymbolForCar.add(possibleCarChar);
cars.add(new Car(possibleCarChar, new PositionVector(xPosition, yPosition)));
}
}
}
}
/**
* Determines the finish line and saves it in a list, throws an Exception if none is found.
*
* @throws InvalidTrackFormatException thrown if no finish line is found
*/
private void findFinish() throws InvalidTrackFormatException {
for (int i = 0; i < track.size(); i++) {
String line = track.get(i);
for (int j = 0; j < line.length(); j++) {
if (line.charAt(j) == ConfigSpecification.SpaceType.FINISH_LEFT.getValue() ||
line.charAt(j) == ConfigSpecification.SpaceType.FINISH_RIGHT.getValue() ||
line.charAt(j) == ConfigSpecification.SpaceType.FINISH_DOWN.getValue() ||
line.charAt(j) == ConfigSpecification.SpaceType.FINISH_UP.getValue()) {
finishLine.add(new PositionVector(j, i));
}
}
}
if (finishLine.size() == 0) {
throw new InvalidTrackFormatException("No finish line found!");
}
finishTyp = getSpaceType(finishLine.get(0));
for (PositionVector positionVector : finishLine) {
if (getSpaceType(positionVector) != finishTyp) {
throw new InvalidTrackFormatException("Inconsistent finish line found!");
}
}
}
/**
* Method to find the PositionVector of a chosen character
*
* @param symbol char that we are looking for on the track
* @return the PositionVector of the desired char
*/
private PositionVector findChar(char symbol) {
PositionVector vector = null;
for (int i = 0; i < track.size(); i++) {
String line = track.get(i);
for (int j = 0; j < line.length(); j++) {
if (line.charAt(j) == symbol) {
vector = new PositionVector(j, i);
}
}
}
return vector;
}
/**
* Method that places a character at a chosen position
*
* @param positionVector position where char will be placed
* @param symbol char that should be placed at desired position
*/
private void drawCharOnTrackIndicator(PositionVector positionVector, char symbol) {
String line = track.get(positionVector.getY());
line = line.substring(0, positionVector.getX()) + symbol + line.substring(positionVector.getX() + 1);
track.remove(positionVector.getY());
track.add(positionVector.getY(), line);
}
/**
* Method that returns the finish line as a List
*
* @return finishLine List
*/
public List<PositionVector> getFinishLine() {
return finishLine;
}
/**
* Returns the whole Track as List of Strings
*
* @return track as List of Strings
*/
public List<String> getTrack() {
return track;
}
/**
* This Method will update the Car on the track
* and will make the Car move to the next position
*
* @param carIndex representing the current Car
*/
public void moveCar(int carIndex) {
makeCarMoveInTrack(carIndex);
//Change position of car
getCar(carIndex).move();
}
/**
* This Method does change the Position of the car inside the track object.
*
* @param carIndex of the current car
*/
private void makeCarMoveInTrack(int carIndex) {
PositionVector carPositionVector = findChar(getCarId(carIndex));
//Removes the Car at Current Pos
drawCharOnTrackIndicator(carPositionVector, ConfigSpecification.SpaceType.TRACK.getValue());
//Redraw finish line if Car was on finish-line Position
for (PositionVector finishLinePositionVector : finishLine) {
if (finishLinePositionVector.equals(carPositionVector)) {
drawCharOnTrackIndicator(carPositionVector, finishTyp.getValue());
}
}
//Adds Car at new Position
carPositionVector = cars.get(carIndex).nextPosition();
drawCharOnTrackIndicator(carPositionVector, cars.get(carIndex).getID());
}
/**
* This Method will check if the Car would crash at the specific position
*
* @param positionVector the position to check if the car would crash
* @return true if crash otherwise false
*/
public boolean willCrashAtPosition(int carIndex, PositionVector positionVector) {
char charAtPosition = track.get(positionVector.getY()).charAt(positionVector.getX());
if (getCarId(carIndex) == charAtPosition) return false;
return !(charAtPosition == ConfigSpecification.SpaceType.TRACK.value ||
charAtPosition == ConfigSpecification.SpaceType.FINISH_RIGHT.value ||
charAtPosition == ConfigSpecification.SpaceType.FINISH_LEFT.value ||
charAtPosition == ConfigSpecification.SpaceType.FINISH_UP.value ||
charAtPosition == ConfigSpecification.SpaceType.FINISH_DOWN.value);
}
/**
* This Method will mark the Car as crashed inside the track and the car Object.
*
* @param carIndex of car that will be marked as crashed
* @param crashPositionVector of the location of the crash
*/
public void carDoesCrash(int carIndex, PositionVector crashPositionVector) {
PositionVector currentCarPosition = getCarPos(carIndex);
drawCharOnTrackIndicator(new PositionVector(currentCarPosition.getX(), currentCarPosition.getY()), ConfigSpecification.SpaceType.TRACK.getValue());
Car car = cars.get(carIndex);
car.crash();
car.setPosition(crashPositionVector);
drawCharOnTrackIndicator(new PositionVector(crashPositionVector.getX(), crashPositionVector.getY()), CRASH_INDICATOR);
} }
/** /**
@ -272,29 +74,23 @@ public class Track implements TrackSpecification {
* If the location is outside the track bounds, it is considered a wall. * If the location is outside the track bounds, it is considered a wall.
* *
* @param position The coordinates of the position to examine * @param position The coordinates of the position to examine
* @return The type of space at the desired position * @return The type of track position at the given location
*/ */
@Override @Override
public Config.SpaceType getSpaceType(PositionVector position) { public Config.SpaceType getSpaceType(PositionVector position) {
char charAtPosition = track.get(position.getY()).charAt(position.getX()); // TODO: implementation
ConfigSpecification.SpaceType[] spaceTypes = ConfigSpecification.SpaceType.values(); throw new UnsupportedOperationException();
for (ConfigSpecification.SpaceType spaceType : spaceTypes) {
if (spaceType.getValue() == charAtPosition) {
return spaceType;
}
}
return ConfigSpecification.SpaceType.WALL;
} }
/** /**
* Return the number of cars that are located in a track * Return the number of cars.
* *
* @return number of cars as int * @return Number of cars
*/ */
@Override @Override
public int getCarCount() { public int getCarCount() {
return cars.size(); // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
@ -305,7 +101,8 @@ public class Track implements TrackSpecification {
*/ */
@Override @Override
public Car getCar(int carIndex) { public Car getCar(int carIndex) {
return cars.get(carIndex); // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
@ -316,19 +113,20 @@ public class Track implements TrackSpecification {
*/ */
@Override @Override
public char getCarId(int carIndex) { public char getCarId(int carIndex) {
return cars.get(carIndex).getID(); // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
* Get the position of the specified car. * Get the position of the specified car.
* Returns Null if carIndex not valid
* *
* @param carIndex The zero-based carIndex number * @param carIndex The zero-based carIndex number
* @return A PositionVector containing the car's current position * @return A PositionVector containing the car's current position
*/ */
@Override @Override
public PositionVector getCarPos(int carIndex) { public PositionVector getCarPos(int carIndex) {
return findChar(cars.get(carIndex).getID()); // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
@ -339,7 +137,8 @@ public class Track implements TrackSpecification {
*/ */
@Override @Override
public PositionVector getCarVelocity(int carIndex) { public PositionVector getCarVelocity(int carIndex) {
return cars.get(carIndex).getVelocity(); // TODO: implementation
throw new UnsupportedOperationException();
} }
/** /**
@ -347,133 +146,14 @@ public class Track implements TrackSpecification {
* If there is a crashed car at the position, {@link #CRASH_INDICATOR} is returned. * If there is a crashed car at the position, {@link #CRASH_INDICATOR} is returned.
* *
* @param y position Y-value * @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) * @param currentSpace char to return if no car is at position (x,y)
* @return character representing position (x,y) on the track * @return character representing position (x,y) on the track
*/ */
@Override @Override
public char getCharAtPosition(int y, int x, Config.SpaceType currentSpace) { 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();
}
/**
* Determines all points that lie between the two position vectors including the endpoint VectorPosition using the Bresenham algorithm.
*
* @param startPosition PositionVector of the finish coordinate
* @param endPosition PositionVector of the start coordinate
* @return ArrayList containing PositionVectors of all position that are between the start and finish including the finish position.
*/
public ArrayList<PositionVector> calculatePointsOnPath(PositionVector startPosition, PositionVector endPosition) {
ArrayList<PositionVector> pathList = new ArrayList<>();
// Use Bresenham's algorithm to determine positions.
int x = startPosition.getX();
int y = startPosition.getY();
// Relative Distance (x & y-axis) between end- and starting position
int diffX = endPosition.getX() - startPosition.getX();
int diffY = endPosition.getY() - startPosition.getY();
// Absolute distance (x & y-axis) between end- and starting position
int distX = Math.abs(diffX);
int distY = Math.abs(diffY);
// Direction of vector on x & y axis (-1: to left/down, 0: none, +1 : to right/up)
int dirX = Integer.signum(diffX);
int dirY = Integer.signum(diffY);
// Determine which axis is the fast direction and set parallel/diagonal step values
int parallelStepX, parallelStepY;
int diagonalStepX, diagonalStepY;
int distanceSlowAxis, distanceFastAxis;
if (distX > distY) {
// x-axis is the 'fast' direction
parallelStepX = dirX;
parallelStepY = 0; // parallel step only moves in x direction
diagonalStepX = dirX;
diagonalStepY = dirY; // diagonal step moves in both directions
distanceSlowAxis = distY;
distanceFastAxis = distX;
} else {
// y-axis is the 'fast' direction
parallelStepX = 0;
parallelStepY = dirY; // parallel step only moves in y direction
diagonalStepX = dirX;
diagonalStepY = dirY; // diagonal step moves in both directions
distanceSlowAxis = distX;
distanceFastAxis = distY;
}
int error = distanceFastAxis / 2;
for (int step = 0; step < distanceFastAxis; step++) {
error -= distanceSlowAxis;
if (error < 0) {
error += distanceFastAxis; // correct error value to be positive again
// step into slow direction; diagonal step
x += diagonalStepX;
y += diagonalStepY;
} else {
// step into fast direction; parallel step
x += parallelStepX;
y += parallelStepY;
}
pathList.add(new PositionVector(x, y));
}
return pathList;
}
/**
* This method will check if a car is passing the finish line.
* If the car is passing the finish line in the wrong direction, the car will lose a winpoint.
* If the car is passing the finish line in the correct direction, the car will gain a winpoint.
*
* @param start the start position of the car
* @param finish the expected finish position of the car after the move
* @return Number of new winpoints for the current player.
*/
public int calculateNewWinPoints(PositionVector start, PositionVector finish) {
List<PositionVector> path = calculatePointsOnPath(start, finish);
for (PositionVector point : path) {
switch (getSpaceType(point)) {
case FINISH_UP:
if (start.getY() > finish.getY()) {
return 1;
} else if (start.getY() < finish.getY()) {
return -1;
}
break;
case FINISH_DOWN:
if (start.getY() < finish.getY()) {
return 1;
} else if (start.getY() > finish.getY()) {
return -1;
}
break;
case FINISH_RIGHT:
if (start.getX() < finish.getX()) {
return 1;
} else if (start.getX() > finish.getX()) {
return -1;
}
break;
case FINISH_LEFT:
if (start.getX() > finish.getX()) {
return 1;
} else if (start.getX() < finish.getX()) {
return -1;
}
break;
}
}
return 0;
} }
/** /**
@ -483,8 +163,7 @@ public class Track implements TrackSpecification {
*/ */
@Override @Override
public String toString() { public String toString() {
StringBuilder str = new StringBuilder(); // TODO: implementation
for (String line : track) str.append(line).append("\n"); throw new UnsupportedOperationException();
return str.toString();
} }
} }

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

@ -1,120 +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;
/**
* Class representing the Userinterface.
* Used to get inputs from users via text io.
*
* @author Roman Schenk
*/
public class UserInterface {
private final TextIO textIO;
private final TextTerminal<?> textTerminal;
/**
* Opens a new Terminal Window and prints the welcome Text.
*
* @param welcomeText The Text which will be printed after the windows is opened.
*/
public UserInterface(String welcomeText) {
textIO = TextIoFactory.getTextIO();
textTerminal = textIO.getTextTerminal();
textTerminal.println(welcomeText + "\n");
}
/**
* Prints the given Text in textTerminal
*
* @param text The Text which should be printed.
*/
public void printInformation(String text) {
textTerminal.println(text);
}
/**
* Method which asks the user to choose one of the options given.
*
* @param text Text which is printed before the options are printed. Example: "Select Track file:"
* @param options List with the options which can be selected.
* @return the list index of the selected option
*/
public int selectOption(String text, List<String> options) {
textTerminal.println(text + ":");
for (int option = 0; option < options.size(); option++) {
textTerminal.println(" " + (option + 1) + ": " + options.get(option));
}
return textIO.newIntInputReader().withMinVal(1).withMaxVal(options.size()).read("Enter your choice: ") - 1;
}
/**
* Gives information which player is at turn and asks for the direction to accelerate or quit the game.
*
* @param playingCarIndex the index of the player
* @param playingCarID the ID of the player
* @return the direction which is selected by the player. If null -> quit game
*/
public PositionVector.Direction selectDirection(int playingCarIndex, char playingCarID) {
PositionVector.Direction direction = null;
textTerminal.println("Playing Car " + playingCarIndex + ": " + playingCarID);
textTerminal.println("Directions are based on the number pad:");
textTerminal.println("7 8 9 7=up-left, 8=up, 9=up-right");
textTerminal.println("4 5 6 4=left, 5=no acceleration, 6=right");
textTerminal.println("1 2 3 1=down-left, 2=down, 3=down-right");
textTerminal.println("\n10 = quit \n");
while (direction == null) { //asks until a valid input in entered
int number = textIO.newIntInputReader().withMinVal(1).withMaxVal(10).read("choose your Acceleration direction: ");
if (number == 10) { //quit game
return null;
}
direction = getDirection(number);
}
return direction;
}
/**
* Method which returns the associated direction Object.
*
* @param number the number which was typed by the user
* @return the associated direction. If null -> unknown number
*/
private PositionVector.Direction getDirection(int number) {
return switch (number) {
case 1 -> PositionVector.Direction.DOWN_LEFT;
case 2 -> PositionVector.Direction.DOWN;
case 3 -> PositionVector.Direction.DOWN_RIGHT;
case 4 -> PositionVector.Direction.LEFT;
case 5 -> PositionVector.Direction.NONE;
case 6 -> PositionVector.Direction.RIGHT;
case 7 -> PositionVector.Direction.UP_LEFT;
case 8 -> PositionVector.Direction.UP;
case 9 -> PositionVector.Direction.UP_RIGHT;
default -> null;
};
}
/**
* Method to print the given Track in the terminal
*
* @param track the track which should be printed
*/
public void printTrack(Track track) {
textTerminal.println(track.toString());
}
/**
* Method to dispose of the Textterminal
*
* @param text Output Text
*/
public void quit(String text) {
textIO.newStringInputReader().withMinLength(0).read(text);
textTerminal.dispose();
}
}

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

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

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

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

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

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

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

@ -1,133 +1,15 @@
package ch.zhaw.pm2.racetrack.strategy; package ch.zhaw.pm2.racetrack.strategy;
import ch.zhaw.pm2.racetrack.InvalidFileFormatException;
import ch.zhaw.pm2.racetrack.PositionVector;
import ch.zhaw.pm2.racetrack.PositionVector.Direction; import ch.zhaw.pm2.racetrack.PositionVector.Direction;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Scanner;
/** /**
* The PathFollowerMoveStrategy class determines the next move based on a file containing points on a path. * The PathFollowerMoveStrategy class determines the next move based on a file containing points on a path.
*/ */
public class PathFollowerMoveStrategy implements MoveStrategy { public class PathFollowerMoveStrategy implements MoveStrategy {
/**
* The current Position of the car.
*/
private PositionVector currentPosition;
/**
* The current Velocity of the car.
*/
private PositionVector currentVelocity;
/**
* List of all points on the path.
*/
private final ArrayList<PositionVector> pointList;
/**
* The index of the next point on the path.
*/
private int pointer;
/**
* Constructor to create a new PathFollowerMoveStrategy for a car.
*
* @param trackFile The location where the file is saved
* @param startPosition The start position of the car
* @throws FileNotFoundException If the file with the given path does not exist.
*/
public PathFollowerMoveStrategy(File trackFile, PositionVector startPosition) throws FileNotFoundException, InvalidFileFormatException {
pointList = new ArrayList<>();
pointer = 0;
readFile(trackFile);
currentPosition = startPosition;
currentVelocity = new PositionVector(0, 0);
}
/**
* Method to read the given File and add the points to the pointList
*
* @param trackFile the File Object which should be read
* @throws FileNotFoundException If the file with the given path does not exist.
*/
public void readFile(File trackFile) throws FileNotFoundException, InvalidFileFormatException {
Scanner scanner = new Scanner(new FileInputStream(trackFile), StandardCharsets.UTF_8);
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
String[] coordinates = line.split("(\\(X:|, Y:|\\))");
try {
pointList.add(new PositionVector(Integer.parseInt(coordinates[1]), Integer.parseInt(coordinates[2])));
} catch (NumberFormatException e) {
throw new InvalidFileFormatException("Invalid File Format");
}
}
}
/**
* Method to select the direction for the next move.
*
* @return The direction for the next move. null if there are no points left in the list.
*/
@Override @Override
public Direction nextMove() { public Direction nextMove() {
// if no more points in the list --> return null // TODO: implementation
if (pointer >= pointList.size()) { throw new UnsupportedOperationException();
return null;
}
// increase pointer variable if the next point is reached.
if (pointList.get(pointer).equals(currentPosition)) {
pointer++;
}
// calculate Vector from current Position to next Point
PositionVector movementVector = new PositionVector(pointList.get(pointer).getX() - currentPosition.getX(), pointList.get(pointer).getY() - currentPosition.getY());
// select acceleration for X
int accelerationX;
if ((movementVector.getX() == 0 && currentVelocity.getX() > 0) || //reduce velocity to 0 if the destination coordinate is reached
(movementVector.getX() > 0 && movementVector.getX() / 2.0 <= currentVelocity.getX()) || //increase velocity
(movementVector.getX() < 0 && movementVector.getX() / 2.0 < currentVelocity.getX())) { //reduce velocity
accelerationX = -1;
} else if ((movementVector.getX() == 0 && currentVelocity.getX() < 0) || //reduce velocity to 0 if the destination coordinate is reached
(movementVector.getX() > 0 && movementVector.getX() / 2.0 > currentVelocity.getX()) || //increase velocity
(movementVector.getX() < 0 && movementVector.getX() / 2.0 >= currentVelocity.getX())) { //reduce velocity
accelerationX = 1;
} else { //no acceleration
accelerationX = 0;
}
// select acceleration for Y
int accelerationY;
if ((movementVector.getY() == 0 && currentVelocity.getY() > 0) || //reduce velocity to 0 if the destination coordinate is reached
(movementVector.getY() > 0 && movementVector.getY() / 2.0 <= currentVelocity.getY()) || //increase velocity
(movementVector.getY() < 0 && movementVector.getY() / 2.0 < currentVelocity.getY())) { //reduce velocity
accelerationY = -1;
} else if ((movementVector.getY() == 0 && currentVelocity.getY() < 0) || //reduce velocity to 0 if the destination coordinate is reached
(movementVector.getY() > 0 && movementVector.getY() / 2.0 > currentVelocity.getY()) || //increase velocity
(movementVector.getY() < 0 && movementVector.getY() / 2.0 >= currentVelocity.getY())) { //reduce velocity
accelerationY = 1;
} else { //no acceleration
accelerationY = 0;
}
//update current Velocity and current Position with the selected acceleration
currentVelocity = new PositionVector(currentVelocity.getX() + accelerationX, currentVelocity.getY() + accelerationY);
currentPosition = new PositionVector(currentPosition.getX() + currentVelocity.getX(), currentPosition.getY() + currentVelocity.getY());
//Find Direction for acceleration
PositionVector acceleration = new PositionVector(accelerationX, accelerationY);
Direction[] directions = Direction.values();
for (Direction direction : directions) {
if (direction.vector.equals(acceleration)) {
return direction;
}
}
return null;
} }
} }

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

@ -1,30 +1,15 @@
package ch.zhaw.pm2.racetrack.strategy; package ch.zhaw.pm2.racetrack.strategy;
import ch.zhaw.pm2.racetrack.PositionVector.Direction; import ch.zhaw.pm2.racetrack.PositionVector.Direction;
import ch.zhaw.pm2.racetrack.UserInterface;
/** /**
* Let the user decide the next move. * Let the user decide the next move.
* Therefore, it uses the UserInterface class to ask for a direction.
*/ */
public class UserMoveStrategy implements MoveStrategy { public class UserMoveStrategy implements MoveStrategy {
private final UserInterface userInterface;
private final int carIndex;
private final char carID;
public UserMoveStrategy(UserInterface userInterface, int carIndex, char carID) {
this.userInterface = userInterface;
this.carIndex = carIndex;
this.carID = carID;
}
/**
* Uses the interface to determine which move the user takes.
*
* @return the next taken move as Direction
*/
@Override @Override
public Direction nextMove() { public Direction nextMove() {
return userInterface.selectDirection(carIndex, carID); // TODO: implementation
throw new UnsupportedOperationException();
} }
} }

26
src/test/InvalidTracks/sameCar.txt
View File

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

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

@ -2,42 +2,35 @@
package ch.zhaw.pm2.racetrack; package ch.zhaw.pm2.racetrack;
import ch.zhaw.pm2.racetrack.strategy.*; import ch.zhaw.pm2.racetrack.strategy.*;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays;
import java.util.List; import java.util.List;
import static org.junit.jupiter.api.Assertions.*; import static org.junit.jupiter.api.Assertions.*;
/** /**
* Class that contains all test for the Class Car * Tests for Class Car
*
* @author Roman Schenk
*/ */
class CarTest { class CarTest {
Car car; Car car;
// Default coordinates for tests // Default coordinates for tests
final int DEFAULT_X = 10; int DEFAULT_X = 10;
final int DEFAULT_Y = 10; int DEFAULT_Y = 10;
final char DEFAULT_ID = 'f'; 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 @BeforeEach
void setUp() { void setUp() {
car = new Car(DEFAULT_ID, new PositionVector(DEFAULT_X, DEFAULT_Y)); car = new Car(DEFAULT_ID, new PositionVector(DEFAULT_X, DEFAULT_Y));
} }
/**
* Checks if the method getID returns the correct value
*/
@Test @Test
void getID() { void getID() {
assertEquals(DEFAULT_ID, car.getID()); assertEquals(DEFAULT_ID, car.getID());
@ -54,8 +47,8 @@ class CarTest {
} }
/** /**
* Checks if the position of the car can be set and saved correctly with valid positions. * - 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 an exception is throwed and position keeps unchanged if invalid coordinates are entered.
*/ */
@Test @Test
void setPosition() { void setPosition() {
@ -81,7 +74,6 @@ class CarTest {
for (PositionVector positionVector : invalidPositions) { for (PositionVector positionVector : invalidPositions) {
boolean exception = false; boolean exception = false;
setUp();
try { try {
car.setPosition(positionVector); car.setPosition(positionVector);
} catch (IllegalArgumentException e) { } catch (IllegalArgumentException e) {
@ -106,42 +98,40 @@ class CarTest {
@Test @Test
void movement() { void movement() {
// add all possible directions in a List // add all possible directions in a List
PositionVector.Direction[] directions = PositionVector.Direction.values(); List<PositionVector.Direction> directions = Arrays.asList(PositionVector.Direction.values());
//position shouldn't be changed because velocity should be 0. //position shouldn't be changed because velocity should be 0.
car.move(); car.move();
checkNextPosition(DEFAULT_X, DEFAULT_Y); checkNextPosition(DEFAULT_X, DEFAULT_Y);
for (PositionVector.Direction direction1 : directions) { for (PositionVector.Direction direction1 : directions) {
//create a new instance of Car with default coordinates and velocity 0.
setUp();
//variables to save the actual expected result of method nextPosition
int expectedNextPosX = DEFAULT_X;
int expectedNextPosY = DEFAULT_Y;
//variables to save the acutal expected result of method getVelocity
int expectedVelocityX = 0;
int expectedVelocityY = 0;
car.accelerate(direction1);
expectedVelocityX += direction1.vector.getX();
expectedVelocityY += direction1.vector.getY();
expectedNextPosX += direction1.vector.getX();
expectedNextPosY += direction1.vector.getY();
checkVelocity(expectedVelocityX, expectedVelocityY);
checkNextPosition(expectedNextPosX, expectedNextPosY);
car.move();
expectedNextPosX += direction1.vector.getX();
expectedNextPosY += direction1.vector.getY();
checkVelocity(expectedVelocityX, expectedVelocityY);
checkNextPosition(expectedNextPosX, expectedNextPosY);
for (PositionVector.Direction direction2 : directions) { for (PositionVector.Direction direction2 : directions) {
//create a new instance of Car with default coordinates and velocity 0.
setUp();
//variables to save the actual expected result of method nextPosition
int expectedNextPosX = DEFAULT_X;
int expectedNextPosY = DEFAULT_Y;
//variables to save the actual expected result of method getVelocity
int expectedVelocityX = 0;
int expectedVelocityY = 0;
car.accelerate(direction1);
expectedVelocityX += direction1.vector.getX();
expectedVelocityY += direction1.vector.getY();
expectedNextPosX += direction1.vector.getX();
expectedNextPosY += direction1.vector.getY();
checkVelocity(expectedVelocityX, expectedVelocityY);
checkNextPosition(expectedNextPosX, expectedNextPosY);
car.move();
expectedNextPosX += direction1.vector.getX();
expectedNextPosY += direction1.vector.getY();
checkVelocity(expectedVelocityX, expectedVelocityY);
checkNextPosition(expectedNextPosX, expectedNextPosY);
car.accelerate(direction2); car.accelerate(direction2);
expectedVelocityX += direction2.vector.getX(); expectedVelocityX += direction2.vector.getX();
expectedVelocityY += direction2.vector.getY(); expectedVelocityY += direction2.vector.getY();
@ -161,8 +151,7 @@ class CarTest {
/** /**
* Test for methods crash and isCrashed. * test for methods crash and isCrashed. checks if state crashed is set and returned correctly.
* Checks if state crashed is set and returned correctly.
*/ */
@Test @Test
void crash() { void crash() {
@ -172,8 +161,8 @@ class CarTest {
} }
/** /**
* Test for methods setMoveStrategy. * test for methods setMoveStrategy. Checks if the MoveStrategy Object is saved and returned correctly
* Checks if the MoveStrategy Object is saved and returned correctly with all Types of MoveStrategy. * with all Types of MoveStrategy.
*/ */
@Test @Test
void MoveStrategy() { void MoveStrategy() {
@ -183,51 +172,16 @@ class CarTest {
car.setMoveStrategy(moveStrategy); car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy()); assertEquals(moveStrategy, car.getMoveStrategy());
try { moveStrategy = new MoveListStrategy();
moveStrategy = new MoveListStrategy(new File(".\\moves\\challenge-car-a.txt"));
} catch (FileNotFoundException | InvalidFileFormatException e) {
Assertions.fail();
}
car.setMoveStrategy(moveStrategy); car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy()); assertEquals(moveStrategy, car.getMoveStrategy());
try { moveStrategy = new PathFollowerMoveStrategy();
moveStrategy = new PathFollowerMoveStrategy(new File(".\\follower\\challenge_points.txt"), new PositionVector(0, 0));
} catch (FileNotFoundException | InvalidFileFormatException e) {
e.printStackTrace();
}
car.setMoveStrategy(moveStrategy); car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy()); assertEquals(moveStrategy, car.getMoveStrategy());
moveStrategy = new UserMoveStrategy(new UserInterface("Hello"), 0, 'a'); moveStrategy = new UserMoveStrategy();
car.setMoveStrategy(moveStrategy); car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy()); assertEquals(moveStrategy, car.getMoveStrategy());
} }
/**
* Tests if getWinPoints returns the correct value.
*/
@Test
void getWinPoints() {
assertEquals(0, car.getWinPoints());
}
/**
* Tests if winpoints increase functions properly.
*/
@Test
void increaseWinPoints() {
car.increaseWinPoints();
assertEquals(1, car.getWinPoints());
}
/**
* Tests if the deductions of winpoints functions properly.
*/
@Test
void deductWinPoints() {
car.deductWinPoints();
assertEquals(-1, car.getWinPoints());
}
} }

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

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

52
src/test/java/ch/zhaw/pm2/racetrack/MoveListStrategyTest.java
View File

@ -1,52 +0,0 @@
package ch.zhaw.pm2.racetrack;
import ch.zhaw.pm2.racetrack.strategy.MoveListStrategy;
import ch.zhaw.pm2.racetrack.strategy.MoveStrategy;
import org.junit.jupiter.api.*;
import java.io.File;
import java.io.FileNotFoundException;
/**
* This Class tests the MoveStrategy.
*
* @author Andrin Fassbind
*/
public class MoveListStrategyTest {
private MoveStrategy moveList;
@Nested
@DisplayName("MoveListStrategy")
class MoveList {
/**
* Creates a new MoveListStrategy
*/
@BeforeEach
void setup() {
try {
moveList = new MoveListStrategy(new File(".\\moves\\challenge-car-a.txt"));
}catch (FileNotFoundException | InvalidFileFormatException e) {
e.printStackTrace();
}
}
/**
* Checks if the directions are returned correct by method nextMove
*/
@Test
void checkMove() {
Assertions.assertEquals(PositionVector.Direction.RIGHT,moveList.nextMove());
for (int i = 0; i < 3; i++) {
moveList.nextMove();
}
Assertions.assertEquals(PositionVector.Direction.NONE,moveList.nextMove());
for (int i = 0; i < 40; i++) {
moveList.nextMove();
}
Assertions.assertNull(moveList.nextMove());
}
}
}

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

@ -1,204 +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;
/**
* This Class tests the track
*
* @author Andrin Fassbind
*/
public class TrackTest {
Track trackObj;
@Nested
@DisplayName("Positive Test Cases")
class positiveClass {
/**
* Sets up the Test cases by loading the file and setting a new track.
*/
@BeforeEach
void setup() {
File file = new File(".\\tracks\\challenge.txt");
try {
trackObj = new Track(file);
} catch (FileNotFoundException | InvalidTrackFormatException e) {
e.printStackTrace();
Assertions.fail();
}
}
/**
* Checks if correct amount of cars has been instantiated
*/
@Test
@DisplayName("Create correct amount of Car instance")
void checkCars() {
Assertions.assertEquals(2, trackObj.getCarCount());
}
/**
* Checks if car id matches track file symbol
*/
@Test
@DisplayName("Create Car instance with correct Symbols / Id")
void checkCarId() {
Assertions.assertEquals('a', trackObj.getCarId(0));
Assertions.assertEquals('b', trackObj.getCarId(1));
}
/**
* checks if track reads space typ from track file correctly
*/
@Test
@DisplayName("Check getSpaceTyp")
void getSpaceTyp() {
Assertions.assertEquals(ConfigSpecification.SpaceType.FINISH_RIGHT, trackObj.getSpaceType(new PositionVector(22, 24)));
}
/**
* checks if track finds the finish line at the correct positions
*/
@Test
@DisplayName("Find FinishLine")
void findFinish() {
List<PositionVector> expected = new ArrayList<>();
expected.add(new PositionVector(22, 22));
expected.add(new PositionVector(22, 23));
expected.add(new PositionVector(22, 24));
Assertions.assertEquals(expected, trackObj.getFinishLine());
}
/**
* Checks if track does read in track file correctly
*/
@Test
@DisplayName("Converts track file correctly to List<String>")
void checkTrack() {
Track trackObj;
try {
trackObj = new Track(new File(".\\tracks\\oval-anticlock-right.txt"));
List<String> track = new ArrayList<>();
track.add("##################################################");
track.add("##################################################");
track.add("############## #############");
track.add("########## ##########");
track.add("####### #######");
track.add("###### ################# ######");
track.add("##### ################### #####");
track.add("##### ################### #####");
track.add("###### ################# ######");
track.add("####### > a #######");
track.add("########## > ##########");
track.add("############## > b ##############");
track.add("##################################################");
track.add("##################################################");
Assertions.assertLinesMatch(track, trackObj.getTrack());
} catch (FileNotFoundException | InvalidTrackFormatException e) {
e.printStackTrace();
}
}
/**
* checks if track does process car move correctly
*/
@Test
@DisplayName("Make Car move down on track")
void makeCarMoveDown() {
PositionVector beforeMove = trackObj.getCarPos(0);
trackObj.getCar(0).accelerate(PositionVector.Direction.DOWN);
trackObj.moveCar(0);
PositionVector afterMove = trackObj.getCarPos(0);
Assertions.assertEquals(beforeMove.getY() + 1, afterMove.getY());
Assertions.assertEquals(beforeMove.getX(), afterMove.getX());
}
/**
* Checks if car does not move if there is no acceleration
*/
@Test
@DisplayName("Make Car move with (0,0) acceleration on track")
void makeCarStay() {
PositionVector beforeMove = trackObj.getCarPos(0);
trackObj.moveCar(0);
PositionVector afterMove = trackObj.getCarPos(0);
Assertions.assertEquals(beforeMove.getY(), afterMove.getY());
Assertions.assertEquals(beforeMove.getX(), afterMove.getX());
}
/**
* Checks if car does crash
*/
@Test
@DisplayName("Will Car Crash")
void willCarCrash() {
//Car will Crash
Assertions.assertTrue(trackObj.willCrashAtPosition(0, new PositionVector(25, 21)));
//Car will not Crash and is on track
Assertions.assertFalse(trackObj.willCrashAtPosition(0, new PositionVector(7, 22)));
//Car will not Crash and is on finishLine
Assertions.assertFalse(trackObj.willCrashAtPosition(0, trackObj.getFinishLine().get(0)));
}
/**
* checks if track is updated after car crash
*/
@Test
@DisplayName("Make Car Crash")
void makeCarCrash() {
trackObj.carDoesCrash(0, new PositionVector(6, 22));
Assertions.assertEquals(Track.CRASH_INDICATOR, trackObj.getTrack().get(22).charAt(6));
Assertions.assertTrue(trackObj.getCar(0).isCrashed());
}
}
/**
* This testcase does check for negative test cases
*/
@Nested
@DisplayName("Negative TestCase")
class negativeClass {
File file;
/**
* Sets up the negative Test cases by loading the file and setting a new track.
*/
@BeforeEach
void setup() {
file = new File(".\\tracks\\challenge.txt");
try {
trackObj = new Track(file);
} catch (InvalidTrackFormatException | FileNotFoundException e) {
System.err.println("Error in Test compareTrack" + e.getMessage());
}
}
/**
* Tries to read not valid file
*/
@Test
@DisplayName("Throw error if File not found")
void canReadFile() {
file = new File(".\\tracks\\NotExisting.txt");
Assertions.assertThrows(FileNotFoundException.class, () -> new Track(file));
}
/**
* Tries to read not valid file with 2 cars with same symbol
*/
@Test
@DisplayName("Throw error if File is invalid")
void invalidTrackFile() {
File testFile = new File(".\\src\\test\\InvalidTracks\\sameCar.txt");
Assertions.assertThrows(InvalidTrackFormatException.class, () -> new Track(testFile));
}
}
}

1
tracks/.gitignore vendored Normal file
View File

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