294 lines
9.4 KiB
Java
294 lines
9.4 KiB
Java
package backend;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
public class Board {
|
|
|
|
public int width;
|
|
public int height;
|
|
private Piece[][] board;
|
|
private boolean hasSelectedPiece = false;
|
|
private int selectedX = -1;
|
|
private int selectedY = -1;
|
|
private int turnNumber = 0;
|
|
private boolean turnWhite = true;
|
|
private ArrayList<int[]> highlightedSquares = new ArrayList<>();
|
|
private int[] enPassantTarget = null; // [x,y] coordinates of en passant target square
|
|
|
|
public Board(int colNum, int lineNum) {
|
|
this.width = colNum;
|
|
this.height = lineNum;
|
|
this.board = new Piece[width][height];
|
|
}
|
|
|
|
public int getWidth() {
|
|
return width;
|
|
}
|
|
|
|
public int getHeight() {
|
|
return height;
|
|
}
|
|
|
|
public int getTurnNumber() {
|
|
return turnNumber;
|
|
}
|
|
|
|
public boolean isTurnWhite() {
|
|
return turnWhite;
|
|
}
|
|
|
|
public void setPiece(boolean isWhite, PieceType type, int x, int y) {
|
|
if (x >= 0 && x < width && y >= 0 && y < height) {
|
|
board[x][y] = new Piece(x, y, isWhite, type);
|
|
}
|
|
}
|
|
|
|
public void populateBoard() {
|
|
cleanBoard();
|
|
// White pawns
|
|
for (int x = 0; x < 8; x++) {
|
|
setPiece(true, PieceType.Pawn, x, 1);
|
|
}
|
|
// Black pawns
|
|
for (int x = 0; x < 8; x++) {
|
|
setPiece(false, PieceType.Pawn, x, 6);
|
|
}
|
|
|
|
PieceType[] backRow = {
|
|
PieceType.Rook, PieceType.Knight, PieceType.Bishop,
|
|
PieceType.Queen, PieceType.King, PieceType.Bishop,
|
|
PieceType.Knight, PieceType.Rook
|
|
};
|
|
|
|
// White back row
|
|
for (int x = 0; x < 8; x++) {
|
|
setPiece(true, backRow[x], x, 0);
|
|
}
|
|
// Black back row
|
|
for (int x = 0; x < 8; x++) {
|
|
setPiece(false, backRow[x], x, 7);
|
|
}
|
|
}
|
|
|
|
public void cleanBoard() {
|
|
for (int x = 0; x < width; x++) {
|
|
for (int y = 0; y < height; y++) {
|
|
board[x][y] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuilder stringboard= new StringBuilder();
|
|
for (int row = height - 1; row >= 0; row--) {
|
|
|
|
for (int column = 0; column < width; column++) {
|
|
Piece piece = board[column][row];
|
|
if (piece == null) {
|
|
stringboard.append(". ");
|
|
} else {
|
|
char sym = piece.getType().name().charAt(0);
|
|
stringboard.append(piece.isWhite() ? sym : Character.toLowerCase(sym))
|
|
.append(' ');
|
|
}
|
|
}
|
|
stringboard.append("\n");
|
|
}
|
|
stringboard.append(" ");
|
|
for (int x = 0; x < width; x++) {
|
|
stringboard.append((char)('a' + x)).append(' ');
|
|
}
|
|
stringboard.append("\n");
|
|
stringboard.append("Turn: ").append(isTurnWhite() ? "White" : "Black");
|
|
return stringboard.toString();
|
|
}
|
|
|
|
|
|
public ArrayList<Piece> getPieces() {
|
|
ArrayList<Piece> pieces = new ArrayList<>();
|
|
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;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
public boolean isSelected(int x, int y) {
|
|
return hasSelectedPiece && selectedX == x && selectedY == y;
|
|
}
|
|
|
|
private boolean inBounds(int x, int y) {
|
|
return x >= 0 && x < width && y >= 0 && y < height;
|
|
}
|
|
|
|
|
|
private ArrayList<int[]> getValidMoves(Piece piece) {
|
|
ArrayList<int[]> moves = new ArrayList<>();
|
|
int x = piece.getX();
|
|
int y = piece.getY();
|
|
PieceType type = piece.getType();
|
|
|
|
if (type == PieceType.Pawn) {
|
|
int dir = piece.isWhite() ? 1 : -1;
|
|
int startRow = piece.isWhite() ? 1 : 6;
|
|
|
|
// Normal forward moves
|
|
int oneStep = y + dir;
|
|
if (inBounds(x, oneStep) && board[x][oneStep] == null) {
|
|
moves.add(new int[]{x, oneStep});
|
|
|
|
// Two-step move from starting position
|
|
int twoStep = y + 2 * dir;
|
|
if (y == startRow && inBounds(x, twoStep) && board[x][twoStep] == null && board[x][oneStep] == null) {
|
|
moves.add(new int[]{x, twoStep});
|
|
}
|
|
}
|
|
|
|
// Capture diagonals (including en passant)
|
|
for (int dx : new int[]{-1, 1}) {
|
|
int nx = x + dx;
|
|
int ny = y + dir;
|
|
if (inBounds(nx, ny)) {
|
|
// Normal capture
|
|
if (board[nx][ny] != null && board[nx][ny].isWhite() != piece.isWhite()) {
|
|
moves.add(new int[]{nx, ny});
|
|
}
|
|
// En passant capture
|
|
else if (board[nx][ny] == null && enPassantTarget != null &&
|
|
nx == enPassantTarget[0] && ny == enPassantTarget[1]) {
|
|
// Verify there's an opponent pawn beside us
|
|
int pawnY = y; // The pawn to capture is beside us, not in front
|
|
if (inBounds(nx, pawnY) && board[nx][pawnY] != null &&
|
|
board[nx][pawnY].getType() == PieceType.Pawn &&
|
|
board[nx][pawnY].isWhite() != piece.isWhite()) {
|
|
moves.add(new int[]{nx, ny});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return moves;
|
|
}
|
|
|
|
|
|
|
|
|
|
public void userTouch(int x, int y) {
|
|
if (x < 0 || x >= width || y < 0 || y >= height) return;
|
|
|
|
Piece clicked = board[x][y];
|
|
|
|
if (!hasSelectedPiece) {
|
|
if (clicked != null && clicked.isWhite() == turnWhite) {
|
|
// Select piece
|
|
selectedX = x;
|
|
selectedY = y;
|
|
hasSelectedPiece = true;
|
|
highlightedSquares = getValidMoves(clicked);
|
|
}
|
|
} else {
|
|
// Check if clicked again on the same square to unselect
|
|
if (selectedX == x && selectedY == y) {
|
|
hasSelectedPiece = false;
|
|
highlightedSquares.clear();
|
|
}
|
|
// If clicked on a highlighted square, move there
|
|
else if (isHighlighted(x, y)) {
|
|
Piece selectedPiece = board[selectedX][selectedY];
|
|
|
|
// Check if this is an en passant capture
|
|
boolean isEnPassant = selectedPiece.getType() == PieceType.Pawn &&
|
|
enPassantTarget != null &&
|
|
x == enPassantTarget[0] &&
|
|
y == enPassantTarget[1] &&
|
|
board[x][y] == null;
|
|
|
|
// Move piece
|
|
board[x][y] = selectedPiece;
|
|
board[selectedX][selectedY] = null;
|
|
selectedPiece.setX(x);
|
|
selectedPiece.setY(y);
|
|
|
|
// If en passant, remove the captured pawn
|
|
if (isEnPassant) {
|
|
int capturedPawnY = selectedY; // The pawn is beside, not in front
|
|
board[x][capturedPawnY] = null;
|
|
}
|
|
|
|
// Set en passant target if pawn moved two squares
|
|
enPassantTarget = null;
|
|
if (selectedPiece.getType() == PieceType.Pawn &&
|
|
Math.abs(y - selectedY) == 2) {
|
|
enPassantTarget = new int[]{x, (selectedY + y) / 2};
|
|
}
|
|
|
|
// Update turn
|
|
turnWhite = !turnWhite;
|
|
turnNumber++;
|
|
|
|
// Clear selection & highlights
|
|
hasSelectedPiece = false;
|
|
highlightedSquares.clear();
|
|
}
|
|
// Invalid move: just unselect
|
|
else {
|
|
hasSelectedPiece = false;
|
|
highlightedSquares.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* saving-loading feature */
|
|
public String[] toFileRep() {
|
|
ArrayList<String> fileLines = new ArrayList<>();
|
|
fileLines.add(turnNumber + "," + (turnWhite ? "white" : "black"));
|
|
fileLines.add(width + "," + height);
|
|
for (Piece piece : getPieces()) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(piece.getType()) // e.g. "Pawn"
|
|
.append(",").append(piece.getX()) // file X
|
|
.append(",").append(piece.getY()) // file Y
|
|
.append(",").append(piece.isWhite() ? "W" : "B");
|
|
fileLines.add(sb.toString());
|
|
}
|
|
return fileLines.toArray(new String[0]);
|
|
}
|
|
|
|
|
|
|
|
public Board(String[] array) {
|
|
// TODO
|
|
}
|
|
|
|
/* The following methods require more work */
|
|
public boolean isHighlighted(int x, int y) {
|
|
for (int[] pos : highlightedSquares) {
|
|
if (pos[0] == x && pos[1] == y) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void undoLastMove() {
|
|
// TODO
|
|
}
|
|
|
|
public Board(Board board) {
|
|
// TODO helloyo
|
|
}
|
|
|
|
public void playMove(Move move) {
|
|
// TODO
|
|
}
|
|
} |