castling
This commit is contained in:
cleme
parent
b08bd6477f
commit
9ee1df68d8
|
|
@ -0,0 +1,359 @@
|
|||
package backend;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class CastlingHandler {
|
||||
private Board board;
|
||||
|
||||
public CastlingHandler(Board board) {
|
||||
this.board = board;
|
||||
}
|
||||
|
||||
public class CastlingMove {
|
||||
public final int kingFromX, kingFromY, kingToX, kingToY;
|
||||
public final int rookFromX, rookFromY, rookToX, rookToY;
|
||||
public final boolean isKingside;
|
||||
|
||||
public CastlingMove(int kingFromX, int kingFromY, int kingToX, int kingToY,
|
||||
int rookFromX, int rookFromY, int rookToX, int rookToY,
|
||||
boolean isKingside) {
|
||||
this.kingFromX = kingFromX;
|
||||
this.kingFromY = kingFromY;
|
||||
this.kingToX = kingToX;
|
||||
this.kingToY = kingToY;
|
||||
this.rookFromX = rookFromX;
|
||||
this.rookFromY = rookFromY;
|
||||
this.rookToX = rookToX;
|
||||
this.rookToY = rookToY;
|
||||
this.isKingside = isKingside;
|
||||
}
|
||||
}
|
||||
|
||||
public class Position {
|
||||
public int x;
|
||||
public int y;
|
||||
|
||||
public Position(int x, int y) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
|
||||
public boolean equals(Object obj) {
|
||||
if (this == obj) return true;
|
||||
if (obj == null || getClass() != obj.getClass()) return false;
|
||||
Position position = (Position) obj;
|
||||
return x == position.x && y == position.y;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if castling is possible and returns the castling move details
|
||||
*/
|
||||
public CastlingMove getCastlingMove(int fromX, int fromY, int toX, int toY) {
|
||||
Piece piece = board.getPieceAt(fromX, fromY);
|
||||
|
||||
// Must be a king
|
||||
if (piece == null || piece.getType() != PieceType.King) {
|
||||
return null;
|
||||
}
|
||||
|
||||
boolean isWhite = piece.isWhite();
|
||||
int kingRow = isWhite ? 7 : 0;
|
||||
|
||||
// King must be on its starting position
|
||||
if (fromY != kingRow || fromX != 4) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// Check if this is a castling move (king moves 2 squares horizontally)
|
||||
if (fromY != toY || Math.abs(toX - fromX) != 2) {
|
||||
return null;
|
||||
}
|
||||
|
||||
boolean isKingside = toX > fromX;
|
||||
int rookStartX = isKingside ? 7 : 0;
|
||||
int rookEndX = isKingside ? 5 : 3;
|
||||
|
||||
return new CastlingMove(fromX, fromY, toX, toY,
|
||||
rookStartX, kingRow, rookEndX, kingRow,
|
||||
isKingside);
|
||||
}
|
||||
|
||||
/**
|
||||
* Validates if castling is legal
|
||||
*/
|
||||
public boolean isCastlingValid(CastlingMove castling) {
|
||||
if (castling == null) return false;
|
||||
|
||||
Piece king = board.getPieceAt(castling.kingFromX, castling.kingFromY);
|
||||
Piece rook = board.getPieceAt(castling.rookFromX, castling.rookFromY);
|
||||
|
||||
// Verify pieces exist and are correct type/color
|
||||
if (king == null || king.getType() != PieceType.King) return false;
|
||||
if (rook == null || rook.getType() != PieceType.Rook) return false;
|
||||
if (king.isWhite() != rook.isWhite()) return false;
|
||||
|
||||
// Check if king or rook have moved (simplified - assumes starting positions)
|
||||
boolean isWhite = king.isWhite();
|
||||
int expectedKingRow = isWhite ? 7 : 0;
|
||||
if (castling.kingFromY != expectedKingRow || castling.kingFromX != 4) return false;
|
||||
if (castling.rookFromY != expectedKingRow) return false;
|
||||
if (castling.isKingside && castling.rookFromX != 7) return false;
|
||||
if (!castling.isKingside && castling.rookFromX != 0) return false;
|
||||
|
||||
// Check path is clear between king and rook
|
||||
int startX = Math.min(castling.kingFromX, castling.rookFromX) + 1;
|
||||
int endX = Math.max(castling.kingFromX, castling.rookFromX) - 1;
|
||||
|
||||
for (int x = startX; x <= endX; x++) {
|
||||
if (board.getPieceAt(x, castling.kingFromY) != null) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Check that king is not in check
|
||||
if (isKingInCheck(isWhite)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check that king doesn't pass through check
|
||||
for (int x = castling.kingFromX; x != castling.kingToX + (castling.isKingside ? 1 : -1);
|
||||
x += castling.isKingside ? 1 : -1) {
|
||||
|
||||
// Create temporary board with king at this position
|
||||
Board tempBoard = new Board(board);
|
||||
tempBoard.removePiece(castling.kingFromX, castling.kingFromY);
|
||||
tempBoard.setPiece(isWhite, PieceType.King, x, castling.kingFromY);
|
||||
|
||||
CastlingHandler tempHandler = new CastlingHandler(tempBoard);
|
||||
if (tempHandler.isKingInCheck(isWhite)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the castling move on the board
|
||||
*/
|
||||
public void executeCastling(CastlingMove castling) {
|
||||
Piece king = board.getPieceAt(castling.kingFromX, castling.kingFromY);
|
||||
Piece rook = board.getPieceAt(castling.rookFromX, castling.rookFromY);
|
||||
|
||||
// Move the king
|
||||
board.removePiece(castling.kingFromX, castling.kingFromY);
|
||||
board.setPiece(king.isWhite(), king.getType(), castling.kingToX, castling.kingToY);
|
||||
|
||||
// Move the rook
|
||||
board.removePiece(castling.rookFromX, castling.rookFromY);
|
||||
board.setPiece(rook.isWhite(), rook.getType(), castling.rookToX, castling.rookToY);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets all possible castling moves for a king
|
||||
*/
|
||||
public List<Position> getCastlingPositions(Piece king) {
|
||||
List<Position> castlingMoves = new ArrayList<>();
|
||||
|
||||
if (king.getType() != PieceType.King) {
|
||||
return castlingMoves;
|
||||
}
|
||||
|
||||
boolean isWhite = king.isWhite();
|
||||
int kingRow = isWhite ? 7 : 0;
|
||||
|
||||
// King must be on starting position
|
||||
if (king.getX() != 4 || king.getY() != kingRow) {
|
||||
return castlingMoves;
|
||||
}
|
||||
|
||||
// Check kingside castling
|
||||
CastlingMove kingsideCastling = getCastlingMove(4, kingRow, 6, kingRow);
|
||||
if (isCastlingValid(kingsideCastling)) {
|
||||
castlingMoves.add(new Position(6, kingRow));
|
||||
}
|
||||
|
||||
// Check queenside castling
|
||||
CastlingMove queensideCastling = getCastlingMove(4, kingRow, 2, kingRow);
|
||||
if (isCastlingValid(queensideCastling)) {
|
||||
castlingMoves.add(new Position(2, kingRow));
|
||||
}
|
||||
|
||||
return castlingMoves;
|
||||
}
|
||||
|
||||
public boolean isKingInCheck(boolean isWhiteKing) {
|
||||
// Find the king's position
|
||||
Piece king = null;
|
||||
for (Piece p : board.getPieces()) {
|
||||
if (p.getType() == PieceType.King && p.isWhite() == isWhiteKing) {
|
||||
king = p;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (king == null) return false;
|
||||
|
||||
return checkIfKingUnderAttack(isWhiteKing, king);
|
||||
}
|
||||
|
||||
private boolean checkIfKingUnderAttack(boolean isWhiteKing, Piece king) {
|
||||
// Check if any opponent piece can attack the king
|
||||
for (Piece p : board.getPieces()) {
|
||||
if (p.isWhite() == isWhiteKing) continue; // Skip pieces of same color
|
||||
|
||||
// Get raw moves without check validation
|
||||
List<Position> attackMoves = getValidDestinations(p);
|
||||
|
||||
// If any piece can move to king's position, king is in check
|
||||
for (Position pos : attackMoves) {
|
||||
if (pos.x == king.getX() && pos.y == king.getY()) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private List<Position> getValidDestinations(Piece piece) {
|
||||
List<Position> moves = new ArrayList<>();
|
||||
|
||||
switch (piece.getType()) {
|
||||
case Pawn:
|
||||
addPawnMoves(moves, piece);
|
||||
break;
|
||||
case Rook:
|
||||
addRookMoves(moves, piece);
|
||||
break;
|
||||
case Knight:
|
||||
addKnightMoves(moves, piece);
|
||||
break;
|
||||
case Bishop:
|
||||
addBishopMoves(moves, piece);
|
||||
break;
|
||||
case Queen:
|
||||
addRookMoves(moves, piece);
|
||||
addBishopMoves(moves, piece);
|
||||
break;
|
||||
case King:
|
||||
addKingMoves(moves, piece);
|
||||
break;
|
||||
}
|
||||
|
||||
return moves;
|
||||
}
|
||||
|
||||
private void addPawnMoves(List<Position> validMoves, Piece piece) {
|
||||
int x = piece.getX();
|
||||
int y = piece.getY();
|
||||
boolean isWhite = piece.isWhite();
|
||||
|
||||
int direction = isWhite ? -1 : 1;
|
||||
|
||||
// Diagonal captures only (for attack patterns)
|
||||
int newY = y + direction;
|
||||
if (newY >= 0 && newY < board.getHeight()) {
|
||||
for (int dx = -1; dx <= 1; dx += 2) {
|
||||
int newX = x + dx;
|
||||
if (newX >= 0 && newX < board.getWidth()) {
|
||||
validMoves.add(new Position(newX, newY));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void addRookMoves(List<Position> validMoves, Piece piece) {
|
||||
int x = piece.getX();
|
||||
int y = piece.getY();
|
||||
boolean isWhite = piece.isWhite();
|
||||
|
||||
int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
|
||||
|
||||
for (int[] dir : directions) {
|
||||
int dx = dir[0];
|
||||
int dy = dir[1];
|
||||
|
||||
int newX = x + dx;
|
||||
int newY = y + dy;
|
||||
|
||||
while (newX >= 0 && newX < board.getWidth() && newY >= 0 && newY < board.getHeight()) {
|
||||
validMoves.add(new Position(newX, newY));
|
||||
|
||||
Piece targetPiece = board.getPieceAt(newX, newY);
|
||||
if (targetPiece != null) {
|
||||
break; // Cannot move beyond a piece
|
||||
}
|
||||
|
||||
newX += dx;
|
||||
newY += dy;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void addKnightMoves(List<Position> validMoves, Piece piece) {
|
||||
int x = piece.getX();
|
||||
int y = piece.getY();
|
||||
|
||||
int[][] knightMoves = {
|
||||
{-2, -1}, {-2, 1}, {-1, -2}, {-1, 2},
|
||||
{1, -2}, {1, 2}, {2, -1}, {2, 1}
|
||||
};
|
||||
|
||||
for (int[] move : knightMoves) {
|
||||
int newX = x + move[0];
|
||||
int newY = y + move[1];
|
||||
|
||||
if (newX >= 0 && newX < board.getWidth() && newY >= 0 && newY < board.getHeight()) {
|
||||
validMoves.add(new Position(newX, newY));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void addBishopMoves(List<Position> validMoves, Piece piece) {
|
||||
int x = piece.getX();
|
||||
int y = piece.getY();
|
||||
|
||||
int[][] directions = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
|
||||
|
||||
for (int[] dir : directions) {
|
||||
int dx = dir[0];
|
||||
int dy = dir[1];
|
||||
|
||||
int newX = x + dx;
|
||||
int newY = y + dy;
|
||||
|
||||
while (newX >= 0 && newX < board.getWidth() && newY >= 0 && newY < board.getHeight()) {
|
||||
validMoves.add(new Position(newX, newY));
|
||||
|
||||
Piece targetPiece = board.getPieceAt(newX, newY);
|
||||
if (targetPiece != null) {
|
||||
break; // Cannot move beyond a piece
|
||||
}
|
||||
|
||||
newX += dx;
|
||||
newY += dy;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void addKingMoves(List<Position> validMoves, Piece piece) {
|
||||
int x = piece.getX();
|
||||
int y = piece.getY();
|
||||
|
||||
for (int dx = -1; dx <= 1; dx++) {
|
||||
for (int dy = -1; dy <= 1; dy++) {
|
||||
if (dx == 0 && dy == 0) continue;
|
||||
|
||||
int newX = x + dx;
|
||||
int newY = y + dy;
|
||||
|
||||
if (newX >= 0 && newX < board.getWidth() && newY >= 0 && newY < board.getHeight()) {
|
||||
validMoves.add(new Position(newX, newY));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue