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

Merge remote-tracking branch 'origin/main'

This commit is contained in:
Leonardo Brandenberger 2022-03-23 21:07:55 +01:00
parent a14327a2a7 ded9023ff1
commit 787ddd7155
18 changed files with 884 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Klassendiagramm.drawio Normal file
View File

@ -0,0 +1 @@
<mxfile host="Electron" modified="2022-03-22T17:46:19.706Z" agent="5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/16.5.1 Chrome/96.0.4664.110 Electron/16.0.7 Safari/537.36" etag="blTsmpdlGFIXdx0F82xm" version="16.5.1" type="device"><diagram id="C5RBs43oDa-KdzZeNtuy" name="Page-1">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</diagram></mxfile>

2
build.gradle
View File

@ -44,7 +44,7 @@ version = '2022.1'
application {
// Define the main class for the application.
mainClass = 'ch.zhaw.pm2.racetrack.ConsoleApp'
mainClass = 'ch.zhaw.pm2.racetrack.Main'
}
run {

19
follower/challenge_points.txt Normal file
View File

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

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

@ -24,6 +24,10 @@ public class Car implements CarSpecification {
* Current position of the car on the track grid using a {@link PositionVector}
*/
private PositionVector position;
/**
* Points that car is holding for determining winner.
*/
private int winPoints;
/**
* Current velocity of the car using a {@link PositionVector}
@ -59,6 +63,18 @@ public class Car implements CarSpecification {
return id;
}
public void increaseWinPoints() {
winPoints ++;
}
public void deductWinPoints() {
winPoints --;
}
public int getWinPoints() {
return winPoints;
}
/**
* Returns the current velocity of the car as a PositionVector.
*

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

@ -1,7 +1,11 @@
package ch.zhaw.pm2.racetrack;
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.List;
import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
@ -13,59 +17,158 @@ import static ch.zhaw.pm2.racetrack.PositionVector.Direction;
*/
public class Game implements GameSpecification {
public static final int NO_WINNER = -1;
private Track track;
private int currentCarIndex;
UserInterface userInterface;
public Game(UserInterface userInterface) {
this.userInterface = userInterface;
}
public boolean initPhase() throws InvalidTrackFormatException {
File folder = new File("tracks");
File[] listOfFiles = folder.listFiles();
if (listOfFiles.length > 0) {
List<String> tracks = new ArrayList<>();
for (File file : listOfFiles) {
tracks.add(file.getName());
}
File selectedTrack = listOfFiles[userInterface.selectOption("Select Track file", tracks)];
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++) {
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:
moveStrategy = new DoNotMoveStrategy();
break;
case 2:
moveStrategy = new UserMoveStrategy(userInterface, i, track.getCarId(i));
break;
case 3:
filePath = ".\\moves\\" + selectedTrack.getName().split("\\.")[0] + "-car-" + track.getCar(i).getID() + ".txt";
try {
moveStrategy = new MoveListStrategy(filePath);
} catch (FileNotFoundException e) {
userInterface.printInformation("There is no Move-List implemented. Choose another Strategy!");
}
//TODO: Backslash kompatibel für Linux
break;
case 4:
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 {
userInterface.printInformation("No Trackfile found!");
return false;
}
}
/**
* 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.
*
* @return The zero-based number of the current car
*/
@Override
public int getCurrentCarIndex() {
// TODO: implementation
throw new UnsupportedOperationException();
return currentCarIndex;
}
/**
* Get the id of the specified car.
*
* @param carIndex The zero-based carIndex number
* @return A char containing the id of the car
*/
@Override
public char getCarId(int carIndex) {
// TODO: implementation
throw new UnsupportedOperationException();
return track.getCarId(carIndex);
}
/**
* Get the position of the specified car.
*
* @param carIndex The zero-based carIndex number
* @return A PositionVector containing the car's current position
*/
@Override
public PositionVector getCarPosition(int carIndex) {
// TODO: implementation
throw new UnsupportedOperationException();
return track.getCarPos(carIndex);
}
/**
* Get the velocity of the specified car.
*
* @param carIndex The zero-based carIndex number
* @return A PositionVector containing the car's current velocity
*/
@Override
public PositionVector getCarVelocity(int carIndex) {
// TODO: implementation
throw new UnsupportedOperationException();
return track.getCarVelocity(carIndex);
}
/**
* Return the winner of the game. If the game is still in progress, returns NO_WINNER.
*
* @return The winning car's index (zero-based, see getCurrentCar()), or NO_WINNER if the game is still in progress
*/
@Override
public int getWinner() {
// TODO: implementation
throw new UnsupportedOperationException();
if (onlyOneCarLeft()) {
return currentCarIndex;
}
for (int i = 0; i < track.getCarCount(); i++) {
if (track.getCar(i).getWinPoints() == 1) {
return i;
}
}
return NO_WINNER;
}
/**
@ -95,9 +198,47 @@ public class Game implements GameSpecification {
* for this turn
*/
@Override
public void doCarTurn(Direction acceleration) {
// TODO: implementation
throw new UnsupportedOperationException();
public void doCarTurn(Direction acceleration) throws PositionVectorNotValid {
track.getCar(currentCarIndex).accelerate(acceleration);
PositionVector crashPosition = null;
List<PositionVector> positionList = calculatePath(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition());
for (int i = 0; i < positionList.size(); i++) {
if (willCarCrash(currentCarIndex, positionList.get(i))) {
if (i == 0) {
crashPosition = track.getCarPos(currentCarIndex);
} else {
crashPosition = positionList.get(i - 1);
}
break;
}
}
if (crashPosition != null) {
track.carDoesCrash(currentCarIndex, crashPosition);
} else {
calculateWinner(track.getCarPos(currentCarIndex), track.getCar(currentCarIndex).nextPosition(), currentCarIndex);
track.moveCar(currentCarIndex);
}
}
public String gamePhase() throws PositionVectorNotValid {
while (carsMoving() && getWinner() == NO_WINNER) {
userInterface.printTrack(track);
Direction direction;
direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
if (direction == null) {
track.getCar(currentCarIndex).setMoveStrategy(new DoNotMoveStrategy());
direction = track.getCar(currentCarIndex).getMoveStrategy().nextMove();
}
doCarTurn(direction);
switchToNextActiveCar();
}
userInterface.printTrack(track);
int indexWinner = getWinner();
if (indexWinner == NO_WINNER) {
return null;
}
return String.valueOf(track.getCar(indexWinner).getID());
}
/**
@ -105,8 +246,14 @@ public class Game implements GameSpecification {
*/
@Override
public void switchToNextActiveCar() {
// TODO: implementation
throw new UnsupportedOperationException();
do {
if ((currentCarIndex + 1) == track.getCarCount()) {
currentCarIndex = 0;
} else {
currentCarIndex++;
}
} while (track.getCar(currentCarIndex).isCrashed());
// TODO: evtl andere Kapselung
}
/**
@ -117,28 +264,139 @@ public class Game implements GameSpecification {
* - Detect which axis of the distance vector is longer (faster movement)
* - for each pixel on the 'faster' axis calculate the position on the 'slower' axis.
* Direction of the movement has to correctly considered
*
* @param startPosition Starting position as a PositionVector
* @param endPosition Ending position as a PositionVector
* @return Intervening grid positions as a List of PositionVector's, including the starting and ending positions.
*/
@Override
public List<PositionVector> calculatePath(PositionVector startPosition, PositionVector endPosition) {
// TODO: implementation
throw new UnsupportedOperationException();
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;
}
private void calculateWinner(PositionVector start, PositionVector finish, int carIndex) {
List<PositionVector> path = calculatePath(start, finish);
for (PositionVector point : path) {
if (track.getSpaceType(point) != null) {
switch (track.getSpaceType(point)) {
case FINISH_UP:
if (start.getY() < finish.getY()) {
track.getCar(carIndex).increaseWinPoints();
} else if (start.getY() > finish.getY()) {
track.getCar(carIndex).deductWinPoints();
}
break;
case FINISH_DOWN:
if (start.getY() > finish.getY()) {
track.getCar(carIndex).increaseWinPoints();
} else if (start.getY() < finish.getY()) {
track.getCar(carIndex).deductWinPoints();
}
break;
case FINISH_RIGHT:
if (start.getX() < finish.getX()) {
track.getCar(carIndex).increaseWinPoints();
} else if (start.getX() > finish.getX()) {
track.getCar(carIndex).deductWinPoints();
}
break;
case FINISH_LEFT:
if (start.getX() > finish.getX()) {
track.getCar(carIndex).increaseWinPoints();
} else if (start.getX() < finish.getX()) {
track.getCar(carIndex).increaseWinPoints();
}
break;
}
}
}
}
/**
* Does indicate if a car would have a crash with a WALL space or another car at the given position.
*
* @param carIndex The zero-based carIndex number
* @param position A PositionVector of the possible crash position
* @return A boolean indicator if the car would crash with a WALL or another car.
*/
@Override
public boolean willCarCrash(int carIndex, PositionVector position) {
public boolean willCarCrash(int carIndex, PositionVector position) throws PositionVectorNotValid {
return track.willCrashAtPosition(carIndex, position);
}
public boolean onlyOneCarLeft() {
int carsLeft = 0;
for (int carIndex = 0; carIndex < track.getCarCount(); carIndex++) {
if (!track.getCar(carIndex).isCrashed()) {
carsLeft++;
}
}
return !(carsLeft > 1);
}
public boolean carsMoving() {
for (int carIndex = 0; carIndex < track.getCarCount(); carIndex++) {
if (!(track.getCar(carIndex).isCrashed() || track.getCar(carIndex).getMoveStrategy().getClass() == DoNotMoveStrategy.class)) {
return true;
}
}
return false;
}
}

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

@ -7,4 +7,7 @@ public class InvalidTrackFormatException extends Exception {
public InvalidTrackFormatException(String errorMessage) {
super(errorMessage);
}
public InvalidTrackFormatException() {
super();
}
}

40
src/main/java/ch/zhaw/pm2/racetrack/Main.java Normal file
View File

@ -0,0 +1,40 @@
package ch.zhaw.pm2.racetrack;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) throws InvalidTrackFormatException, PositionVectorNotValid {
UserInterface userInterface = new UserInterface("Hello and Welcome to Racetrack by Team02-\"AngryNerds\"");
while (true) {
Game game = new Game(userInterface);
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;
}
}
}
}

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

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

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

@ -22,6 +22,14 @@ public class UserInterface {
textTerminal.println(welcomeText + "\n");
}
/**
* Prints the given Text in textTerminal
* @param text The Text which should be printed.
*/
public void printInformation(String text) {
textTerminal.println(text);
}
/**
* asks the user to choose one of the options given.
* @param text Text which is printed befor the options are printed. Example: "Select Track file:"
@ -29,7 +37,7 @@ public class UserInterface {
* @return the list index of the selected option
*/
public int selectOption(String text, List<String> options) {
textTerminal.println(text + ":\n");
textTerminal.println(text + ":");
for(int option = 0; option < options.size(); option ++) {
textTerminal.println(" " + (option + 1) + ": " + options.get(option));
}
@ -44,7 +52,7 @@ public class UserInterface {
*/
public PositionVector.Direction selectDirection(int playingCarIndex, char playingCarID) {
PositionVector.Direction direction = null;
textTerminal.println("Playing Car " + playingCarIndex + ": " + playingCarIndex);
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");
@ -89,6 +97,15 @@ public class UserInterface {
textTerminal.println(track.toString());
}
/**
* Method to dispose the Textterminal
* @param text OUtput Text
*/
public void quit(String text){
textIO.newStringInputReader().withMinLength(0).read(text);
textTerminal.dispose();
}
}

5
src/main/java/ch/zhaw/pm2/racetrack/given/GameSpecification.java
View File

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

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

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

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

@ -2,11 +2,44 @@ package ch.zhaw.pm2.racetrack.strategy;
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.List;
import java.util.Scanner;
public class MoveListStrategy implements MoveStrategy {
private List<Direction> moveList;
private int pointer;
public MoveListStrategy(String path) throws FileNotFoundException{
moveList = new ArrayList<>();
pointer = -1;
readFile(new File(path));
}
private void readFile(File trackFile) throws FileNotFoundException {
Scanner scanner = new Scanner(new FileInputStream(trackFile), "UTF-8");
Direction[] directions = Direction.values();
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
for (Direction direction : directions) {
if (direction.toString().equals(line)) {
moveList.add(direction);
break;
}
}
}
}
@Override
public Direction nextMove() {
// TODO: implementation
throw new UnsupportedOperationException();
pointer += 1;
if (pointer < moveList.size()) {
return moveList.get(pointer);
}
return null;
}
}

115
src/main/java/ch/zhaw/pm2/racetrack/strategy/PathFollowerMoveStrategy.java
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;
}
}

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

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

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

@ -2,9 +2,11 @@
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;
@ -176,16 +178,51 @@ class CarTest {
car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy());
moveStrategy = new MoveListStrategy();
try {
moveStrategy = new MoveListStrategy(".\\moves\\challenge-car-a.txt");
} catch (FileNotFoundException e) {
Assertions.fail();
}
car.setMoveStrategy(moveStrategy);
assertEquals(moveStrategy, car.getMoveStrategy());
moveStrategy = new PathFollowerMoveStrategy();
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();
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());
}
}

233
src/test/java/ch/zhaw/pm2/racetrack/GameTest.java Normal file
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;
}
}
}

40
src/test/java/ch/zhaw/pm2/racetrack/MoveStrategyTest.java Normal file
View File

@ -0,0 +1,40 @@
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.FileNotFoundException;
public class MoveStrategyTest {
private MoveStrategy moveList;
@Nested
@DisplayName("MoveListStrategy")
class MoveList {
@BeforeEach
void setup() {
try {
moveList = new MoveListStrategy(".\\moves\\challenge-car-a.txt");
}catch (FileNotFoundException e) {
e.printStackTrace();
}
}
@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());
}
}
}

1
tracks/.gitignore vendored
View File

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