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

fixed PathFinderMoveStrategy

This commit is contained in:
romanschenk37 2022-03-25 00:02:04 +01:00
parent 7c8cf55ac2
commit b01bee0142
1 changed files with 59 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -3,7 +3,9 @@ package ch.zhaw.pm2.racetrack.strategy;
import ch.zhaw.pm2.racetrack.PositionVector; import ch.zhaw.pm2.racetrack.PositionVector;
import ch.zhaw.pm2.racetrack.Track; import ch.zhaw.pm2.racetrack.Track;
import java.util.*; import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class PathFinderMoveStrategy implements MoveStrategy{ public class PathFinderMoveStrategy implements MoveStrategy{
private Track track; private Track track;
@ -11,6 +13,7 @@ public class PathFinderMoveStrategy implements MoveStrategy{
private List<PositionVector.Direction> moveList; private List<PositionVector.Direction> moveList;
private int pointer; private int pointer;
private List<PositionVector.Direction> allDirections; private List<PositionVector.Direction> allDirections;
private List<State> calculatedStates;
public PathFinderMoveStrategy(Track track, int carIndex) { public PathFinderMoveStrategy(Track track, int carIndex) {
@ -23,49 +26,84 @@ public class PathFinderMoveStrategy implements MoveStrategy{
private void createMoveList(){ private void createMoveList(){
calculatedStates = new ArrayList<>();
PossibleMove finishedMove = null; PossibleMove finishedMove = null;
List<PossibleMove> possibleMoves= new ArrayList<>(); List<PossibleMove> possibleMoves= new ArrayList<>();
for(PositionVector.Direction direction : allDirections){ for(PositionVector.Direction direction : allDirections){
possibleMoves.add(new PossibleMove(null, direction)); PossibleMove newMove = new PossibleMove(null, direction);
if(! newMove.crashed()){
possibleMoves.add(newMove);
}
} }
while(finishedMove == null){ while(finishedMove == null){
List<PossibleMove> newMoves = new ArrayList<>(); List<PossibleMove> newMoves = new ArrayList<>();
for(PossibleMove previousMove : possibleMoves){ for(PossibleMove previousMove : possibleMoves){
for(PositionVector.Direction direction : allDirections){ for(PositionVector.Direction direction : allDirections){
PossibleMove newMove = new PossibleMove(previousMove, direction); PossibleMove newMove = new PossibleMove(previousMove, direction);
if(! (newMove.crashed() || newMove.drivingLoop() || finishedMove != null)){ State newState = new State(newMove.endPosition, newMove.endVelocity);
if(! (newMove.crashed() || alreadyCalculated(newState) || finishedMove != null)){
if(newMove.finished()){ if(newMove.finished()){
finishedMove = newMove; finishedMove = newMove;
break; } else {
} calculatedStates.add(newState);
newMoves.add(newMove); newMoves.add(newMove);
} }
} }
} }
}
possibleMoves = newMoves; possibleMoves = newMoves;
} }
moveList = finishedMove.directions; moveList = finishedMove.directions;
} }
private boolean alreadyCalculated(State state){
for(State calculatedState: calculatedStates){
if(state.equals(calculatedState)){
return true;
}
}
return false;
}
public class State{
PositionVector position;
PositionVector velocity;
public State(PositionVector position, PositionVector velocity){
this.position = position;
this.velocity = velocity;
}
public boolean equals(State compareState){
if(compareState.position.equals(position) && compareState.velocity.equals(velocity)){
return true;
} else{
return false;
}
}
}
public class PossibleMove { public class PossibleMove {
List<PositionVector.Direction> directions; List<PositionVector.Direction> directions;
List<PositionVector> positions; PositionVector startPosition;
PositionVector endPosition;
PositionVector endVelocity; PositionVector endVelocity;
public PossibleMove(PossibleMove previousMove, PositionVector.Direction nextDirection){ public PossibleMove(PossibleMove previousMove, PositionVector.Direction nextDirection){
PositionVector startVelocity; PositionVector startVelocity;
PositionVector startPosition;
positions = new ArrayList<>();
directions = new ArrayList<>(); directions = new ArrayList<>();
if(previousMove != null){ if(previousMove != null){
positions.addAll(previousMove.positions);
directions.addAll(previousMove.directions); directions.addAll(previousMove.directions);
startPosition = positions.get(positions.size()-1); startPosition = previousMove.endPosition;
startVelocity = previousMove.endVelocity; startVelocity = previousMove.endVelocity;
} }
else { else {
@ -74,37 +112,31 @@ public class PathFinderMoveStrategy implements MoveStrategy{
} }
directions.add(nextDirection); directions.add(nextDirection);
endVelocity = new PositionVector(startVelocity.getX() + nextDirection.vector.getX(), startVelocity.getY() + nextDirection.vector.getY()); endVelocity = new PositionVector(startVelocity.getX() + nextDirection.vector.getX(), startVelocity.getY() + nextDirection.vector.getY());
positions.add(new PositionVector(startPosition.getX() + endVelocity.getX(), startPosition.getY() + endVelocity.getY())); endPosition = new PositionVector(startPosition.getX() + endVelocity.getX(), startPosition.getY() + endVelocity.getY());
} }
public boolean finished(){ public boolean finished(){
if(track.calculateNewWinPoints(positions.get(positions.size()-2), positions.get(positions.size()-1)) == 1){ if(track.calculateNewWinPoints(startPosition, endPosition) == 1){
return true; return true;
} }
else return false; else{
return false;
}
} }
public boolean crashed() { public boolean crashed() {
for(PositionVector point : track.calculatePointsOnPath(positions.get(positions.size()-2), positions.get(positions.size()-1))) { List<PositionVector> points = track.calculatePointsOnPath(startPosition, endPosition);
for(PositionVector point : points) {
if (track.willCrashAtPosition(carIndex, point)){ if (track.willCrashAtPosition(carIndex, point)){
return true; return true;
} }
} }
if(track.calculateNewWinPoints(positions.get(positions.size()-2), positions.get(positions.size()-1)) == -1){ if(track.calculateNewWinPoints(startPosition, endPosition) == -1){
return true; return true;
} }
return false; return false;
} }
public boolean drivingLoop(){
for(int i = 0; i < positions.size()-1; i++){
if(positions.get(i).equals(positions.get(positions.size()-1))){
return true;
}
}
return false;
}
} }