fdai6281
/
CliArcadeService
1
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merge branch 'feature-chess' into development

development
Dion Aliu 3 years ago
parent
88d236c328 4ef75e249b
commit
c897f8ded4
6 changed files with 1028 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 247
      src/main/java/Game/Chess.java
  2. 195
      src/main/java/Game/ChessObj/ChessBoard.java
  3. 115
      src/main/java/Game/ChessObj/ChessFigure.java
  4. 228
      src/test/java/Game/ChessObj/ChessBoardTest.java
  5. 111
      src/test/java/Game/ChessObj/ChessFigureTest.java
  6. 132
      src/test/java/Game/ChessTest.java

247
src/main/java/Game/Chess.java
View File

@ -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;
}
}

195
src/main/java/Game/ChessObj/ChessBoard.java
View File

@ -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;
}
}

115
src/main/java/Game/ChessObj/ChessFigure.java
View File

@ -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;
}
}

228
src/test/java/Game/ChessObj/ChessBoardTest.java
View File

@ -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));
}
}

111
src/test/java/Game/ChessObj/ChessFigureTest.java
View File

@ -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");
}
}
}
}
}

132
src/test/java/Game/ChessTest.java
View File

@ -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