346 lines
12 KiB
Java
346 lines
12 KiB
Java
package backend;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
public class Board {
|
|
|
|
private int selectedX = -1; // negative value means impossible x and y so unselected
|
|
private int selectedY = -1;
|
|
|
|
private int turnNumber = 0; // tracks current turn
|
|
private int width; // enables to define the dimensions of board
|
|
private int height;
|
|
private Piece[][] board; // 2D array chess board
|
|
private ArrayList<int[]> highlightedPositions = new ArrayList<>(); // list of valid positions to highlight
|
|
|
|
public Board(int colNum, int lineNum) {
|
|
this.width = colNum;
|
|
this.height = lineNum;
|
|
this.board = new Piece[width][height]; // first empty board *********REVIEW************
|
|
clearConsole();
|
|
System.out.println(toString()); // print the chess at the beginning of the game
|
|
}
|
|
|
|
public int getWidth() {
|
|
return width;
|
|
}
|
|
|
|
public int getHeight() {
|
|
return height;
|
|
}
|
|
|
|
// new piece on the board at x,y (More specifically changes the empty cell of coordinates x,y with a new chess piece)
|
|
public void setPiece(boolean isWhite, PieceType type, int x, int y) {
|
|
board[x][y] = new Piece(x, y, type, isWhite);
|
|
}
|
|
|
|
public boolean isTurnWhite() {
|
|
if (turnNumber % 2 == 0) { // even turns including 0 are white's ones (% calculates the reminder of the euclidean division)
|
|
return true;
|
|
} else { // same reasoning, odd turns are black's ones
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public int getTurnNumber() { // this class enables to obtain the current turn number while increment adds 1 to this value for each turn
|
|
return turnNumber; // Necessarly in two functions to get rid of an infinite loop ****WHY****
|
|
}
|
|
|
|
public void incrementTurn() {
|
|
turnNumber++;
|
|
}
|
|
|
|
// set up the classic chess board taking it as a matrix and putting each corresponding starting piece at its place 0,0 is the top left spot of the board
|
|
public void populateBoard() {
|
|
// Black
|
|
setPiece(false, PieceType.Rook, 0, 0);
|
|
setPiece(false, PieceType.Knight, 1, 0);
|
|
setPiece(false, PieceType.Bishop, 2, 0);
|
|
setPiece(false, PieceType.Queen, 3, 0);
|
|
setPiece(false, PieceType.King, 4, 0);
|
|
setPiece(false, PieceType.Bishop, 5, 0);
|
|
setPiece(false, PieceType.Knight, 6, 0);
|
|
setPiece(false, PieceType.Rook, 7, 0);
|
|
|
|
// Black pawns
|
|
for (int i = 0; i < 8; i++) {
|
|
setPiece(false, PieceType.Pawn, i, 1);
|
|
}
|
|
|
|
// White pawns
|
|
for (int i = 0; i < 8; i++) {
|
|
setPiece(true, PieceType.Pawn, i, 6);
|
|
}
|
|
|
|
// White
|
|
setPiece(true, PieceType.Rook, 0, 7);
|
|
setPiece(true, PieceType.Knight, 1, 7);
|
|
setPiece(true, PieceType.Bishop, 2, 7);
|
|
setPiece(true, PieceType.Queen, 3, 7);
|
|
setPiece(true, PieceType.King, 4, 7);
|
|
setPiece(true, PieceType.Bishop, 5, 7);
|
|
setPiece(true, PieceType.Knight, 6, 7);
|
|
setPiece(true, PieceType.Rook, 7, 7);
|
|
}
|
|
|
|
public void cleanBoard() {
|
|
for (int x = 0; x < width; x++) {
|
|
for (int y = 0; y < height; y++) {
|
|
board[x][y] = null; // each position becomes empty
|
|
}
|
|
}
|
|
}
|
|
|
|
private void clearConsole() {
|
|
for (int i = 0; i < 50; i++) {
|
|
System.out.println(); // Print 50 empty lines to "clear" the console
|
|
}
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuilder str = new StringBuilder();
|
|
str.append(" A B C D E F G H\n"); // columns letter at the top
|
|
|
|
// representation of the rows
|
|
for (int y = 0; y < height; y++) {
|
|
str.append(8 - y).append(" "); // row number on the left
|
|
|
|
for (int x = 0; x < width; x++) {
|
|
if (board[x][y] == null) {
|
|
str.append("- "); // empty positions
|
|
} else {
|
|
// convert each piece of both color into a character
|
|
Piece piece = board[x][y];
|
|
char pieceChar;
|
|
|
|
switch (piece.getType()) { // switch function avoids too many if-else
|
|
case King: pieceChar = 'K'; break;
|
|
case Queen: pieceChar = 'Q'; break;
|
|
case Bishop: pieceChar = 'B'; break;
|
|
case Knight: pieceChar = 'N'; break; // N because we already have King
|
|
case Rook: pieceChar = 'R'; break;
|
|
case Pawn: pieceChar = 'P'; break;
|
|
default: pieceChar = '?'; break; // safety net
|
|
}
|
|
|
|
// Make black pieces in lowercase
|
|
if (!piece.isWhite()) {
|
|
pieceChar = Character.toLowerCase(pieceChar);
|
|
}
|
|
|
|
str.append(pieceChar).append(" "); // gives structure to the output
|
|
}
|
|
}
|
|
str.append("\n"); // change of row
|
|
}
|
|
|
|
// Additional infos for a proper output
|
|
str.append("Turn ").append(getTurnNumber()).append(": ");
|
|
str.append(isTurnWhite() ? "White" : "Black");
|
|
|
|
return str.toString();
|
|
}
|
|
|
|
// list the placement of the pieces on the board
|
|
public ArrayList<Piece> getPieces() {
|
|
ArrayList<Piece> pieces = new ArrayList<>();
|
|
// collect infos for the non-empty positions
|
|
for (int x = 0; x < width; x++) {
|
|
for (int y = 0; y < height; y++) {
|
|
if (board[x][y] != null) {
|
|
pieces.add(board[x][y]);
|
|
}
|
|
}
|
|
}
|
|
return pieces;
|
|
}
|
|
|
|
// user clicks on the board
|
|
public void userTouch(int x, int y) {
|
|
if (selectedX == -1 && selectedY == -1) {
|
|
// check if the position is empty and the color
|
|
if (board[x][y] != null && board[x][y].isWhite() == isTurnWhite()) {
|
|
// select it as active location
|
|
selectedX = x;
|
|
selectedY = y;
|
|
highlightedPositions = getValidMoves(board[x][y]); // compute valid moves
|
|
}
|
|
} else {
|
|
if (x == selectedX && y == selectedY) {
|
|
// unselect it
|
|
selectedX = -1;
|
|
selectedY = -1;
|
|
highlightedPositions.clear();
|
|
} else {
|
|
// allow move if valid destination
|
|
boolean valid = false;
|
|
for (int[] pos : highlightedPositions) {
|
|
if (pos[0] == x && pos[1] == y) {
|
|
valid = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (valid) {
|
|
Piece pieceToMove = board[selectedX][selectedY];
|
|
board[x][y] = new Piece(x, y, pieceToMove.getType(), pieceToMove.isWhite());
|
|
board[selectedX][selectedY] = null;
|
|
incrementTurn();
|
|
}
|
|
|
|
// reset selection
|
|
selectedX = -1;
|
|
selectedY = -1;
|
|
highlightedPositions.clear();
|
|
clearConsole();
|
|
System.out.println(toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean isSelected(int x, int y) {
|
|
return (x == selectedX && y == selectedY); // true if matching position
|
|
}
|
|
|
|
public boolean isHighlighted(int x, int y) { // checking for a given position if the square is highlighted or not
|
|
for (int[] pos : highlightedPositions) {
|
|
if (pos[0] == x && pos[1] == y) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* utility methods */
|
|
private boolean isInBounds(int x, int y) {
|
|
return x >= 0 && x < width && y >= 0 && y < height;
|
|
}
|
|
|
|
private void addLinearMoves(ArrayList<int[]> moves, int x, int y, Piece piece, int dx, int dy) {
|
|
int nx = x + dx;
|
|
int ny = y + dy;
|
|
while (isInBounds(nx, ny)) {
|
|
if (board[nx][ny] == null) {
|
|
moves.add(new int[]{nx, ny});
|
|
} else {
|
|
if (board[nx][ny].isWhite() != piece.isWhite()) {
|
|
moves.add(new int[]{nx, ny});
|
|
}
|
|
break;
|
|
}
|
|
nx += dx;
|
|
ny += dy;
|
|
}
|
|
}
|
|
|
|
private ArrayList<int[]> getValidMoves(Piece piece) {
|
|
ArrayList<int[]> moves = new ArrayList<>();
|
|
int x = piece.getX();
|
|
int y = piece.getY();
|
|
|
|
switch (piece.getType()) {
|
|
case Pawn:
|
|
int direction = piece.isWhite() ? -1 : 1;
|
|
int nextY = y + direction;
|
|
|
|
// forward move
|
|
if (isInBounds(x, nextY) && board[x][nextY] == null) {
|
|
moves.add(new int[]{x, nextY});
|
|
|
|
// double move from starting position
|
|
int startRow = piece.isWhite() ? 6 : 1;
|
|
int doubleStepY = y + 2 * direction;
|
|
if (y == startRow && isInBounds(x, doubleStepY) && board[x][doubleStepY] == null) {
|
|
moves.add(new int[]{x, doubleStepY});
|
|
}
|
|
}
|
|
|
|
// diagonal captures
|
|
for (int dx = -1; dx <= 1; dx += 2) {
|
|
int nx = x + dx;
|
|
if (isInBounds(nx, nextY) && board[nx][nextY] != null && board[nx][nextY].isWhite() != piece.isWhite()) {
|
|
moves.add(new int[]{nx, nextY});
|
|
}
|
|
}
|
|
break;
|
|
//for each piece, we calculate the positions it can end up in from an initial position
|
|
case Rook:
|
|
addLinearMoves(moves, x, y, piece, 1, 0);
|
|
addLinearMoves(moves, x, y, piece, -1, 0);
|
|
addLinearMoves(moves, x, y, piece, 0, 1);
|
|
addLinearMoves(moves, x, y, piece, 0, -1);
|
|
break;
|
|
|
|
case Bishop:
|
|
addLinearMoves(moves, x, y, piece, 1, 1);
|
|
addLinearMoves(moves, x, y, piece, -1, 1);
|
|
addLinearMoves(moves, x, y, piece, 1, -1);
|
|
addLinearMoves(moves, x, y, piece, -1, -1);
|
|
break;
|
|
|
|
case Queen:
|
|
for (int dx = -1; dx <= 1; dx++) {
|
|
for (int dy = -1; dy <= 1; dy++) {
|
|
if (dx != 0 || dy != 0) {
|
|
addLinearMoves(moves, x, y, piece, dx, dy);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case King:
|
|
for (int dx = -1; dx <= 1; dx++) {
|
|
for (int dy = -1; dy <= 1; dy++) {
|
|
if (dx != 0 || dy != 0) {
|
|
int nx = x + dx;
|
|
int ny = y + dy;
|
|
if (isInBounds(nx, ny) && (board[nx][ny] == null || board[nx][ny].isWhite() != piece.isWhite())) {
|
|
moves.add(new int[]{nx, ny});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case Knight:
|
|
int[][] jumps = {
|
|
{1, 2}, {2, 1}, {-1, 2}, {-2, 1}, // possible moves for
|
|
{-1, -2}, {-2, -1}, {1, -2}, {2, -1}
|
|
};
|
|
for (int[] j : jumps) {
|
|
int nx = x + j[0];
|
|
int ny = y + j[1];
|
|
if (isInBounds(nx, ny) && (board[nx][ny] == null || board[nx][ny].isWhite() != piece.isWhite())) {
|
|
moves.add(new int[]{nx, ny});
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return moves;
|
|
}
|
|
|
|
/* saving-loading feature : */
|
|
public String[] toFileRep() {
|
|
// TODO
|
|
return null;
|
|
}
|
|
|
|
public Board(String[] array) {
|
|
// TODO
|
|
}
|
|
|
|
/* additional functionality to implement later */
|
|
public void undoLastMove() {
|
|
// TODO
|
|
}
|
|
|
|
public void playMove(Move move) {
|
|
// TODO
|
|
}
|
|
|
|
public Board(Board board) {
|
|
// TODO
|
|
}
|
|
}
|