You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
195 lines
8.4 KiB
195 lines
8.4 KiB
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;
|
|
}
|
|
}
|