523 lines
16 KiB
Java
523 lines
16 KiB
Java
package dev.kske.chess.board;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import dev.kske.chess.board.Log.LoggedMove;
|
|
import dev.kske.chess.board.Piece.Color;
|
|
import dev.kske.chess.board.Piece.Type;
|
|
|
|
/**
|
|
* Project: <strong>Chess</strong><br>
|
|
* File: <strong>Board.java</strong><br>
|
|
* Created: <strong>01.07.2019</strong><br>
|
|
* Author: <strong>Kai S. K. Engelbart</strong>
|
|
*/
|
|
public class Board implements Cloneable {
|
|
|
|
private Piece[][] boardArr;
|
|
private Map<Color, Position> kingPos;
|
|
private Map<Color, Map<Type, Boolean>> castlingRights;
|
|
private Log log;
|
|
|
|
private static final Map<Type, int[][]> positionScores;
|
|
|
|
static {
|
|
positionScores = new HashMap<>();
|
|
positionScores.put(Type.KING,
|
|
new int[][] { new int[] { -3, -4, -4, -5, -5, -4, -4, -3 },
|
|
new int[] { -3, -4, -4, -5, -4, -4, -4, -3 }, new int[] { -3, -4, -4, -5, -4, -4, -4, -3 },
|
|
new int[] { -3, -4, -4, -5, -4, -4, -4, -3 }, new int[] { -2, -3, -3, -2, -2, -2, -2, -1 },
|
|
new int[] { -1, -2, -2, -2, -2, -2, -2, -1 }, new int[] { 2, 2, 0, 0, 0, 0, 2, 2 },
|
|
new int[] { 2, 3, 1, 0, 0, 1, 3, 2 } });
|
|
positionScores.put(Type.QUEEN,
|
|
new int[][] { new int[] { -2, -1, -1, -1, -1, -1, -1, -2 }, new int[] { -1, 0, 0, 0, 0, 0, 0, -1 },
|
|
new int[] { -1, 0, 1, 1, 1, 1, 0, -1 }, new int[] { -1, 0, 1, 1, 1, 1, 0, -1 },
|
|
new int[] { 0, 0, 1, 1, 1, 1, 0, -1 }, new int[] { -1, 1, 1, 1, 1, 1, 0, -1 },
|
|
new int[] { -1, 0, 1, 0, 0, 0, 0, -1 }, new int[] { -2, -1, -1, -1, -1, -1, -1, -2 } });
|
|
positionScores.put(Type.ROOK,
|
|
new int[][] { new int[] { 0, 0, 0, 0, 0, 0, 0, 0 }, new int[] { 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
new int[] { -1, 0, 0, 0, 0, 0, 0, -1 }, new int[] { -1, 0, 0, 0, 0, 0, 0, -1 },
|
|
new int[] { -1, 0, 0, 0, 0, 0, 0, -1 }, new int[] { -1, 0, 0, 0, 0, 0, 0, -1 },
|
|
new int[] { -1, 0, 0, 0, 0, 0, 0, -1 }, new int[] { 0, 0, 0, 1, 1, 0, 0, 0 } });
|
|
positionScores.put(Type.KNIGHT,
|
|
new int[][] { new int[] { -5, -4, -3, -3, -3, -3, -4, -5 }, new int[] { -4, -2, 0, 0, 0, 0, -2, -4 },
|
|
new int[] { -3, 0, 1, 2, 2, 1, 0, -3 }, new int[] { -3, 1, 2, 2, 2, 2, 1, -3 },
|
|
new int[] { -3, 0, 2, 2, 2, 2, 0, -1 }, new int[] { -3, 1, 1, 2, 2, 1, 1, -3 },
|
|
new int[] { -4, -2, 0, 1, 1, 0, -2, -4 }, new int[] { -5, -4, -3, -3, -3, -3, -4, -5 } });
|
|
positionScores.put(Type.BISHOP,
|
|
new int[][] { new int[] { -2, -1, -1, -1, -1, -1, -1, 2 }, new int[] { -1, 0, 0, 0, 0, 0, 0, -1 },
|
|
new int[] { -1, 0, 1, 1, 1, 1, 0, -1 }, new int[] { -1, 1, 1, 1, 1, 1, 1, -1 },
|
|
new int[] { -1, 0, 1, 1, 1, 1, 0, -1 }, new int[] { -1, 1, 1, 1, 1, 1, 1, -1 },
|
|
new int[] { -1, 1, 0, 0, 0, 0, 1, -1 }, new int[] { -2, -1, -1, -1, -1, -1, -1, -2 } });
|
|
positionScores.put(Type.PAWN,
|
|
new int[][] { new int[] { 0, 0, 0, 0, 0, 0, 0, 0 }, new int[] { 5, 5, 5, 5, 5, 5, 5, 5 },
|
|
new int[] { 1, 1, 2, 3, 3, 2, 1, 1 }, new int[] { 0, 0, 1, 3, 3, 1, 0, 0 },
|
|
new int[] { 0, 0, 0, 2, 2, 0, 0, 0 }, new int[] { 0, 0, -1, 0, 0, -1, 0, 0 },
|
|
new int[] { 0, 1, 1, -2, -2, 1, 1, 0 }, new int[] { 0, 0, 0, 0, 0, 0, 0, 0 } });
|
|
}
|
|
|
|
public Board() {
|
|
boardArr = new Piece[8][8];
|
|
kingPos = new HashMap<>();
|
|
castlingRights = new HashMap<>();
|
|
log = new Log();
|
|
initializeDefaultPositions();
|
|
}
|
|
|
|
/**
|
|
* Moves a piece across the board if the move is legal.
|
|
*
|
|
* @param move The move to execute
|
|
* @return {@code true}, if the attempted move was legal and thus executed
|
|
*/
|
|
public boolean attemptMove(Move move) {
|
|
Piece piece = getPos(move);
|
|
if (piece == null || !piece.isValidMove(move)) return false;
|
|
else {
|
|
// Set type after validation
|
|
if (move.type == Move.Type.UNKNOWN) move.type = Move.Type.NORMAL;
|
|
|
|
// Move piece
|
|
move(move);
|
|
|
|
// Revert move if it caused a check for its team
|
|
if (checkCheck(piece.getColor())) {
|
|
revert();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Moves a piece across the board without checking if the move is legal.
|
|
*
|
|
* @param move The move to execute
|
|
* @return The captures piece, or null if the move's destination was empty
|
|
*/
|
|
public void move(Move move) {
|
|
Piece piece = getPos(move);
|
|
Piece capturePiece = getDest(move);
|
|
|
|
switch (move.type) {
|
|
case PAWN_PROMOTION:
|
|
setPos(move, null);
|
|
// TODO: Select promotion
|
|
setDest(move, new Queen(piece.getColor(), this));
|
|
break;
|
|
case EN_PASSANT:
|
|
setDest(move, piece);
|
|
setPos(move, null);
|
|
boardArr[move.dest.x][move.dest.y - move.ySign] = null;
|
|
break;
|
|
case CASTLING:
|
|
// Move the king
|
|
setDest(move, piece);
|
|
setPos(move, null);
|
|
|
|
// Move the rook
|
|
Move rookMove = move.dest.x == 6 ? new Move(7, move.pos.y, 5, move.pos.y) // Kingside
|
|
: new Move(0, move.pos.y, 3, move.pos.y); // Queenside
|
|
|
|
// Move the rook
|
|
setDest(rookMove, getPos(rookMove));
|
|
setPos(rookMove, null);
|
|
|
|
getDest(rookMove).incMoveCounter();
|
|
break;
|
|
case UNKNOWN:
|
|
System.err.printf("Move of unknown type %s found!%n", move);
|
|
case NORMAL:
|
|
setDest(move, piece);
|
|
setPos(move, null);
|
|
break;
|
|
default:
|
|
System.err.printf("Move %s of unimplemented type found!%n", move);
|
|
}
|
|
|
|
// Increment move counter
|
|
getDest(move).incMoveCounter();
|
|
|
|
// Update the king's position if the moved piece is the king and castling
|
|
// availability
|
|
if (piece.getType() == Type.KING) kingPos.put(piece.getColor(), move.dest);
|
|
|
|
// Update log
|
|
log.add(move, capturePiece, piece.getType() == Type.PAWN);
|
|
|
|
updateCastlingRights();
|
|
}
|
|
|
|
/**
|
|
* Reverts the last move.
|
|
*/
|
|
public void revert() {
|
|
LoggedMove loggedMove = log.getLast();
|
|
Move move = loggedMove.move;
|
|
Piece capturedPiece = loggedMove.capturedPiece;
|
|
|
|
switch (move.type) {
|
|
case PAWN_PROMOTION:
|
|
setPos(move, new Pawn(getDest(move).getColor(), this));
|
|
setDest(move, capturedPiece);
|
|
break;
|
|
case EN_PASSANT:
|
|
setPos(move, getDest(move));
|
|
setDest(move, null);
|
|
boardArr[move.dest.x][move.dest.y - move.ySign] = new Pawn(getPos(move).getColor().opposite(), this);
|
|
break;
|
|
case CASTLING:
|
|
// Move the king
|
|
setPos(move, getDest(move));
|
|
setDest(move, null);
|
|
|
|
// Move the rook
|
|
Move rookMove = move.dest.x == 6 ? new Move(5, move.pos.y, 7, move.pos.y) // Kingside
|
|
: new Move(3, move.pos.y, 0, move.pos.y); // Queenside
|
|
setDest(rookMove, getPos(rookMove));
|
|
setPos(rookMove, null);
|
|
|
|
getDest(rookMove).decMoveCounter();
|
|
break;
|
|
case UNKNOWN:
|
|
System.err.printf("Move of unknown type %s found!%n", move);
|
|
case NORMAL:
|
|
setPos(move, getDest(move));
|
|
setDest(move, capturedPiece);
|
|
break;
|
|
default:
|
|
System.err.printf("Move %s of unimplemented type found!%n", move);
|
|
}
|
|
|
|
// Decrement move counter
|
|
getPos(move).decMoveCounter();
|
|
|
|
// Update the king's position if the moved piece is the king
|
|
if (getPos(move).getType() == Type.KING) kingPos.put(getPos(move).getColor(), move.pos);
|
|
|
|
// Update log
|
|
log.removeLast();
|
|
|
|
updateCastlingRights();
|
|
}
|
|
|
|
private void updateCastlingRights() {
|
|
// White
|
|
if (new Position(4, 7).equals(kingPos.get(Color.WHITE))) {
|
|
final King king = (King) get(kingPos.get(Color.WHITE));
|
|
castlingRights.get(Color.WHITE).put(Type.KING, king.canCastleKingside());
|
|
castlingRights.get(Color.WHITE).put(Type.QUEEN, king.canCastleQueenside());
|
|
} else {
|
|
castlingRights.get(Color.WHITE).put(Type.KING, false);
|
|
castlingRights.get(Color.WHITE).put(Type.QUEEN, false);
|
|
}
|
|
|
|
// Black
|
|
if (new Position(4, 0).equals(kingPos.get(Color.BLACK))) {
|
|
final King king = (King) get(kingPos.get(Color.BLACK));
|
|
castlingRights.get(Color.BLACK).put(Type.KING, king.canCastleKingside());
|
|
castlingRights.get(Color.BLACK).put(Type.QUEEN, king.canCastleQueenside());
|
|
} else {
|
|
castlingRights.get(Color.BLACK).put(Type.KING, false);
|
|
castlingRights.get(Color.BLACK).put(Type.QUEEN, false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generated every legal move for one color
|
|
*
|
|
* @param color The color to generate the moves for
|
|
* @return A list of all legal moves
|
|
*/
|
|
public List<Move> getMoves(Color color) {
|
|
List<Move> moves = new ArrayList<>();
|
|
for (int i = 0; i < 8; i++)
|
|
for (int j = 0; j < 8; j++)
|
|
if (boardArr[i][j] != null && boardArr[i][j].getColor() == color)
|
|
moves.addAll(boardArr[i][j].getMoves(new Position(i, j)));
|
|
return moves;
|
|
}
|
|
|
|
public List<Move> getMoves(Position pos) {
|
|
return get(pos).getMoves(pos);
|
|
}
|
|
|
|
/**
|
|
* Checks, if the king is in check.
|
|
*
|
|
* @param color The color of the king to check
|
|
* @return {@code true}, if the king is in check
|
|
*/
|
|
public boolean checkCheck(Color color) {
|
|
for (int i = 0; i < 8; i++)
|
|
for (int j = 0; j < 8; j++) {
|
|
Position pos = new Position(i, j);
|
|
if (get(pos) != null && get(pos).getColor() != color
|
|
&& get(pos).isValidMove(new Move(pos, kingPos.get(color))))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks, if the king is in checkmate.
|
|
* This requires the king to already be in check!
|
|
*
|
|
* @param color The color of the king to check
|
|
* @return {@code true}, if the king is in checkmate
|
|
*/
|
|
public boolean checkCheckmate(Color color) {
|
|
// Return false immediately if the king can move
|
|
if (!getMoves(kingPos.get(color)).isEmpty()) return false;
|
|
else {
|
|
for (Move move : getMoves(color)) {
|
|
move(move);
|
|
boolean check = checkCheck(color);
|
|
revert();
|
|
if (!check) return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public GameState getGameEventType(Color color) {
|
|
return checkCheck(color) ? checkCheckmate(color) ? GameState.CHECKMATE : GameState.CHECK
|
|
: getMoves(color).isEmpty() || log.getLast().halfmoveClock >= 50 ? GameState.STALEMATE
|
|
: GameState.NORMAL;
|
|
}
|
|
|
|
/**
|
|
* Evaluated the board.
|
|
*
|
|
* @param color The color to evaluate for
|
|
* @return An positive number representing how good the position is
|
|
*/
|
|
public int evaluate(Color color) {
|
|
int score = 0;
|
|
for (int i = 0; i < 8; i++)
|
|
for (int j = 0; j < 8; j++)
|
|
if (boardArr[i][j] != null && boardArr[i][j].getColor() == color) {
|
|
switch (boardArr[i][j].getType()) {
|
|
case QUEEN:
|
|
score += 90;
|
|
break;
|
|
case ROOK:
|
|
score += 50;
|
|
break;
|
|
case KNIGHT:
|
|
score += 30;
|
|
break;
|
|
case BISHOP:
|
|
score += 30;
|
|
break;
|
|
case PAWN:
|
|
score += 10;
|
|
break;
|
|
}
|
|
if (positionScores.containsKey(boardArr[i][j].getType()))
|
|
score += positionScores.get(boardArr[i][j].getType())[i][color == Color.WHITE ? j : 7 - j];
|
|
}
|
|
return score;
|
|
}
|
|
|
|
/**
|
|
* Initialized the board array with the default chess pieces and positions.
|
|
*/
|
|
public void initializeDefaultPositions() {
|
|
// Initialize pawns
|
|
for (int i = 0; i < 8; i++) {
|
|
boardArr[i][1] = new Pawn(Color.BLACK, this);
|
|
boardArr[i][6] = new Pawn(Color.WHITE, this);
|
|
}
|
|
|
|
// Initialize kings
|
|
boardArr[4][0] = new King(Color.BLACK, this);
|
|
boardArr[4][7] = new King(Color.WHITE, this);
|
|
|
|
// Initialize king position objects
|
|
kingPos.put(Color.BLACK, new Position(4, 0));
|
|
kingPos.put(Color.WHITE, new Position(4, 7));
|
|
|
|
// Initialize queens
|
|
boardArr[3][0] = new Queen(Color.BLACK, this);
|
|
boardArr[3][7] = new Queen(Color.WHITE, this);
|
|
|
|
// Initialize rooks
|
|
boardArr[0][0] = new Rook(Color.BLACK, this);
|
|
boardArr[0][7] = new Rook(Color.WHITE, this);
|
|
boardArr[7][0] = new Rook(Color.BLACK, this);
|
|
boardArr[7][7] = new Rook(Color.WHITE, this);
|
|
|
|
// Initialize knights
|
|
boardArr[1][0] = new Knight(Color.BLACK, this);
|
|
boardArr[1][7] = new Knight(Color.WHITE, this);
|
|
boardArr[6][0] = new Knight(Color.BLACK, this);
|
|
boardArr[6][7] = new Knight(Color.WHITE, this);
|
|
|
|
// Initialize bishops
|
|
boardArr[2][0] = new Bishop(Color.BLACK, this);
|
|
boardArr[2][7] = new Bishop(Color.WHITE, this);
|
|
boardArr[5][0] = new Bishop(Color.BLACK, this);
|
|
boardArr[5][7] = new Bishop(Color.WHITE, this);
|
|
|
|
// Clear all other tiles
|
|
for (int i = 0; i < 8; i++)
|
|
for (int j = 2; j < 6; j++)
|
|
boardArr[i][j] = null;
|
|
|
|
// Initialize castling rights
|
|
castlingRights.clear();
|
|
Map<Type, Boolean> whiteCastling = new HashMap<>(), blackCastling = new HashMap<>();
|
|
whiteCastling.put(Type.KING, true);
|
|
whiteCastling.put(Type.QUEEN, true);
|
|
blackCastling.put(Type.KING, true);
|
|
blackCastling.put(Type.QUEEN, true);
|
|
castlingRights.put(Color.WHITE, whiteCastling);
|
|
castlingRights.put(Color.BLACK, blackCastling);
|
|
|
|
log.reset();
|
|
}
|
|
|
|
/**
|
|
* @return A new instance of this class with a shallow copy of both
|
|
* {@code kingPos} and {code boardArr}
|
|
*/
|
|
@Override
|
|
public Object clone() {
|
|
Board board = null;
|
|
try {
|
|
board = (Board) super.clone();
|
|
} catch (CloneNotSupportedException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
board.boardArr = new Piece[8][8];
|
|
for (int i = 0; i < 8; i++)
|
|
for (int j = 0; j < 8; j++) {
|
|
if (boardArr[i][j] == null) continue;
|
|
board.boardArr[i][j] = (Piece) boardArr[i][j].clone();
|
|
board.boardArr[i][j].board = board;
|
|
}
|
|
|
|
board.kingPos = new HashMap<>();
|
|
board.kingPos.putAll(kingPos);
|
|
board.log = (Log) log.clone();
|
|
|
|
return board;
|
|
}
|
|
|
|
/**
|
|
* @return A FEN string representing the board
|
|
*/
|
|
public String toFEN() {
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
// Piece placement (from white's perspective)
|
|
for (int i = 0; i < 8; i++) {
|
|
int emptyCount = 0;
|
|
for (int j = 0; j < 8; j++)
|
|
if (boardArr[j][i] == null) ++emptyCount;
|
|
else {
|
|
if (emptyCount != 0) {
|
|
sb.append(emptyCount);
|
|
emptyCount = 0;
|
|
}
|
|
char piece;
|
|
switch (boardArr[j][i].getType()) {
|
|
case KING:
|
|
piece = 'K';
|
|
break;
|
|
case QUEEN:
|
|
piece = 'Q';
|
|
break;
|
|
case ROOK:
|
|
piece = 'R';
|
|
break;
|
|
case KNIGHT:
|
|
piece = 'N';
|
|
break;
|
|
case BISHOP:
|
|
piece = 'B';
|
|
break;
|
|
case PAWN:
|
|
piece = 'P';
|
|
break;
|
|
default:
|
|
piece = '-';
|
|
}
|
|
if (boardArr[j][i].getColor() == Color.BLACK) piece = Character.toLowerCase(piece);
|
|
sb.append(piece);
|
|
}
|
|
if (emptyCount != 0) sb.append(emptyCount);
|
|
if (i < 7) sb.append('/');
|
|
}
|
|
|
|
// Active color
|
|
sb.append(" " + log.getActiveColor().firstChar());
|
|
|
|
sb.append(' ');
|
|
StringBuilder castlingSb = new StringBuilder();
|
|
if (castlingRights.get(Color.WHITE).get(Type.KING)) castlingSb.append('K');
|
|
if (castlingRights.get(Color.WHITE).get(Type.QUEEN)) castlingSb.append('Q');
|
|
if (castlingRights.get(Color.BLACK).get(Type.KING)) castlingSb.append('k');
|
|
if (castlingRights.get(Color.BLACK).get(Type.QUEEN)) castlingSb.append('q');
|
|
if (castlingSb.length() == 0) sb.append("-");
|
|
sb.append(castlingSb);
|
|
|
|
final LoggedMove lastMove = log.getLast();
|
|
|
|
// En passant availabillity
|
|
sb.append(" " + (lastMove == null || lastMove.enPassant == null ? "-" : lastMove.enPassant.toSAN()));
|
|
|
|
// Halfmove clock
|
|
sb.append(" " + String.valueOf(lastMove == null ? 0 : lastMove.halfmoveClock));
|
|
|
|
// Fullmove counter
|
|
sb.append(" " + String.valueOf(lastMove == null ? 1 : lastMove.fullmoveCounter));
|
|
|
|
return sb.toString();
|
|
}
|
|
|
|
public Piece get(Position pos) {
|
|
return boardArr[pos.x][pos.y];
|
|
}
|
|
|
|
public void set(Position pos, Piece piece) {
|
|
boardArr[pos.x][pos.y] = piece;
|
|
}
|
|
|
|
public Piece getPos(Move move) {
|
|
return get(move.pos);
|
|
}
|
|
|
|
public Piece getDest(Move move) {
|
|
return get(move.dest);
|
|
}
|
|
|
|
public void setPos(Move move, Piece piece) {
|
|
set(move.pos, piece);
|
|
}
|
|
|
|
public void setDest(Move move, Piece piece) {
|
|
set(move.dest, piece);
|
|
}
|
|
|
|
/**
|
|
* @return The board array
|
|
*/
|
|
public Piece[][] getBoardArr() { return boardArr; }
|
|
|
|
/**
|
|
* @return The active color for the next move
|
|
*/
|
|
public Color getActiveColor() { return log.getActiveColor(); }
|
|
|
|
/**
|
|
* @return The current en passant square, or null if there isn't any
|
|
*/
|
|
public Position getEnPassantSquare() { return log.getLast() == null ? null : log.getLast().enPassant; }
|
|
}
|