Jenkins
3 years ago
8 changed files with 1034 additions and 1 deletions
-
2pom.xml
-
5src/main/java/Application/App.java
-
247src/main/java/Game/Chess.java
-
195src/main/java/Game/ChessObj/ChessBoard.java
-
115src/main/java/Game/ChessObj/ChessFigure.java
-
228src/test/java/Game/ChessObj/ChessBoardTest.java
-
111src/test/java/Game/ChessObj/ChessFigureTest.java
-
132src/test/java/Game/ChessTest.java
@ -0,0 +1,247 @@ |
|||||
|
package Game; |
||||
|
|
||||
|
import Game.ChessObj.ChessBoard; |
||||
|
import Game.ChessObj.ChessFigure; |
||||
|
|
||||
|
import java.util.ArrayList; |
||||
|
|
||||
|
public class Chess extends Game { |
||||
|
|
||||
|
private int[] firstTurn; |
||||
|
private ChessFigure.Team currentTeam; |
||||
|
|
||||
|
private ArrayList<ChessFigure> destroyedWhiteFigures; |
||||
|
private ArrayList<ChessFigure> destroyedBlackFigures; |
||||
|
|
||||
|
private ChessBoard.MoveFeedback lastFeedback; |
||||
|
|
||||
|
private ChessBoard chessBoard; |
||||
|
|
||||
|
public Chess() { |
||||
|
init(); |
||||
|
} |
||||
|
|
||||
|
private void init() { |
||||
|
resetGame(); |
||||
|
} |
||||
|
|
||||
|
@Override |
||||
|
public void update(String input) { |
||||
|
outputBuffer.clear(); |
||||
|
ArrayList<String> footer = new ArrayList<>(); |
||||
|
|
||||
|
if (isFinished()) { |
||||
|
resetGame(); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int[] coords = convertInput(input); |
||||
|
|
||||
|
if (coords == null) { |
||||
|
footer.add("Invalid Input!"); |
||||
|
firstTurn = null; |
||||
|
} else { |
||||
|
if (firstTurn == null) { |
||||
|
firstTurn = coords; |
||||
|
if (getChessBoard().getBoard()[firstTurn[1]][firstTurn[0]] != null) { |
||||
|
if (getChessBoard().getBoard()[firstTurn[1]][firstTurn[0]].getTeam() == currentTeam) { |
||||
|
String firstCoords = (char) (firstTurn[0] + 97) + "" + (firstTurn[1] + 1); |
||||
|
footer.add("Currently selected cell: " + firstCoords); |
||||
|
} else { |
||||
|
footer.add("It's " + currentTeam.name() + "'s turn "); |
||||
|
firstTurn = null; |
||||
|
} |
||||
|
} else { |
||||
|
footer.add("Can't select empty cell"); |
||||
|
firstTurn = null; |
||||
|
} |
||||
|
} else { |
||||
|
footer = makeMove(firstTurn, coords); |
||||
|
if(lastFeedback != ChessBoard.MoveFeedback.INVALID && lastFeedback != ChessBoard.MoveFeedback.OUTSIDEOFBOARD) |
||||
|
switchCurrentTeam(); |
||||
|
firstTurn = null; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (chessBoard.scanForOccurringFigure(ChessFigure.Type.KING, ChessFigure.Team.WHITE) == 0) { |
||||
|
footer.add("Black has Won!"); |
||||
|
footer.add("Press any key to restart game"); |
||||
|
setFinished(true); |
||||
|
} |
||||
|
if (chessBoard.scanForOccurringFigure(ChessFigure.Type.KING, ChessFigure.Team.BLACK) == 0) { |
||||
|
footer.add("White has Won!"); |
||||
|
footer.add("Press any key to restart game"); |
||||
|
setFinished(true); |
||||
|
} |
||||
|
|
||||
|
outputBuffer.addAll(getHeader()); |
||||
|
outputBuffer.addAll(getUpdatedOutputBoard(destroyedWhiteFigures, destroyedBlackFigures)); |
||||
|
outputBuffer.addAll(footer); |
||||
|
|
||||
|
} |
||||
|
|
||||
|
private ArrayList<String> getHeader() { |
||||
|
ArrayList<String> header = new ArrayList<>(); |
||||
|
|
||||
|
header.add("Welcome to the good old game Chess!"); |
||||
|
header.add("First select one cell like: 'e7', than confirm it with an enter."); |
||||
|
header.add("After that, select a second cell and also confirm it with an enter."); |
||||
|
header.add("The Goal is to defeat the other teams King(K)."); |
||||
|
header.add(""); |
||||
|
header.add("It's your Turn " + currentTeam.name().toLowerCase() + "."); |
||||
|
|
||||
|
return header; |
||||
|
} |
||||
|
|
||||
|
//int[0] = x, int[1] = y; |
||||
|
public int[] convertInput(String input) { |
||||
|
int[] temp = new int[2]; |
||||
|
|
||||
|
//input is not 2 chars big |
||||
|
if (input.length() != 2) |
||||
|
return null; |
||||
|
char[] symbols = input.toCharArray(); |
||||
|
int counterDigit = 0; |
||||
|
int counterChar = 0; |
||||
|
//input contains one number and one char |
||||
|
for (char x : symbols) { |
||||
|
if (Character.isDigit(x)) { |
||||
|
counterDigit++; |
||||
|
temp[1] = Character.getNumericValue(x) - 1; |
||||
|
} |
||||
|
if (Character.isAlphabetic(x)) { |
||||
|
counterChar++; |
||||
|
temp[0] = x; |
||||
|
} |
||||
|
} |
||||
|
if (counterChar != 1 || counterDigit != 1) |
||||
|
return null; |
||||
|
|
||||
|
temp[0] = Character.toLowerCase(temp[0]) - 97; |
||||
|
if (!chessBoard.isCellInBoard(temp[0], temp[1])) |
||||
|
return null; |
||||
|
else |
||||
|
return temp; |
||||
|
} |
||||
|
|
||||
|
public ArrayList<String> makeMove(int[] source, int[] target) { |
||||
|
ArrayList<String> result = new ArrayList<>(); |
||||
|
ChessFigure sourceFigure = chessBoard.getBoard()[source[1]][source[0]]; |
||||
|
ChessFigure targetFigure = chessBoard.getBoard()[target[1]][target[0]]; |
||||
|
String sourceFigureName = "<NOT FOUND>"; |
||||
|
String targetFigureName = "<NOT FOUND>"; |
||||
|
String sourceCoords = (char) (source[0] + 97) + "" + (source[1] + 1); |
||||
|
String targetCoords = (char) (target[0] + 97) + "" + (target[1] + 1); |
||||
|
|
||||
|
ChessBoard.MoveFeedback moveFeedback = chessBoard.moveFigure(source[0], source[1], target[0], target[1]); |
||||
|
lastFeedback = moveFeedback; |
||||
|
|
||||
|
if (sourceFigure != null) |
||||
|
sourceFigureName = sourceFigure.getTeam().name().toCharArray()[0] + sourceFigure.getTeam().name().substring(1).toLowerCase() + " " + sourceFigure.getType().name().toLowerCase(); |
||||
|
if (targetFigure != null) |
||||
|
targetFigureName = targetFigure.getTeam().name().toLowerCase() + " " + targetFigure.getType().name().toLowerCase(); |
||||
|
|
||||
|
if (moveFeedback == ChessBoard.MoveFeedback.MOVE) { |
||||
|
result.add("Successfully moved " + sourceFigureName.toLowerCase() + " from " + sourceCoords + " to " + targetCoords); |
||||
|
} else if (moveFeedback == ChessBoard.MoveFeedback.ENEMYBEATEN) { |
||||
|
result.add(sourceFigureName + " successfully beat " + targetFigureName.toLowerCase() + " at " + targetCoords); |
||||
|
if (targetFigure.getTeam() == ChessFigure.Team.WHITE) |
||||
|
getDestroyedWhiteFigures().add(targetFigure); |
||||
|
else |
||||
|
getDestroyedBlackFigures().add(targetFigure); |
||||
|
} else { |
||||
|
result.add("Invalid input!"); |
||||
|
switch (moveFeedback) { |
||||
|
case INVALID: |
||||
|
if (targetFigure != null) |
||||
|
if (targetFigure.getTeam() == sourceFigure.getTeam()) |
||||
|
result.add("You are on the same Team! [" + getCurrentTeam().name() + "]"); |
||||
|
break; |
||||
|
case OUTSIDEOFBOARD: |
||||
|
result.add("Input is not inside the board!"); |
||||
|
break; |
||||
|
default: |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
private ArrayList<String> getUpdatedOutputBoard(ArrayList<ChessFigure> whiteFigures, ArrayList<ChessFigure> blackFigures) { |
||||
|
ArrayList<String> updatedOutputBoard = chessBoard.getOutputBoard(); |
||||
|
ArrayList<String> sidebarWhiteFigures = getSidebarFigures(whiteFigures, 5); |
||||
|
ArrayList<String> sidebarBlackFigures = getSidebarFigures(blackFigures, 5); |
||||
|
|
||||
|
for (int i = 0; i < sidebarWhiteFigures.size(); i++) { |
||||
|
int index = i + 3; |
||||
|
updatedOutputBoard.set(index, updatedOutputBoard.get(index) + sidebarWhiteFigures.get(i)); |
||||
|
} |
||||
|
|
||||
|
for (int i = 0; i < sidebarBlackFigures.size(); i++) { |
||||
|
int index = updatedOutputBoard.size() - (i + 3); |
||||
|
updatedOutputBoard.set(index, updatedOutputBoard.get(index) + sidebarBlackFigures.get(i)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
return updatedOutputBoard; |
||||
|
} |
||||
|
|
||||
|
public ArrayList<String> getSidebarFigures(ArrayList<ChessFigure> chessFigureArrayList, int maxPerLine) { |
||||
|
ArrayList<String> result = new ArrayList<>(); |
||||
|
String line = ""; |
||||
|
int counter = 0; |
||||
|
|
||||
|
for (int i = 0; i < chessFigureArrayList.size(); i++) { |
||||
|
if (i == chessFigureArrayList.size() - 1) { |
||||
|
line += chessFigureArrayList.get(i).getSymbol() + ""; |
||||
|
result.add(line); |
||||
|
return result; |
||||
|
} |
||||
|
line += chessFigureArrayList.get(i).getSymbol() + ","; |
||||
|
counter++; |
||||
|
if (counter >= maxPerLine) { |
||||
|
result.add(line); |
||||
|
line = ""; |
||||
|
counter = 0; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
private void switchCurrentTeam() { |
||||
|
if (currentTeam == ChessFigure.Team.WHITE) |
||||
|
currentTeam = ChessFigure.Team.BLACK; |
||||
|
else |
||||
|
currentTeam = ChessFigure.Team.WHITE; |
||||
|
} |
||||
|
|
||||
|
public void resetGame() { |
||||
|
chessBoard = new ChessBoard(); |
||||
|
firstTurn = null; |
||||
|
currentTeam = ChessFigure.Team.WHITE; |
||||
|
destroyedWhiteFigures = new ArrayList<>(); |
||||
|
destroyedBlackFigures = new ArrayList<>(); |
||||
|
setFinished(false); |
||||
|
outputBuffer.clear(); |
||||
|
outputBuffer.addAll(getHeader()); |
||||
|
outputBuffer.addAll(chessBoard.getOutputBoard()); |
||||
|
} |
||||
|
|
||||
|
public ChessBoard getChessBoard() { |
||||
|
return this.chessBoard; |
||||
|
} |
||||
|
|
||||
|
public ChessFigure.Team getCurrentTeam() { |
||||
|
return this.currentTeam; |
||||
|
} |
||||
|
|
||||
|
public ArrayList<ChessFigure> getDestroyedWhiteFigures() { |
||||
|
return destroyedWhiteFigures; |
||||
|
} |
||||
|
|
||||
|
public ArrayList<ChessFigure> getDestroyedBlackFigures() { |
||||
|
return destroyedBlackFigures; |
||||
|
} |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,195 @@ |
|||||
|
package Game.ChessObj; |
||||
|
|
||||
|
import java.util.ArrayList; |
||||
|
|
||||
|
public class ChessBoard { |
||||
|
|
||||
|
public enum MoveFeedback { |
||||
|
ENEMYBEATEN, |
||||
|
MOVE, |
||||
|
OUTSIDEOFBOARD, |
||||
|
INVALID |
||||
|
} |
||||
|
|
||||
|
private ChessFigure[][] board; |
||||
|
|
||||
|
public ChessBoard() { |
||||
|
board = new ChessFigure[8][8]; |
||||
|
initBoard(); |
||||
|
} |
||||
|
|
||||
|
protected void initBoard() { |
||||
|
ChessFigure.Type[] order = { |
||||
|
ChessFigure.Type.CASTLE, ChessFigure.Type.KNIGHT, ChessFigure.Type.BISHOP, ChessFigure.Type.QUEEN, ChessFigure.Type.KING, ChessFigure.Type.BISHOP, ChessFigure.Type.KNIGHT, ChessFigure.Type.CASTLE |
||||
|
}; |
||||
|
for (int x = 0; x < board[0].length; x++) { |
||||
|
//sets all pawns |
||||
|
board[1][x] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK); |
||||
|
board[6][x] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE); |
||||
|
|
||||
|
//sets all others |
||||
|
board[0][x] = new ChessFigure(order[x], ChessFigure.Team.BLACK); |
||||
|
board[7][x] = new ChessFigure(order[x], ChessFigure.Team.WHITE); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/* |
||||
|
a b c d e f g h |
||||
|
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ |
||||
|
1 │ |T| │ |Z| │ |I| │ |Q| │ |K| │ |I| │ |Z| │ |T| │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
2 │ |o| │ |o| │ |o| │ |o| │ |o| │ |o| │ |o| │ |o| │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
3 │ │ │ │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
4 │ │ │ │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
5 │ │ │ │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
6 │ │ │ │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
7 │ o │ o │ o │ o │ o │ o │ o │ o │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
8 │ T │ Z │ I │ Q │ K │ I │ Z │ T │ |
||||
|
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ |
||||
|
*/ |
||||
|
|
||||
|
public ArrayList<String> getOutputBoard() { |
||||
|
ArrayList<String> outputBoard = new ArrayList<>(); |
||||
|
String[][] cellSymbol = getCellSymbols(); |
||||
|
outputBoard.add(" a b c d e f g h"); |
||||
|
outputBoard.add(" ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐"); |
||||
|
for (int y = 0; y < board.length; y++) { |
||||
|
String line = ""; |
||||
|
line += " " + (y + 1) + " │ "; |
||||
|
for (int x = 0; x < board[0].length; x++) { |
||||
|
line += (cellSymbol[y][x] + " │ "); |
||||
|
} |
||||
|
outputBoard.add(line); |
||||
|
if (y < 7) |
||||
|
outputBoard.add(" ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤"); |
||||
|
} |
||||
|
outputBoard.add(" └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘"); |
||||
|
return outputBoard; |
||||
|
} |
||||
|
|
||||
|
public String[][] getCellSymbols() { |
||||
|
String[][] cellSymbol = new String[8][8]; |
||||
|
for (int y = 0; y < board.length; y++) { |
||||
|
for (int x = 0; x < board[0].length; x++) { |
||||
|
cellSymbol[y][x] = (board[y][x] == null) ? " " : board[y][x].getSymbol(); |
||||
|
} |
||||
|
} |
||||
|
return cellSymbol; |
||||
|
} |
||||
|
|
||||
|
public boolean isCellInBoard(int x, int y) { |
||||
|
if (x >= 0 && x < board[0].length && y >= 0 && y < board.length) |
||||
|
return true; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public boolean validateMove(int sourceX, int sourceY, int destX, int destY) { |
||||
|
//Destination not in board range |
||||
|
if (!isCellInBoard(sourceX, sourceY) || !isCellInBoard(destX, destY)) |
||||
|
return false; |
||||
|
ChessFigure figure = board[sourceY][sourceX]; |
||||
|
//Destination has same Team |
||||
|
if (board[destY][destX] != null) |
||||
|
if (board[destY][destX].getTeam() == figure.getTeam()) |
||||
|
return false; |
||||
|
int deltaX = destX - sourceX; |
||||
|
int deltaY = sourceY - destY; |
||||
|
//Pawn special case |
||||
|
if (figure.getType() == ChessFigure.Type.PAWN) { |
||||
|
if (board[destY][destX] != null) { |
||||
|
if (board[destY][destX].getTeam() == figure.getTeam()) |
||||
|
return false; |
||||
|
if (figure.getTeam() == ChessFigure.Team.WHITE && board[destY][destX].getTeam() != figure.getTeam() && (deltaX == -1 || deltaX == 1) && deltaY == 1) |
||||
|
return true; |
||||
|
if (figure.getTeam() == ChessFigure.Team.BLACK && board[destY][destX].getTeam() != figure.getTeam() && (deltaX == -1 || deltaX == 1) && deltaY == -1) |
||||
|
return true; |
||||
|
} |
||||
|
if (figure.isRelativeMoveValid(deltaX, deltaY)) |
||||
|
return true; |
||||
|
} |
||||
|
if (figure.isRelativeMoveValid(deltaX, deltaY)) { |
||||
|
if (figure.getType() == ChessFigure.Type.KNIGHT) |
||||
|
return true; |
||||
|
if (validateCleanPath(sourceX, sourceY, destX, destY)) |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
protected boolean validateCleanPath(int sourceX, int sourceY, final int destX, final int destY) { |
||||
|
int deltaX = destX - sourceX; |
||||
|
int deltaY = destY - sourceY; |
||||
|
|
||||
|
int stepX = getStepWidth(deltaX); |
||||
|
int stepY = getStepWidth(deltaY); |
||||
|
sourceX += stepX; |
||||
|
sourceY += stepY; |
||||
|
if (!isCellInBoard(sourceX, sourceY) || !isCellInBoard(destX, destY)) |
||||
|
return false; |
||||
|
if (Math.abs(deltaX) <= 1 && Math.abs(deltaY) <= 1) |
||||
|
return true; |
||||
|
while (!(sourceX == destX && sourceY == destY)) { |
||||
|
if (board[sourceY][sourceX] != null) |
||||
|
return false; |
||||
|
sourceX += stepX; |
||||
|
sourceY += stepY; |
||||
|
if (sourceX == destX && sourceY == destY) |
||||
|
return true; |
||||
|
if (sourceX > 7 || sourceY > 7) |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public MoveFeedback moveFigure(int sourceX, int sourceY, final int destX, final int destY) { |
||||
|
if (!isCellInBoard(sourceX, sourceY) || !isCellInBoard(destX, destY)) |
||||
|
return MoveFeedback.OUTSIDEOFBOARD; |
||||
|
if (validateMove(sourceX, sourceY, destX, destY)) { |
||||
|
MoveFeedback feedback = MoveFeedback.INVALID; |
||||
|
if (board[destY][destX] == null) |
||||
|
feedback = MoveFeedback.MOVE; |
||||
|
else |
||||
|
feedback = MoveFeedback.ENEMYBEATEN; |
||||
|
board[destY][destX] = board[sourceY][sourceX]; |
||||
|
board[sourceY][sourceX] = null; |
||||
|
return feedback; |
||||
|
} |
||||
|
return MoveFeedback.INVALID; |
||||
|
} |
||||
|
|
||||
|
private int getStepWidth(int delta) { |
||||
|
if (delta == 0) |
||||
|
return 0; |
||||
|
else if (delta > 0) |
||||
|
return 1; |
||||
|
else |
||||
|
return -1; |
||||
|
} |
||||
|
|
||||
|
public int scanForOccurringFigure(ChessFigure.Type type, ChessFigure.Team team){ |
||||
|
int count = 0; |
||||
|
ChessFigure template = new ChessFigure(type, team); |
||||
|
|
||||
|
for(int y = 0; y < board.length; y++) |
||||
|
for(int x = 0; x < board[0].length; x++) |
||||
|
count += (template.equals(board[y][x]))?1:0; |
||||
|
|
||||
|
return count; |
||||
|
} |
||||
|
|
||||
|
public ChessFigure[][] getBoard() { |
||||
|
return this.board; |
||||
|
} |
||||
|
|
||||
|
public void setChessBoard(ChessFigure[][] board) { |
||||
|
this.board = board; |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,115 @@ |
|||||
|
package Game.ChessObj; |
||||
|
|
||||
|
public class ChessFigure { |
||||
|
|
||||
|
public enum Type { |
||||
|
KING, |
||||
|
QUEEN, |
||||
|
CASTLE, |
||||
|
BISHOP, |
||||
|
KNIGHT, |
||||
|
PAWN |
||||
|
} |
||||
|
|
||||
|
public enum Team { |
||||
|
WHITE, |
||||
|
BLACK |
||||
|
} |
||||
|
|
||||
|
private final Type type; |
||||
|
private final Team team; |
||||
|
|
||||
|
public ChessFigure(Type type, Team team) { |
||||
|
this.type = type; |
||||
|
this.team = team; |
||||
|
} |
||||
|
|
||||
|
public Type getType() { |
||||
|
return this.type; |
||||
|
} |
||||
|
|
||||
|
public Team getTeam() { |
||||
|
return this.team; |
||||
|
} |
||||
|
|
||||
|
public String getSymbol() { |
||||
|
String symbol = ""; |
||||
|
switch (getType()) { |
||||
|
case KING: |
||||
|
symbol = "K"; |
||||
|
break; |
||||
|
case QUEEN: |
||||
|
symbol = "Q"; |
||||
|
break; |
||||
|
case CASTLE: |
||||
|
symbol = "T"; |
||||
|
break; |
||||
|
case BISHOP: |
||||
|
symbol = "I"; |
||||
|
break; |
||||
|
case KNIGHT: |
||||
|
symbol = "Z"; |
||||
|
break; |
||||
|
case PAWN: |
||||
|
symbol = "o"; |
||||
|
break; |
||||
|
default: |
||||
|
} |
||||
|
|
||||
|
symbol = ((this.getTeam() == Team.WHITE) ? " " : "|") + symbol + ((this.getTeam() == Team.WHITE) ? " " : "|"); |
||||
|
|
||||
|
return symbol; |
||||
|
} |
||||
|
|
||||
|
public boolean isRelativeMoveValid(int dx, int dy) { |
||||
|
if (dx == 0 && dy == 0) |
||||
|
return false; |
||||
|
switch (getType()) { |
||||
|
case KING: |
||||
|
if (Math.abs(dx) == 1 && Math.abs(dy) == 1) |
||||
|
return true; |
||||
|
break; |
||||
|
case QUEEN: |
||||
|
if ((Math.abs(dx) == Math.abs(dy)) || (dx == 0 ^ dy == 0)) |
||||
|
return true; |
||||
|
break; |
||||
|
case CASTLE: |
||||
|
if (dx == 0 ^ dy == 0) |
||||
|
return true; |
||||
|
break; |
||||
|
case BISHOP: |
||||
|
if (Math.abs(dx) == Math.abs(dy)) |
||||
|
return true; |
||||
|
break; |
||||
|
case KNIGHT: |
||||
|
if ((dy == 2 && (dx == -1 || dx == 1)) || (dy == -2 && (dx == -1 || dx == 1)) || (dx == 2 && (dy == -1 || dy == 1)) || (dx == -2 && (dy == -1 || dy == 1))) |
||||
|
return true; |
||||
|
break; |
||||
|
case PAWN: |
||||
|
if (dx != 0) |
||||
|
return false; |
||||
|
if (getTeam() == Team.WHITE && (dy == 1)) |
||||
|
return true; |
||||
|
if (getTeam() == Team.BLACK && (dy == -1)) |
||||
|
return true; |
||||
|
break; |
||||
|
default: |
||||
|
} |
||||
|
|
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
@Override |
||||
|
public boolean equals(Object o) { |
||||
|
if (!(o instanceof ChessFigure)) { |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
ChessFigure x = (ChessFigure) o; |
||||
|
if (this.getType() != x.getType() || this.getTeam() != x.getTeam()) |
||||
|
return false; |
||||
|
|
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,228 @@ |
|||||
|
package Game.ChessObj; |
||||
|
|
||||
|
import org.junit.jupiter.api.AfterEach; |
||||
|
import org.junit.jupiter.api.BeforeEach; |
||||
|
import org.junit.jupiter.api.Test; |
||||
|
|
||||
|
import static org.junit.jupiter.api.Assertions.*; |
||||
|
import static org.mockito.Mockito.mock; |
||||
|
|
||||
|
class ChessBoardTest { |
||||
|
|
||||
|
ChessFigure.Type[] startOrder = { |
||||
|
ChessFigure.Type.CASTLE, ChessFigure.Type.KNIGHT, ChessFigure.Type.BISHOP, ChessFigure.Type.QUEEN, ChessFigure.Type.KING, ChessFigure.Type.BISHOP, ChessFigure.Type.KNIGHT, ChessFigure.Type.CASTLE |
||||
|
}; |
||||
|
|
||||
|
ChessBoard chessBoard; |
||||
|
|
||||
|
@BeforeEach |
||||
|
void setUp() { |
||||
|
chessBoard = new ChessBoard(); |
||||
|
} |
||||
|
|
||||
|
@AfterEach |
||||
|
void tearDown() { |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void initBoard() { |
||||
|
ChessFigure[][] board = chessBoard.getBoard(); |
||||
|
for (int x = 0; x < board[0].length; x++) { |
||||
|
for (int y = 0; y < board.length; y++) { |
||||
|
//test pawns |
||||
|
if (y == 1) { |
||||
|
assertEquals(new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK), board[y][x]); |
||||
|
continue; |
||||
|
} |
||||
|
if (y == 6) { |
||||
|
assertEquals(new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE), board[y][x]); |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
if (y == 0) { |
||||
|
assertEquals(new ChessFigure(startOrder[x], ChessFigure.Team.BLACK), board[y][x]); |
||||
|
continue; |
||||
|
} |
||||
|
if (y == 7) { |
||||
|
assertEquals(new ChessFigure(startOrder[x], ChessFigure.Team.WHITE), board[y][x]); |
||||
|
continue; |
||||
|
} |
||||
|
//rest should be empty(null) |
||||
|
assertNull(board[y][x]); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void getCellSymbols() { |
||||
|
String[][] expectedArray = { |
||||
|
{"|T|", "|Z|", "|I|", "|Q|", "|K|", "|I|", "|Z|", "|T|"}, |
||||
|
{"|o|", "|o|", "|o|", "|o|", "|o|", "|o|", "|o|", "|o|"}, |
||||
|
{" ", " ", " ", " ", " ", " ", " ", " "}, |
||||
|
{" ", " ", " ", " ", " ", " ", " ", " "}, |
||||
|
{" ", " ", " ", " ", " ", " ", " ", " "}, |
||||
|
{" ", " ", " ", " ", " ", " ", " ", " "}, |
||||
|
{" o ", " o ", " o ", " o ", " o ", " o ", " o ", " o "}, |
||||
|
{" T ", " Z ", " I ", " Q ", " K ", " I ", " Z ", " T "} |
||||
|
}; |
||||
|
assertArrayEquals(expectedArray, chessBoard.getCellSymbols()); |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void isCellInBoard() { |
||||
|
assertTrue(chessBoard.isCellInBoard(0, 0)); |
||||
|
assertTrue(chessBoard.isCellInBoard(7, 7)); |
||||
|
assertTrue(chessBoard.isCellInBoard(2, 1)); |
||||
|
assertTrue(chessBoard.isCellInBoard(5, 7)); |
||||
|
assertFalse(chessBoard.isCellInBoard(-1, 0)); |
||||
|
assertFalse(chessBoard.isCellInBoard(4, 8)); |
||||
|
assertFalse(chessBoard.isCellInBoard(10, 20)); |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void validateCleanPath() { |
||||
|
ChessFigure[][] tempBoard = chessBoard.getBoard(); |
||||
|
|
||||
|
tempBoard[3][0] = mock(ChessFigure.class); |
||||
|
tempBoard[3][5] = mock(ChessFigure.class); |
||||
|
chessBoard.setChessBoard(tempBoard); |
||||
|
|
||||
|
assertFalse(chessBoard.validateCleanPath(-2, 0, 1, 4)); |
||||
|
assertTrue(chessBoard.validateCleanPath(0, 3, 5, 3)); |
||||
|
assertFalse(chessBoard.validateCleanPath(0, 3, 6, 3)); |
||||
|
assertFalse(chessBoard.validateCleanPath(0, 3, 7, 3)); |
||||
|
assertFalse(chessBoard.validateCleanPath(0, 3, 5, 5)); |
||||
|
assertFalse(chessBoard.validateCleanPath(0, 3, 4, 7)); |
||||
|
assertTrue(chessBoard.validateCleanPath(0, 3, 2, 5)); |
||||
|
assertTrue(chessBoard.validateCleanPath(7, 3, 5, 5)); |
||||
|
assertFalse(chessBoard.validateCleanPath(7, 3, 6, 6)); |
||||
|
} |
||||
|
|
||||
|
/* |
||||
|
0 1 2 3 4 5 6 7 |
||||
|
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ |
||||
|
0 │ │ │ │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
1 │ │ │ │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
2 │ │ │ │ │ o │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
3 │ │ │ │ |o| │ │ |o| │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
4 │ │ │ o │ │ o │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
5 │ │ │ │ |o| │ │ │ |T| │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
6 │ │ │ │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
7 │ │ │ T │ │ B │ │ │ │ |
||||
|
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ |
||||
|
*/ |
||||
|
@Test |
||||
|
void validateMove() { |
||||
|
ChessFigure[][] tempBoard = new ChessFigure[8][8]; |
||||
|
|
||||
|
tempBoard[4][2] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE); |
||||
|
tempBoard[4][4] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE); |
||||
|
tempBoard[2][4] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE); |
||||
|
tempBoard[3][3] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK); |
||||
|
tempBoard[3][5] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK); |
||||
|
tempBoard[5][3] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK); |
||||
|
tempBoard[7][2] = new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.WHITE); |
||||
|
tempBoard[7][4] = new ChessFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE); |
||||
|
tempBoard[5][6] = new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.BLACK); |
||||
|
|
||||
|
chessBoard.setChessBoard(tempBoard); |
||||
|
|
||||
|
//White pawn normal move |
||||
|
assertTrue(chessBoard.validateMove(4, 2, 4, 1)); |
||||
|
assertFalse(chessBoard.validateMove(4, 2, 4, 3)); |
||||
|
assertFalse(chessBoard.validateMove(4, 2, 3, 1)); |
||||
|
assertFalse(chessBoard.validateMove(4, 2, 5, 1)); |
||||
|
//White pawn beats Black |
||||
|
assertTrue(chessBoard.validateMove(4, 4, 3, 3)); |
||||
|
assertTrue(chessBoard.validateMove(4, 4, 5, 3)); |
||||
|
//Black pawn normal move |
||||
|
assertTrue(chessBoard.validateMove(3, 5, 3, 6)); |
||||
|
assertFalse(chessBoard.validateMove(3, 5, 3, 4)); |
||||
|
assertFalse(chessBoard.validateMove(3, 5, 2, 6)); |
||||
|
assertFalse(chessBoard.validateMove(3, 5, 6, 6)); |
||||
|
//Black pawn beats White |
||||
|
assertTrue(chessBoard.validateMove(3, 3, 2, 4)); |
||||
|
assertTrue(chessBoard.validateMove(3, 3, 4, 4)); |
||||
|
|
||||
|
//CastleMoves for testing global rules |
||||
|
assertTrue(chessBoard.validateMove(2, 7, 2, 5)); |
||||
|
assertFalse(chessBoard.validateMove(2, 7, 2, 4)); |
||||
|
assertFalse(chessBoard.validateMove(2, 7, 2, 2)); |
||||
|
|
||||
|
//Bishop Moves for testing global moves |
||||
|
assertTrue(chessBoard.validateMove(4, 7, 5, 6)); |
||||
|
assertTrue(chessBoard.validateMove(4, 7, 6, 5)); |
||||
|
assertFalse(chessBoard.validateMove(4, 7, 7, 4)); |
||||
|
} |
||||
|
|
||||
|
/* |
||||
|
0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 |
||||
|
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ |
||||
|
0 │ │ │ │ │ │ │ │ │ 0 │ │ │ │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
1 │ │ │ │ T │ │ │ │ K │ 1 │ │ │ │ │ │ │ │ K │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
2 │ │ │ │ │ │ │ │ │ 2 │ │ │ │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
3 │ │ │ │ │ │ Z │ │ │ 3 │ │ │ │ │ │ Z │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ --> ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
4 │ │ │ │ │ │ │ │ │ 4 │ │ │ │ │ B │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
5 │ │ │ |Q| │ │ │ │ │ │ 5 │ │ │ T │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
6 │ │ │ │ │ │ │ B │ │ 6 │ │ │ │ │ │ │ │ │ |
||||
|
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ |
||||
|
7 │ │ │ │ │ │ │ │ │ 7 │ │ │ │ │ │ │ │ │ |
||||
|
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ |
||||
|
*/ |
||||
|
@Test |
||||
|
void moveFigure() { |
||||
|
ChessFigure[][] tempBoard = new ChessFigure[8][8]; |
||||
|
ChessFigure[][] resultBoard = new ChessFigure[8][8]; |
||||
|
|
||||
|
tempBoard[1][3] = new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.WHITE); |
||||
|
tempBoard[1][7] = new ChessFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE); |
||||
|
tempBoard[6][6] = new ChessFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE); |
||||
|
tempBoard[3][5] = new ChessFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE); |
||||
|
tempBoard[5][2] = new ChessFigure(ChessFigure.Type.QUEEN, ChessFigure.Team.BLACK); |
||||
|
|
||||
|
resultBoard[5][2] = new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.WHITE); |
||||
|
resultBoard[1][7] = new ChessFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE); |
||||
|
resultBoard[4][4] = new ChessFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE); |
||||
|
resultBoard[3][5] = new ChessFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE); |
||||
|
|
||||
|
chessBoard.setChessBoard(tempBoard); |
||||
|
|
||||
|
assertEquals(chessBoard.moveFigure(3, 1, 2, 1), ChessBoard.MoveFeedback.MOVE); |
||||
|
assertEquals(chessBoard.moveFigure(2, 1, 2, 5), ChessBoard.MoveFeedback.ENEMYBEATEN); |
||||
|
assertEquals(chessBoard.moveFigure(6, 6, 4, 4), ChessBoard.MoveFeedback.MOVE); |
||||
|
assertEquals(chessBoard.moveFigure(7, 1, 8, 1), ChessBoard.MoveFeedback.OUTSIDEOFBOARD); |
||||
|
assertEquals(chessBoard.moveFigure(5, 3, 4, 2), ChessBoard.MoveFeedback.INVALID); |
||||
|
|
||||
|
assertArrayEquals(resultBoard, chessBoard.getBoard()); |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void scanForOccurringFigure() { |
||||
|
assertEquals(8, chessBoard.scanForOccurringFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE)); |
||||
|
assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.WHITE)); |
||||
|
assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE)); |
||||
|
assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE)); |
||||
|
assertEquals(1, chessBoard.scanForOccurringFigure(ChessFigure.Type.QUEEN, ChessFigure.Team.WHITE)); |
||||
|
assertEquals(1, chessBoard.scanForOccurringFigure(ChessFigure.Type.KING, ChessFigure.Team.WHITE)); |
||||
|
|
||||
|
assertEquals(8, chessBoard.scanForOccurringFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK)); |
||||
|
assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.BLACK)); |
||||
|
assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.BLACK)); |
||||
|
assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.BLACK)); |
||||
|
assertEquals(1, chessBoard.scanForOccurringFigure(ChessFigure.Type.QUEEN, ChessFigure.Team.BLACK)); |
||||
|
assertEquals(1, chessBoard.scanForOccurringFigure(ChessFigure.Type.KING, ChessFigure.Team.BLACK)); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,111 @@ |
|||||
|
package Game.ChessObj; |
||||
|
|
||||
|
import org.junit.jupiter.api.AfterEach; |
||||
|
import org.junit.jupiter.api.BeforeEach; |
||||
|
import org.junit.jupiter.api.Test; |
||||
|
|
||||
|
import java.util.ArrayList; |
||||
|
|
||||
|
import static org.junit.jupiter.api.Assertions.*; |
||||
|
|
||||
|
class ChessFigureTest { |
||||
|
|
||||
|
@BeforeEach |
||||
|
void setUp() { |
||||
|
} |
||||
|
|
||||
|
@AfterEach |
||||
|
void tearDown() { |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void getSymbol() { |
||||
|
assertEquals(" K ", new ChessFigure(ChessFigure.Type.KING, ChessFigure.Team.WHITE).getSymbol()); |
||||
|
assertEquals(" Q ", new ChessFigure(ChessFigure.Type.QUEEN, ChessFigure.Team.WHITE).getSymbol()); |
||||
|
assertEquals(" I ", new ChessFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE).getSymbol()); |
||||
|
assertEquals(" T ", new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.WHITE).getSymbol()); |
||||
|
assertEquals(" Z ", new ChessFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE).getSymbol()); |
||||
|
assertEquals(" o ", new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE).getSymbol()); |
||||
|
assertEquals("|K|", new ChessFigure(ChessFigure.Type.KING, ChessFigure.Team.BLACK).getSymbol()); |
||||
|
assertEquals("|Q|", new ChessFigure(ChessFigure.Type.QUEEN, ChessFigure.Team.BLACK).getSymbol()); |
||||
|
assertEquals("|I|", new ChessFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.BLACK).getSymbol()); |
||||
|
assertEquals("|T|", new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.BLACK).getSymbol()); |
||||
|
assertEquals("|Z|", new ChessFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.BLACK).getSymbol()); |
||||
|
assertEquals("|o|", new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK).getSymbol()); |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void testEquals() { |
||||
|
ChessFigure kw1 = new ChessFigure(ChessFigure.Type.KING, ChessFigure.Team.WHITE); |
||||
|
ChessFigure kw2 = new ChessFigure(ChessFigure.Type.KING, ChessFigure.Team.WHITE); |
||||
|
ChessFigure kb1 = new ChessFigure(ChessFigure.Type.KING, ChessFigure.Team.BLACK); |
||||
|
ChessFigure pw1 = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE); |
||||
|
|
||||
|
assertEquals(kw1, kw2); |
||||
|
assertNotEquals(kw2, kb1); |
||||
|
assertNotEquals(pw1, kb1); |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void isRelativeMoveValid() { |
||||
|
ArrayList<ChessFigure> array = new ArrayList<>(); |
||||
|
for (ChessFigure.Type type : ChessFigure.Type.values()) |
||||
|
for (ChessFigure.Team team : ChessFigure.Team.values()) |
||||
|
array.add(new ChessFigure(type, team)); |
||||
|
|
||||
|
for (ChessFigure figure : array) { |
||||
|
for (int x = -4; x <= 4; x++) { |
||||
|
for (int y = -4; y <= 4; y++) { |
||||
|
if (x == 0 && y == 0) { |
||||
|
assertFalse(figure.isRelativeMoveValid(x, y)); |
||||
|
continue; |
||||
|
} |
||||
|
switch (figure.getType()) { |
||||
|
case KING: |
||||
|
if (x * x == 1 && y * y == 1) { |
||||
|
assertTrue(figure.isRelativeMoveValid(x, y)); |
||||
|
continue; |
||||
|
} |
||||
|
break; |
||||
|
case QUEEN: |
||||
|
if (Math.abs(x) == Math.abs(y) || (x == 0 ^ y == 0)) { |
||||
|
assertTrue(figure.isRelativeMoveValid(x, y)); |
||||
|
continue; |
||||
|
} |
||||
|
break; |
||||
|
case CASTLE: |
||||
|
if (x == 0 ^ y == 0) { |
||||
|
assertTrue(figure.isRelativeMoveValid(x, y)); |
||||
|
continue; |
||||
|
} |
||||
|
break; |
||||
|
case BISHOP: |
||||
|
if (Math.abs(x) == Math.abs(y)) { |
||||
|
assertTrue(figure.isRelativeMoveValid(x, y)); |
||||
|
continue; |
||||
|
} |
||||
|
break; |
||||
|
case KNIGHT: |
||||
|
if ((y == 2 && (x == -1 || x == 1)) || (y == -2 && (x == -1 || x == 1)) || (x == 2 && (y == -1 || y == 1)) || (x == -2 && (y == -1 || y == 1))) { |
||||
|
assertTrue(figure.isRelativeMoveValid(x, y)); |
||||
|
continue; |
||||
|
} |
||||
|
break; |
||||
|
case PAWN: |
||||
|
if (figure.getTeam() == ChessFigure.Team.WHITE && (y == 1) && x == 0) { |
||||
|
assertTrue(figure.isRelativeMoveValid(x, y)); |
||||
|
continue; |
||||
|
} |
||||
|
if (figure.getTeam() == ChessFigure.Team.BLACK && (y == -1) && x == 0) { |
||||
|
assertTrue(figure.isRelativeMoveValid(x, y)); |
||||
|
continue; |
||||
|
} |
||||
|
break; |
||||
|
default: |
||||
|
} |
||||
|
assertFalse(figure.isRelativeMoveValid(x, y), "Type: " + figure.getType() + " X: " + x + " Y: " + y + " should be false"); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,132 @@ |
|||||
|
package Game; |
||||
|
|
||||
|
import Game.ChessObj.ChessFigure; |
||||
|
import org.junit.jupiter.api.AfterEach; |
||||
|
import org.junit.jupiter.api.BeforeEach; |
||||
|
import org.junit.jupiter.api.Test; |
||||
|
|
||||
|
import java.util.ArrayList; |
||||
|
|
||||
|
import static org.junit.jupiter.api.Assertions.*; |
||||
|
|
||||
|
class ChessTest { |
||||
|
|
||||
|
Chess chess; |
||||
|
|
||||
|
@BeforeEach |
||||
|
void setUp() { |
||||
|
chess = new Chess(); |
||||
|
} |
||||
|
|
||||
|
@AfterEach |
||||
|
void tearDown() { |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void convertInput() { |
||||
|
int[] test1 = {0, 0}; |
||||
|
int[] test2 = {7, 7}; |
||||
|
int[] test3 = {6, 2}; |
||||
|
|
||||
|
assertNull(chess.convertInput("0g2")); |
||||
|
assertNull(chess.convertInput("25")); |
||||
|
assertNull(chess.convertInput("bg")); |
||||
|
assertNull(chess.convertInput("9b")); |
||||
|
assertNull(chess.convertInput("2i")); |
||||
|
|
||||
|
assertArrayEquals(chess.convertInput("1a"), test1); |
||||
|
assertArrayEquals((chess.convertInput("a1")), test1); |
||||
|
assertArrayEquals((chess.convertInput("8h")), test2); |
||||
|
assertArrayEquals((chess.convertInput("h8")), test2); |
||||
|
|
||||
|
assertArrayEquals((chess.convertInput("3G")), test3); |
||||
|
assertArrayEquals((chess.convertInput("G3")), test3); |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void getSidebarFigures() { |
||||
|
ArrayList<ChessFigure> array1 = new ArrayList<>(); |
||||
|
ArrayList<ChessFigure> array2 = new ArrayList<>(); |
||||
|
ArrayList<ChessFigure> array3 = new ArrayList<>(); |
||||
|
ArrayList<String> expectedArray2 = new ArrayList<>(); |
||||
|
ArrayList<String> expectedArray3 = new ArrayList<>(); |
||||
|
|
||||
|
array2.add(new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE)); |
||||
|
array2.add(new ChessFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE)); |
||||
|
array2.add(new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE)); |
||||
|
array2.add(new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE)); |
||||
|
array2.add(new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.WHITE)); |
||||
|
array2.add(new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE)); |
||||
|
|
||||
|
expectedArray2.add(" o , I , o , o , T ,"); |
||||
|
expectedArray2.add(" o "); |
||||
|
|
||||
|
array3.add(new ChessFigure(ChessFigure.Type.QUEEN, ChessFigure.Team.BLACK)); |
||||
|
array3.add(new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK)); |
||||
|
array3.add(new ChessFigure(ChessFigure.Type.KING, ChessFigure.Team.BLACK)); |
||||
|
array3.add(new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK)); |
||||
|
|
||||
|
expectedArray3.add("|Q|,|o|,|K|,|o|"); |
||||
|
|
||||
|
assertEquals(0, chess.getSidebarFigures(array1, 5).size()); |
||||
|
assertEquals(expectedArray2, chess.getSidebarFigures(array2, 5)); |
||||
|
assertEquals(expectedArray3, chess.getSidebarFigures(array3, 5)); |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void makeMove() { |
||||
|
int countBlackPawns = chess.getChessBoard().scanForOccurringFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK); |
||||
|
int countWhiteBishops = chess.getChessBoard().scanForOccurringFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE); |
||||
|
chess.makeMove(chess.convertInput("a2"), chess.convertInput("a3")); |
||||
|
chess.makeMove(chess.convertInput("e7"), chess.convertInput("e6")); |
||||
|
chess.makeMove(chess.convertInput("f8"), chess.convertInput("a3")); |
||||
|
chess.makeMove(chess.convertInput("b2"), chess.convertInput("a3")); |
||||
|
|
||||
|
assertEquals(countBlackPawns - 1, chess.getChessBoard().scanForOccurringFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK)); |
||||
|
assertEquals(countWhiteBishops - 1, chess.getChessBoard().scanForOccurringFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE)); |
||||
|
} |
||||
|
|
||||
|
@Test |
||||
|
void update() { |
||||
|
//starting team = White |
||||
|
assertEquals(chess.getCurrentTeam(), ChessFigure.Team.WHITE); |
||||
|
|
||||
|
//Emtpy cell |
||||
|
chess.update("d7"); |
||||
|
chess.update("g5"); |
||||
|
assertEquals(chess.getCurrentTeam(), ChessFigure.Team.WHITE); |
||||
|
|
||||
|
chess.update("7b"); |
||||
|
chess.update("6b"); |
||||
|
assertEquals(chess.getCurrentTeam(), ChessFigure.Team.BLACK); |
||||
|
|
||||
|
chess.update("e2"); |
||||
|
chess.update("e3"); |
||||
|
assertEquals(chess.getCurrentTeam(), ChessFigure.Team.WHITE); |
||||
|
|
||||
|
chess.update("6b"); |
||||
|
chess.update("5b"); |
||||
|
assertEquals(chess.getCurrentTeam(), ChessFigure.Team.BLACK); |
||||
|
|
||||
|
//Defeat enemy |
||||
|
chess.update("f1"); |
||||
|
chess.update("b5"); |
||||
|
assertEquals(7, chess.getChessBoard().scanForOccurringFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE)); |
||||
|
assertEquals(chess.getCurrentTeam(), ChessFigure.Team.WHITE); |
||||
|
|
||||
|
chess.update("d7"); |
||||
|
chess.update("d6"); |
||||
|
assertEquals(chess.getCurrentTeam(), ChessFigure.Team.BLACK); |
||||
|
|
||||
|
//Invalid Move |
||||
|
chess.update("5b"); |
||||
|
chess.update("a5"); |
||||
|
assertEquals(chess.getCurrentTeam(), ChessFigure.Team.BLACK); |
||||
|
|
||||
|
//King defeated |
||||
|
chess.update("5b"); |
||||
|
chess.update("e8"); |
||||
|
|
||||
|
assertTrue(chess.isFinished()); |
||||
|
} |
||||
|
} |
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue