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

Merge branch 'main' into Strategy

Browse Source
This commit is contained in:
romanschenk37
2022-03-24 13:41:42 +01:00
parent cf1a8d703e 4ce26578b9
commit a689df5fe1
13 changed files with 773 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/ch/zhaw/pm2/racetrack/Game.java
+63 -86
View File
@@ -18,7 +18,7 @@ import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
public class Game implements GameSpecification {
public static final int NO_WINNER = -1;
private Track track;
int currentCarIndex;
private int currentCarIndex;
UserInterface userInterface;
@@ -27,7 +27,7 @@ public class Game implements GameSpecification {
}
public boolean initPhase() throws InvalidTrackFormatException, FileNotFoundException {
public boolean initPhase() throws InvalidTrackFormatException {
File folder = new File("tracks");
File[] listOfFiles = folder.listFiles();
if (listOfFiles.length > 0) {
@@ -36,42 +36,46 @@ public class Game implements GameSpecification {
tracks.add(file.getName());
}
File selectedTrack = listOfFiles[userInterface.selectOption("Select Track file", tracks)];
try {
track = new Track(selectedTrack);
} catch (FileNotFoundException | PositionVectorNotValid e) {
e.printStackTrace();
}
selectTrack(selectedTrack);
List<String> moveStrategies = new ArrayList<>();
moveStrategies.add("Do not move Strategy");
moveStrategies.add("User Move Strategy");
moveStrategies.add("Move List Strategy");
moveStrategies.add("Path Follow Move Strategy");
for (int i = 0; i < track.getCarCount(); i++) {
while(track.getCar(i).getMoveStrategy() == null) {
Car car = track.getCar(i);
MoveStrategy moveStrategy = null;
while (moveStrategy == null) {
String filePath;
int moveStrategie = userInterface.selectOption(
"Select Strategy for Car " + i + " (" + track.getCarId(i) + ")", moveStrategies);
switch (moveStrategie + 1) {
case 1:
track.getCar(i).setMoveStrategy(new DoNotMoveStrategy());
moveStrategy = new DoNotMoveStrategy();
break;
case 2:
track.getCar(i).setMoveStrategy(new UserMoveStrategy(userInterface, i, track.getCarId(i)));
moveStrategy = new UserMoveStrategy(userInterface, i, track.getCarId(i));
break;
case 3:
String path = ".\\moves\\" + selectedTrack.getName().split("\\.")[0] + "-car-" + track.getCar(i).getID() + ".txt";
filePath = ".\\moves\\" + selectedTrack.getName().split("\\.")[0] + "-car-" + track.getCar(i).getID() + ".txt";
try {
MoveStrategy moveStrategy = new MoveListStrategy(path);
track.getCar(i).setMoveStrategy(moveStrategy);
moveStrategy = new MoveListStrategy(filePath);
} catch (FileNotFoundException e) {
userInterface.printInformation("There is no MoveList implemented. Choose another Strategy!");
userInterface.printInformation("There is no Move-List implemented. Choose another Strategy!");
}
//TODO: Backslash kompatibel für Linux
break;
case 4:
track.getCar(i).setMoveStrategy(new PathFollowerMoveStrategy()); //TODO: add Arguments
filePath = ".\\follower\\" + selectedTrack.getName().split("\\.")[0] + "_points.txt";
try {
moveStrategy = new PathFollowerMoveStrategy(filePath, track.getCarPos(i));
} catch (FileNotFoundException e) {
userInterface.printInformation("There is no Point-List implemented. Choose another Strategy!");
}
break;
}
}
selectMoveStrategy(car, moveStrategy);
}
return true;
} else {
@@ -80,6 +84,31 @@ public class Game implements GameSpecification {
}
}
/**
* The functionality was taken out of init to automate testing
*
* @param selectedTrack
*/
Track selectTrack(File selectedTrack) {
try {
track = new Track(selectedTrack);
return track;
} catch (FileNotFoundException | PositionVectorNotValid | InvalidTrackFormatException e) {
e.printStackTrace();
}
return null;
}
/**
* The functionality was taken out of init to automate testing
*
* @param car to set the MoveStrategy
* @param strategy The movestrategy to set
*/
void selectMoveStrategy(Car car, MoveStrategy strategy) {
car.setMoveStrategy(strategy);
}
/**
* Return the index of the current active car.
* Car indexes are zero-based, so the first car is 0, and the last car is getCarCount() - 1.
@@ -115,6 +144,7 @@ public class Game implements GameSpecification {
/**
* Get the velocity of the specified car.
*
* @param carIndex The zero-based carIndex number
* @return A PositionVector containing the car's current velocity
*/
@@ -192,20 +222,20 @@ public class Game implements GameSpecification {
}
public String gamePhase() throws PositionVectorNotValid {
while (CarsMoving() && getWinner() == NO_WINNER) {
while (carsMoving() && getWinner() == NO_WINNER) {
userInterface.printTrack(track);
Direction direction = null;
direction= track.getCar(currentCarIndex).getMoveStrategy().nextMove();
if(direction == null) {
Direction direction;
direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
if (direction == null) {
track.getCar(currentCarIndex).setMoveStrategy(new DoNotMoveStrategy());
direction= track.getCar(currentCarIndex).getMoveStrategy().nextMove();
direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
}
doCarTurn(direction);
switchToNextActiveCar();
}
userInterface.printTrack(track);
int indexWinner = getWinner();
if(indexWinner == NO_WINNER){
if (indexWinner == NO_WINNER) {
return null;
}
return String.valueOf(track.getCar(indexWinner).getID());
@@ -241,69 +271,15 @@ public class Game implements GameSpecification {
*/
@Override
public List<PositionVector> calculatePath(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;
return track.calculatePointsOnPath(startPosition, endPosition);
}
private void calculateWinner(PositionVector start, PositionVector finish, int carIndex) {
List<PositionVector> path = calculatePath(start, finish);
for (PositionVector point : path) {
if (track.getSpaceType(point) != null)
{
if (track.getSpaceType(point) != null) {
switch (track.getSpaceType(point)) {
case FINISH_UP:
if (start.getY() < finish.getY()) {
@@ -333,15 +309,16 @@ public class Game implements GameSpecification {
track.getCar(carIndex).increaseWinPoints();
}
break;
}
}
}
}
}
/**
* Does indicate if a car would have a crash with a WALL space or another car at the given position.
*
* @param carIndex The zero-based carIndex number
* @param position A PositionVector of the possible crash position
* @return A boolean indicator if the car would crash with a WALL or another car.
@@ -353,17 +330,17 @@ public class Game implements GameSpecification {
public boolean onlyOneCarLeft() {
int carsLeft = 0;
for(int carIndex = 0; carIndex < track.getCarCount(); carIndex ++) {
if(! track.getCar(carIndex).isCrashed()) {
for (int carIndex = 0; carIndex < track.getCarCount(); carIndex++) {
if (!track.getCar(carIndex).isCrashed()) {
carsLeft++;
}
}
return !(carsLeft > 1);
}
public boolean CarsMoving() {
for(int carIndex = 0; carIndex < track.getCarCount(); carIndex ++) {
if(! (track.getCar(carIndex).isCrashed() || track.getCar(carIndex).getMoveStrategy().getClass() == DoNotMoveStrategy.class)) {
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;
}
}
src/main/java/ch/zhaw/pm2/racetrack/InvalidFileFormatException.java
+6 -1
View File
@@ -1,5 +1,10 @@
package ch.zhaw.pm2.racetrack;
/**
* Class for Exception when invalid Fileformat is used.
*/
public class InvalidFileFormatException extends Exception {
// TODO: implementation
public InvalidFileFormatException(String errorMessage) {
super(errorMessage);
}
}
src/main/java/ch/zhaw/pm2/racetrack/InvalidTrackFormatException.java
+9 -1
View File
@@ -1,5 +1,13 @@
package ch.zhaw.pm2.racetrack;
/**
* Class for Exception when invalid track format is used.
*/
public class InvalidTrackFormatException extends Exception {
// TODO: implementation
public InvalidTrackFormatException(String errorMessage) {
super(errorMessage);
}
public InvalidTrackFormatException() {
super();
}
}
src/main/java/ch/zhaw/pm2/racetrack/Main.java
+1 -1
View File
@@ -6,7 +6,7 @@ import java.util.List;
public class Main {
public static void main(String[] args) throws InvalidTrackFormatException, FileNotFoundException, PositionVectorNotValid {
public static void main(String[] args) throws InvalidTrackFormatException, PositionVectorNotValid {
UserInterface userInterface = new UserInterface("Hello and Welcome to Racetrack by Team02-\"AngryNerds\"");
while (true) {
Game game = new Game(userInterface);
src/main/java/ch/zhaw/pm2/racetrack/Track.java
+59
View File
@@ -355,6 +355,65 @@ public class Track implements TrackSpecification {
return currentSpace.getValue();
}
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;
}
/**
* Return a String representation of the track, including the car locations.
*
src/main/java/ch/zhaw/pm2/racetrack/strategy/MoveListStrategy.java
+3 -3
View File
@@ -25,9 +25,9 @@ public class MoveListStrategy implements MoveStrategy {
Direction[] directions = Direction.values();
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
for (Direction dir : directions) {
if (dir.toString().equals(line)) {
moveList.add(dir);
for (Direction direction : directions) {
if (direction.toString().equals(line)) {
moveList.add(direction);
break;
}
}
src/main/java/ch/zhaw/pm2/racetrack/strategy/PathFollowerMoveStrategy.java
+113 -2
View File
@@ -1,15 +1,126 @@
package ch.zhaw.pm2.racetrack.strategy;
import ch.zhaw.pm2.racetrack.PositionVector;
import ch.zhaw.pm2.racetrack.PositionVector.Direction;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;
/**
* The PathFollowerMoveStrategy class determines the next move based on a file containing points on a path.
*/
public class PathFollowerMoveStrategy implements MoveStrategy {
/**
* The current Position of the car.
*/
private PositionVector currentPosition;
/**
* The current Velocity of the car.
*/
private PositionVector currentVelocity;
/**
* List of all points on the path.
*/
private 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 path The location where the file is saved
* @param startPosition The start position of the car
* @throws FileNotFoundException If the file with the given path does not exist.
*/
public PathFollowerMoveStrategy(String path, PositionVector startPosition) throws FileNotFoundException {
pointList = new ArrayList<>();
pointer = 0;
readFile(new File(path));
currentPosition = startPosition;
currentVelocity = new PositionVector(0, 0);
}
/**
* Method to read the given File and add the points to the pointList
* @param trackFile the File Object which should be read
* @throws FileNotFoundException If the file with the given path does not exist.
*/
public void readFile(File trackFile) throws FileNotFoundException {
Scanner scanner = new Scanner(new FileInputStream(trackFile), "UTF-8");
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
String[] coordinates = line.split("(\\(X:|, Y:|\\))");
pointList.add(new PositionVector(Integer.parseInt(coordinates[1]), Integer.parseInt(coordinates[2])));
}
}
/**
* Method to select the direction for the next move.
* @return The direction for the next move. null if there are no points left in the list.
*/
@Override
public Direction nextMove() {
// TODO: implementation
throw new UnsupportedOperationException();
// if no more points in the list --> return null
if (pointer >= pointList.size()) {
return null;
}
// increase pointer variable if the next point is reached.
if (pointList.get(pointer).equals(currentPosition)) {
pointer ++;
}
// calculate Vector from current Position to next Point
PositionVector movementVector = new PositionVector(pointList.get(pointer).getX() - currentPosition.getX(), pointList.get(pointer).getY() - currentPosition.getY());
// select acceleration for X
int accelerationX;
if((movementVector.getX() == 0 && currentVelocity.getX() > 0) || //reduce velocity to 0 if the destination coordinate is reached
(movementVector.getX() > 0 && movementVector.getX()/2.0 <= currentVelocity.getX()) || //increase velocity
(movementVector.getX() < 0 && movementVector.getX()/2.0 < currentVelocity.getX())){ //reduce velocity
accelerationX = -1;
} else if((movementVector.getX() == 0 && currentVelocity.getX() < 0) || //reduce velocity to 0 if the destination coordinate is reached
(movementVector.getX() > 0 && movementVector.getX()/2.0 > currentVelocity.getX()) || //increase velocity
(movementVector.getX() < 0 && movementVector.getX()/2.0 >= currentVelocity.getX())) { //reduce velocity
accelerationX = 1;
}
else { //no acceleration
accelerationX = 0;
}
// select acceleration for Y
int accelerationY;
if((movementVector.getY() == 0 && currentVelocity.getY() > 0) || //reduce velocity to 0 if the destination coordinate is reached
(movementVector.getY() > 0 && movementVector.getY()/2.0 <= currentVelocity.getY()) || //increase velocity
(movementVector.getY() < 0 && movementVector.getY()/2.0 < currentVelocity.getY())){ //reduce velocity
accelerationY = -1;
} else if((movementVector.getY() == 0 && currentVelocity.getY() < 0) || //reduce velocity to 0 if the destination coordinate is reached
(movementVector.getY() > 0 && movementVector.getY()/2.0 > currentVelocity.getY()) || //increase velocity
(movementVector.getY() < 0 && movementVector.getY()/2.0 >= currentVelocity.getY())) { //reduce velocity
accelerationY = 1;
}
else { //no acceleration
accelerationY = 0;
}
//update current Velocity and current Position with the selected acceleration
currentVelocity = new PositionVector(currentVelocity.getX() + accelerationX, currentVelocity.getY() + accelerationY);
currentPosition = new PositionVector(currentPosition.getX() + currentVelocity.getX(), currentPosition.getY() + currentVelocity.getY());
//Find Direction for acceleration
PositionVector acceleration = new PositionVector(accelerationX, accelerationY);
Direction[] directions = Direction.values();
for (Direction direction : directions) {
if (direction.vector.equals(acceleration)) {
return direction;
}
}
return null;
}
}
src/test/java/ch/zhaw/pm2/racetrack/CarTest.java
+228
View File
@@ -0,0 +1,228 @@
package ch.zhaw.pm2.racetrack;
import ch.zhaw.pm2.racetrack.strategy.*;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
/**
* Tests for Class Car
*/
class CarTest {
Car car;
// Default coordinates for tests
int DEFAULT_X = 10;
int DEFAULT_Y = 10;
char DEFAULT_ID = 'f';
/**
* Create a new Car Object and set Position to a defined Default Position
*/
@BeforeEach
void setUp() {
car = new Car(DEFAULT_ID, new PositionVector(DEFAULT_X, DEFAULT_Y));
}
@Test
void getID() {
assertEquals(DEFAULT_ID, car.getID());
}
/**
* Method to check nextPosition with coordinates as int
*
* @param x the expected value for x coordinate
* @param y the expected value for y coordinate
*/
void checkNextPosition(int x, int y) {
assertEquals(new PositionVector(x, y), car.nextPosition());
}
/**
* - checks if the position of the car can be set and saved correctly with valid positions.
* - checks if an exception is throwed and position keeps unchanged if invalid coordinates are entered.
*/
@Test
void setPosition() {
checkNextPosition(DEFAULT_X, DEFAULT_Y);
// List of valid Positions
List<PositionVector> validPositions = new ArrayList<>();
validPositions.add(new PositionVector(20, 20));
validPositions.add(new PositionVector(0, 0));
validPositions.add(new PositionVector(20, 0));
validPositions.add(new PositionVector(0, 20));
for (PositionVector positionVector : validPositions) {
car.setPosition(positionVector);
assertEquals(positionVector, car.nextPosition());
}
// List of invalid positions.
List<PositionVector> invalidPositions = new ArrayList<>();
invalidPositions.add(new PositionVector(0, -20));
invalidPositions.add(new PositionVector(-20, 0));
invalidPositions.add(new PositionVector(-20, -20));
for (PositionVector positionVector : invalidPositions) {
boolean exception = false;
setUp();
try {
car.setPosition(positionVector);
} catch (IllegalArgumentException e) {
exception = true;
}
assertTrue(exception);
// position should keep unchanged
checkNextPosition(DEFAULT_X, DEFAULT_Y);
}
}
void checkVelocity(int x, int y) {
assertEquals(new PositionVector(x, y), car.getVelocity());
}
/**
* Checks if the methods accelerate, move and getVelocity are working correctly with acceleration in all directions.
* Checks also if velocity is calculated correctly if method accelerate is called a second time.
*/
@Test
void movement() {
// add all possible directions in a List
List<PositionVector.Direction> directions = Arrays.asList(PositionVector.Direction.values());
//position shouldn't be changed because velocity should be 0.
car.move();
checkNextPosition(DEFAULT_X, DEFAULT_Y);
for (PositionVector.Direction direction1 : directions) {
for (PositionVector.Direction direction2 : directions) {
//create a new instance of Car with default coordinates and velocity 0.
setUp();
//variables to save the actual expected result of method nextPosition
int expectedNextPosX = DEFAULT_X;
int expectedNextPosY = DEFAULT_Y;
//variables to save the acutal expected result of method getVelocity
int expectedVelocityX = 0;
int expectedVelocityY = 0;
car.accelerate(direction1);
expectedVelocityX += direction1.vector.getX();
expectedVelocityY += direction1.vector.getY();
expectedNextPosX += direction1.vector.getX();
expectedNextPosY += direction1.vector.getY();
checkVelocity(expectedVelocityX, expectedVelocityY);
checkNextPosition(expectedNextPosX, expectedNextPosY);
car.move();
expectedNextPosX += direction1.vector.getX();
expectedNextPosY += direction1.vector.getY();
checkVelocity(expectedVelocityX, expectedVelocityY);
checkNextPosition(expectedNextPosX, expectedNextPosY);
car.accelerate(direction2);
expectedVelocityX += direction2.vector.getX();
expectedVelocityY += direction2.vector.getY();
expectedNextPosX += direction2.vector.getX();
expectedNextPosY += direction2.vector.getY();
checkVelocity(expectedVelocityX, expectedVelocityY);
checkNextPosition(expectedNextPosX, expectedNextPosY);
car.move();
checkVelocity(expectedVelocityX, expectedVelocityY);
expectedNextPosX += (direction1.vector.getX() + direction2.vector.getX());
expectedNextPosY += (direction1.vector.getY() + direction2.vector.getY());
checkNextPosition(expectedNextPosX, expectedNextPosY);
}
}
}
/**
* test for methods crash and isCrashed. checks if state crashed is set and returned correctly.
*/
@Test
void crash() {
assertFalse(car.isCrashed());
car.crash();
assertTrue(car.isCrashed());
}
/**
* test for methods setMoveStrategy. Checks if the MoveStrategy Object is saved and returned correctly
* with all Types of MoveStrategy.
*/
@Test
void MoveStrategy() {
MoveStrategy moveStrategy;
moveStrategy = new DoNotMoveStrategy();
car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy());
try {
moveStrategy = new MoveListStrategy(".\\moves\\challenge-car-a.txt");
} catch (FileNotFoundException e) {
Assertions.fail();
}
car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy());
try {
moveStrategy = new PathFollowerMoveStrategy(".\\follower\\challenge_points.txt", new PositionVector(0, 0));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy());
moveStrategy = new UserMoveStrategy(new UserInterface("Hello"),0,'a');
car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy());
}
/**
* Test for get WinPoints
*/
@Test
void getWinPoints() {
assertEquals(0,car.getWinPoints());
}
/**
* Test for increase WinPoints
*/
@Test
void increaseWinPoints() {
car.increaseWinPoints();
assertEquals(1,car.getWinPoints());
}
/**
* Test for deduct WinPoints
*/
@Test
void deductWinPoints() {
car.deductWinPoints();
assertEquals(-1,car.getWinPoints());
}
}
src/test/java/ch/zhaw/pm2/racetrack/GameTest.java
+233
View File
@@ -0,0 +1,233 @@
package ch.zhaw.pm2.racetrack;
import ch.zhaw.pm2.racetrack.strategy.UserMoveStrategy;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Assertions;
import java.io.File;
import java.util.List;
import static ch.zhaw.pm2.racetrack.Game.NO_WINNER;
import static ch.zhaw.pm2.racetrack.PositionVector.Direction.*;
/**
* Test for Class Game
*/
class GameTest {
private UserInterface userInterface;
private Game game;
private Track track;
private String TRACK_FILE_PATH = ".\\tracks\\challenge.txt";
private int CAR_INDEX_ONE = 0;
private int CAR_INDEX_TWO = 1;
/**
* This nested Class tests if the game gets initiatet correctly
*/
@Nested
@DisplayName("Test correct Setup")
class Setup {
@BeforeEach
void setup() {
userInterface = new UserInterface("Test");
game = new Game(userInterface);
track = game.selectTrack(new File(TRACK_FILE_PATH));
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)));
}
@Test
void getCurrentCarIndex() {
Assertions.assertEquals(CAR_INDEX_ONE, game.getCurrentCarIndex());
game.switchToNextActiveCar();
Assertions.assertEquals(CAR_INDEX_TWO, game.getCurrentCarIndex());
}
@Test
void getCarId() {
Assertions.assertEquals('a', game.getCarId(0));
Assertions.assertEquals('b', game.getCarId(1));
}
@Test
void getCarPosition() {
Assertions.assertEquals(new PositionVector(24, 22), game.getCarPosition(0));
Assertions.assertEquals(new PositionVector(24, 24), game.getCarPosition(1));
}
@Test
void getCarVelocity() {
Assertions.assertEquals(new PositionVector(0, 0), game.getCarVelocity(0));
Assertions.assertEquals(new PositionVector(0, 0), game.getCarVelocity(1));
}
@Test
void getWinner() {
Assertions.assertEquals(NO_WINNER, game.getWinner());
}
@Test
void onlyOneCarLeft() {
Assertions.assertFalse(game.onlyOneCarLeft());
}
@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");
game = new Game(userInterface);
track = game.selectTrack(new File(TRACK_FILE_PATH));
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)));
}
@Test
void carTurnCorrect() {
try {
game.doCarTurn(RIGHT);
Assertions.assertEquals(new PositionVector(1, 0), game.getCarVelocity(0));
} catch (PositionVectorNotValid positionVectorNotValid) {
positionVectorNotValid.printStackTrace();
}
}
@Test
void carCrash() {
try {
game.doCarTurn(PositionVector.Direction.UP);
Assertions.assertTrue(game.onlyOneCarLeft());
} catch (PositionVectorNotValid positionVectorNotValid) {
positionVectorNotValid.printStackTrace();
}
}
}
/**
* This nested Class tests a Playtrough. And implements a UserInterface interagtion to pretend a real player
*/
@Nested
@DisplayName("Playtrough")
class Play {
private Game game;
@Test
void winner() {
game = new Game(new interFace("Test",new Integer[]{0,2,1},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}));
try {
game.initPhase();
Assertions.assertEquals("a",game.gamePhase());
} catch (InvalidTrackFormatException | PositionVectorNotValid e) {
e.printStackTrace();
}
}
@Test
void crashA() {
game = new Game(new interFace("Test",new Integer[]{0,2,2},new PositionVector.Direction[]{UP}));
try {
game.initPhase();
Assertions.assertEquals("b",game.gamePhase());
} catch (InvalidTrackFormatException | PositionVectorNotValid e) {
e.printStackTrace();
}
}
}
private class interFace extends UserInterface {
private final PositionVector.Direction[] directions;
private final Integer[] instructions;
private int pointerDir,pointerInstruction;
public interFace(String welcometxt, Integer[] instructions, PositionVector.Direction[] directions) {
super(welcometxt);
pointerDir = -1;
pointerInstruction = -1;
this.instructions = instructions;
this.directions = directions;
}
@Override
public int selectOption(String text, List<String> options) {
pointerInstruction++;
return instructions[pointerInstruction];
}
public void printInformation(String text) {
}
public void printTrack(Track track) {
}
public void quit(String text) {
}
public PositionVector.Direction selectDirection(int playingCarIndex, char playingCarID) {
pointerDir += 1;
if(pointerDir < directions.length) {
return directions[pointerDir];
}
return NONE;
}
}
}