/**
* Rates a board by the position advantage
*
* @param b
* @param color
* @return
*/
private int h2(Board b, char color) {
int kingVal = 2;
int result = 0;
int[][] posVals = {
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2}
};
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
Piece p = b.getPiece(i, j);
int pVal = 0;
if (p.getColor() == color) pVal = posVals[i][j];
else if (p.getColor() != '-') pVal = -posVals[i][j];
if (p.isKing()) pVal = pVal * kingVal;
result += pVal;
}
}
return result;
}
public void undoLastMove() {
// Check that we have a move to undo
if (moves.isEmpty()) {
throw new InternalError("No move available to undo");
}
final Move lastMove = getLastMove();
final Point from = lastMove.getFrom();
final Point to = lastMove.getTo();
final Piece piece = lastMove.getPiece();
squares[from.getX()][from.getY()].setPiece(piece);
if (lastMove.isLeftCastling()) {
squares[to.getX()][to.getY()].setPiece(null);
if (piece.getColor() == Color.W) {
setPiece(Piece.WHITE_ROOK, King.W_LEFT_ROOK);
setPiece(null, to.incrementX(1));
} else {
setPiece(Piece.BLACK_ROOK, King.B_LEFT_ROOK);
setPiece(null, to.incrementX(1));
}
} else if (lastMove.isRightCastling()) {
squares[to.getX()][to.getY()].setPiece(null);
if (piece.getColor() == Color.W) {
setPiece(Piece.WHITE_ROOK, King.W_RIGHT_ROOK);
setPiece(null, to.decrementX(1));
} else {
setPiece(Piece.BLACK_ROOK, King.B_RIGHT_ROOK);
setPiece(null, to.decrementX(1));
}
} else {
final Piece captured = lastMove.getCaptured();
// Undoing an en passant move?
if (lastMove.isEnPassant()) {
if (captured.getColor() == Color.B) {
squares[to.getX()][to.getY() - 1].setPiece(captured);
} else {
squares[to.getX()][to.getY() + 1].setPiece(captured);
}
squares[to.getX()][to.getY()].setPiece(null);
} else {
squares[to.getX()][to.getY()].setPiece(captured);
}
// Keep track of the kings
if (piece == WHITE_KING) {
whiteKing = squares[from.getX()][from.getY()];
} else if (piece == BLACK_KING) {
blackKing = squares[from.getX()][from.getY()];
}
}
// Remove move from history
moves.remove(moves.size() - 1);
}
public boolean validTake(Point start, Point end) {
Piece piece = b.get(start);
Piece ending = b.get(end);
if (ending != null
&& piece.validCapture(start, end)
&& checkIfPathIsClear(start, end)
&& piece.getColor() != ending.getColor()) {
return true;
}
return false;
}
public void doMove(Move move) {
final Point from = move.getFrom();
final Point to = move.getTo();
final Piece piece = move.getPiece();
// Carry out the move on the board
squares[from.getX()][from.getY()].setPiece(null);
move.setCaptured(squares[to.getX()][to.getY()].getPiece());
squares[to.getX()][to.getY()].setPiece(piece);
// Keep track of the kings
if (piece == WHITE_KING) {
whiteKing = squares[to.getX()][to.getY()];
} else if (piece == BLACK_KING) {
blackKing = squares[to.getX()][to.getY()];
}
// Check for castling first
if (move.isLeftCastling()) {
if (piece.getColor() == Color.W) {
setPiece(null, King.W_LEFT_ROOK);
setPiece(Piece.WHITE_ROOK, to.incrementX(1));
} else {
setPiece(null, King.B_LEFT_ROOK);
setPiece(Piece.BLACK_ROOK, to.incrementX(1));
}
} else if (move.isRightCastling()) {
if (piece.getColor() == Color.W) {
setPiece(null, King.W_RIGHT_ROOK);
setPiece(Piece.WHITE_ROOK, to.decrementX(1));
} else {
setPiece(null, King.B_RIGHT_ROOK);
setPiece(Piece.BLACK_ROOK, to.decrementX(1));
}
} else {
// Check for pawn promotions
if (piece.isPromoted(to)) {
setPiece(piece.getColor().getQueen(), to);
move.setPromoted(true);
}
// En passant?
final Move lastMove = getLastMove();
if (move.isEnPassantAllowed(lastMove)) {
final Point lastTo = lastMove.getTo();
move.setEnPassant(true);
move.setCaptured(squares[lastTo.getX()][lastTo.getY()].getPiece());
squares[lastTo.getX()][lastTo.getY()].setPiece(null);
}
}
// Record last move
moves.add(move);
}
public boolean takePiece(Point startLocation, Point endLocation) {
Piece piece = b.get(startLocation);
Piece ending = b.get(endLocation);
if (piece.validCapture(startLocation, endLocation)
&& checkIfPathIsClear(startLocation, endLocation)
&& piece.getColor() != ending.getColor()) {
b.remove(endLocation);
b.put(endLocation, b.get(startLocation));
b.remove(startLocation);
piece.setHasNotMoved(false);
return true;
}
return false;
}
/**
* Rates a board by the number of kings.
*
* @param b
* @return
*/
private int h1(Board b, char color) {
int result = 0;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
Piece p = b.getPiece(i, j);
if (p.getColor() == color) {
result++;
if (p.isKing()) result++;
} else if (p.getColor() != '-') {
result--;
if (p.isKing()) result--;
}
}
}
return result;
}
/**
* Do the Jump, removing the piece from x1, y1 and setting the piece in x2, y2. Remove the piece
* from captureX, captureY as well. If the piece is now on their "King's Row", then promote the
* piece should be promoted to a King
*/
public void execute(final Jump jump) {
// CHECK IF ALL OF THEM ON BOARD
if (isOnBoard(jump.getX1(), jump.getX2())
&& isOnBoard(jump.getY1(), jump.getY2())
&& isOnBoard(jump.getCaptureX(), jump.getCaptureY())) {
// check if landing square is empty
if (isEmptySquare(jump.getY1(), jump.getY2())) {
Piece piece = getPiece(jump.getY1(), jump.getX1());
// check if capture piece is enemy color
if (getPiece(jump.getCaptureY(), jump.getCaptureX()).isEnemyColor(piece.getColor())) {
if (Piece.WHITE_MAN.equals(piece)) {
if (jump.getY2() == 7) {
piece = Piece.WHITE_KING;
}
} else if (Piece.RED_MAN.equals(piece)) {
if (jump.getY2() == 0) {
piece = Piece.RED_KING;
}
}
setPiece(jump.getY2(), jump.getX2(), piece);
removePiece(jump.getCaptureY(), jump.getCaptureX());
removePiece(jump.getY1(), jump.getX1());
}
}
}
}
/** Determines whether the king can be captured by the player with the move. */
public boolean isKingLeftInCheck() {
MoveLogic attacksKingLogic = new MoveAttacksKingLogic();
HashSet<Move> attackingMoves;
PieceColor colorToMove = this.getColorToMove();
int kx = -1; // If search succeeds, these should be set to "real" values
int ky = -1;
squareloop:
for (int j = 0; j < Chess.BOARD_SIZE; j++) {
for (int i = 0; i < Chess.BOARD_SIZE; i++) {
Piece pieceHere = this.getPieceAt(new Square(i, j));
if (pieceHere.getType() == PieceType.KING && pieceHere.getColor() == colorToMove.invert()) {
kx = i;
ky = j;
break squareloop;
}
}
}
assert ((kx != -1) || (ky != -1))
: "Unexpected search failure, inconsistent state. King not found.";
Square kingSquare = new Square(kx, ky);
attackingMoves = possibleMovesWhichEndAt(kingSquare);
for (Move move : attackingMoves) {
if (attacksKingLogic.isLegal(this, move)) {
return true;
}
}
return false;
}
public ArrayList<Piece> getPiecesOfType(PieceTypes.Color color) {
ArrayList<Piece> ret = new ArrayList<Piece>();
for (Piece p : pieces) {
if (p.getColor() == color) {
ret.add(p);
}
}
return ret;
}
/**
* Checks whether there is a piece at the specified location that is not marked as 'captured' and
* has the specified color.
*
* @param color one of Piece.COLOR_..
* @param row one of Piece.ROW_..
* @param column on of Piece.COLUMN_..
* @return true, if the location contains a not-captured piece of the specified color
*/
private boolean isNonCapturedPieceAtLocation(int color, int row, int column) {
for (Piece piece : this.pieces) {
if (piece.getRow() == row
&& piece.getColumn() == column
&& piece.isCaptured() == false
&& piece.getColor() == color) {
return true;
}
}
return false;
}
/**
* Determines whether the piece at the given square can be moved, i.e. that there is actually a
* piece there and that its color matches the color to move.
*/
public boolean isMovablePieceAtSquare(Square startSquare) {
final Piece pieceToMove = getPieceAt(startSquare);
// There should be a piece on the starting square
if (pieceToMove.equals(Piece.NONE)) {
return false;
}
// The color of the piece being moved must be the color
// of the player to move
return (pieceToMove.getColor() == getColorToMove());
}
private int h4(Board b, char color) {
int result = 0;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
Piece p = b.getPiece(i, j);
if (p.getColor() == color && p.isKing() == true) {
result++;
}
}
}
return result;
}
private void sendBoardToDisplay(MITrisBoard board, Display2D display, double brightness) {
int width = display.getWidth();
int height = display.getHeight();
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
Piece p = board.getPosition(x, y);
Color c = p == null ? Color.BLACK : p.getColor(board.getLevel(), gameDisplayTime);
float[] hsb = Color.RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue(), new float[3]);
hsb[2] *= brightness;
display.setPixelHSB(x, height - 1 - y, hsb[0], hsb[1], hsb[2]);
}
}
}
/**
* Move piece to the specified location. If the target location is occupied by an opponent piece,
* that piece is marked as 'captured'
*
* @param sourceRow the source row (Piece.ROW_..) of the piece to move
* @param sourceColumn the source column (Piece.COLUMN_..) of the piece to move
* @param targetRow the target row (Piece.ROW_..)
* @param targetColumn the target column (Piece.COLUMN_..)
*/
public void movePiece(int sourceRow, int sourceColumn, int targetRow, int targetColumn) {
Piece piece = getNonCapturedPieceAtLocation(sourceRow, sourceColumn);
if (piece == null) {
throw new IllegalArgumentException("No piece at source location");
}
if (piece.getColor() == Piece.COLOR_WHITE && this.gameState != ChessGame.GAME_STATE_WHITE
|| piece.getColor() == Piece.COLOR_BLACK && this.gameState != ChessGame.GAME_STATE_BLACK) {
throw new IllegalArgumentException("It's not your turn");
}
// check if the move is capturing an opponent piece
int opponentColor =
(piece.getColor() == Piece.COLOR_BLACK ? Piece.COLOR_WHITE : Piece.COLOR_BLACK);
if (isNonCapturedPieceAtLocation(opponentColor, targetRow, targetColumn)) {
Piece opponentPiece = getNonCapturedPieceAtLocation(targetRow, targetColumn);
opponentPiece.isCaptured(true);
}
piece.setRow(targetRow);
piece.setColumn(targetColumn);
}
/**
* Draw a piece.
*
* @param obj the piece to draw
* @param comp not used
* @param g2 the graphics 2D object to draw with
*/
public void draw(Object obj, Component comp, Graphics2D g2) {
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
Piece piece = (Piece) obj;
Color pieceColor = piece.getColor();
g2.setPaint(pieceColor);
g2.draw(body);
g2.scale(1.0 / GRADIENT_SIZE, 1.0 / GRADIENT_SIZE);
g2.setPaint(
new GradientPaint(
-GRADIENT_SIZE / 4,
-GRADIENT_SIZE / 2,
Color.white,
GRADIENT_SIZE / 4,
GRADIENT_SIZE / 4,
pieceColor));
g2.fill(ATX.createTransformedShape(body));
g2.scale(GRADIENT_SIZE, GRADIENT_SIZE);
}
/**
* Performs the move, and modifies the actual board
*
* @throws IOException
*/
public void performMove(String move, String color, boolean actuallyMove) throws IOException {
int[] moveArray = parseInput(move);
// System.out.println(board[moveArray[0]][moveArray[1]]);
if (board[moveArray[0]][moveArray[1]] == null) {
throw new IOException();
}
if (!board[moveArray[0]][moveArray[1]].getColor().equals(color)) {
throw new IOException();
}
if (board[moveArray[2]][moveArray[3]] != null) {
if (board[moveArray[2]][moveArray[3]].getColor().equals(color)) {
throw new IOException();
}
}
if (board[moveArray[0]][moveArray[1]].validateMove(
board, moveArray[0], moveArray[1], moveArray[2], moveArray[3])) {
// This means the move was valid
if (isInCheck(color)) {
// Because the current player put him/herself in check
// I need to find out what is going to happen to the board in this case
System.out.println("1");
throw new IOException();
}
if (actuallyMove) {
// Switch the two spots on the board because the move was valid
board[moveArray[2]][moveArray[3]] = board[moveArray[0]][moveArray[1]];
board[moveArray[0]][moveArray[1]] = null;
}
if (board[moveArray[2]][moveArray[3]] != null) {
if (board[moveArray[2]][moveArray[3]].getClass().isInstance(new King("white"))) {
if (actuallyMove) {
((King) board[moveArray[2]][moveArray[3]]).hasMoved = true;
}
// This Piece is a King
if (((King) board[moveArray[2]][moveArray[3]]).castled) {
if (moveArray[3] - moveArray[1] == 2) {
board[moveArray[2]][moveArray[3] - 1] = board[moveArray[2]][moveArray[3] + 1];
board[moveArray[2]][moveArray[3] + 1] = null;
} else {
board[moveArray[2]][moveArray[3] + 1] = board[moveArray[2]][moveArray[3] - 1];
board[moveArray[2]][moveArray[3] - 1] = null;
}
((King) board[moveArray[2]][moveArray[3]]).castled = false;
}
}
}
} else {
throw new IOException();
}
// Rules dealing with pawns
if (actuallyMove) {
Piece piece = board[moveArray[2]][moveArray[3]];
// This way it gets toggled the next time it moves
piece.ep_able = false;
if (piece != null) {
if (piece.getClass().isInstance(new Pawn("white"))) {
// The piece is a pawn
piece.hasMoved = true;
// Promotion
Piece replacement;
if (move.split(" ").length < 3) {
move += " s";
}
if (piece.getColor().equals("white")) {
if (moveArray[2] == 7) {
switch (move.split(" ")[2].charAt(0)) {
case 'N':
replacement = new Knight("white");
break;
case 'B':
replacement = new Bishop("white");
break;
default:
replacement = new Queen("white");
break;
}
board[moveArray[2]][moveArray[3]] = replacement;
}
} else {
if (moveArray[2] == 0) {
switch (move.split(" ")[2].charAt(0)) {
case 'N':
replacement = new Knight("black");
break;
case 'B':
replacement = new Bishop("black");
break;
default:
replacement = new Queen("black");
break;
}
board[moveArray[2]][moveArray[3]] = replacement;
}
}
// En passante capture
/*int newCol = moveArray[3];
int newRow = moveArray[2];
if(inSixthRank(color, newRow)){
if(newCol + 1 < 8){
if(board[newRow][newCol + 1] != null){
if(board[newRow][newCol + 1].getClass().isInstance(new Pawn("white"))){
if(board[][].ep_able){
board[][] = null;
}
}
}
}else if(newCol - 1 > 0){
if(board[newRow][newCol - 1] != null){
if(board[newRow][newCol - 1].getClass().isInstance(new Pawn("white"))){
if(board[][].ep_able){
board[][] = null;
}
}
}
}
}*/
}
}
}
}
@Override
public ArrayList<Move> getMoves(Board board) {
ArrayList<Move> movesList = new ArrayList<Move>();
Location newLocation = null;
Location currentLocation = board.getLocation(this);
char column = currentLocation.getCharacter();
int row = currentLocation.getInteger();
int boardLength = 8;
// Down Left
for (int i = 1; i < boardLength; i++) {
newLocation = new Location((char) (column - i), (row - i));
if (board.isValidSquare(newLocation)) {
Piece p = board.getPiece(newLocation);
if (p != null && p.getColor() != this.getColor()) {
movesList.add(new Move(currentLocation, newLocation));
} else if (p == null) {
movesList.add(new Move(currentLocation, newLocation));
}
if (pathIsObstructed(board, currentLocation, newLocation)) break;
}
}
// Down Right
for (int i = 1; i < boardLength; i++) {
newLocation = new Location((char) (column + i), (row - i));
if (board.isValidSquare(newLocation)) {
Piece p = board.getPiece(newLocation);
if (p != null && p.getColor() != this.getColor()) {
movesList.add(new Move(currentLocation, newLocation));
} else if (p == null) {
movesList.add(new Move(currentLocation, newLocation));
}
if (pathIsObstructed(board, currentLocation, newLocation)) break;
}
}
// Up Left
for (int i = 1; i < boardLength; i++) {
newLocation = new Location((char) (column - i), (row + i));
if (board.isValidSquare(newLocation)) {
Piece p = board.getPiece(newLocation);
if (p != null && p.getColor() != this.getColor()) {
movesList.add(new Move(currentLocation, newLocation));
} else if (p == null) {
movesList.add(new Move(currentLocation, newLocation));
}
if (pathIsObstructed(board, currentLocation, newLocation)) break;
}
}
// Up Right
for (int i = 1; i < boardLength; i++) {
newLocation = new Location((char) (column + i), (row + i));
if (board.isValidSquare(newLocation)) {
Piece p = board.getPiece(newLocation);
if (p != null && p.getColor() != this.getColor()) {
movesList.add(new Move(currentLocation, newLocation));
} else if (p == null) {
movesList.add(new Move(currentLocation, newLocation));
}
if (pathIsObstructed(board, currentLocation, newLocation)) break;
}
}
return movesList;
}
/** Returns true if the given Piece has opposite color from this piece. */
public boolean isOppositeColor(Piece piece) {
return this.getColor() != piece.getColor();
}
/** Returns trie of the given Piece has the same color as this Piece. */
public boolean isSameColor(Piece piece) {
return this.getColor() == piece.getColor();
}
/**
* Returns a list of all possible jumps from the piece at (x,y). If there is no piece on that
* square, or the piece cannot make a legal jump then return an empty list
*/
public List<Jump> getJumps(final int x, final int y) {
Piece piece = getPiece(y, x);
if (piece == null) {
return new ArrayList<Jump>(0);
} else {
List<Jump> jumps = new ArrayList<Jump>();
if (Piece.WHITE_MAN.equals(piece)) {
if (isOnBoard(x - 1, y + 1)
&& isOnBoard(x - 2, y + 2)
&& !isEmptySquare(x - 1, y + 1)
&& getPiece(y + 1, x - 1).isEnemyColor(piece.getColor())
&& isEmptySquare(x - 2, y + 2)) {
jumps.add(new Jump(y, x, x - 1, y + 1, x - 2, y + 2));
}
if (isOnBoard(x + 1, y + 1)
&& isOnBoard(x + 2, y + 2)
&& !isEmptySquare(x + 1, y + 1)
&& getPiece(y + 1, x + 1).isEnemyColor(piece.getColor())
&& isEmptySquare(x + 2, y + 2)) {
jumps.add(new Jump(y, x, x + 1, y + 1, x + 2, y + 2));
}
} else if (Piece.RED_MAN.equals(piece)) {
if (isOnBoard(x - 1, y - 1)
&& isOnBoard(x - 2, y - 2)
&& !isEmptySquare(x - 1, y - 1)
&& getPiece(y - 1, x - 1).isEnemyColor(piece.getColor())
&& isEmptySquare(x - 2, y - 2)) {
jumps.add(new Jump(y, x, x - 1, y - 1, x - 2, y - 2));
}
if (isOnBoard(x + 1, y - 1)
&& isOnBoard(x + 2, y - 2)
&& !isEmptySquare(x + 1, y - 1)
&& getPiece(y - 1, x + 1).isEnemyColor(piece.getColor())
&& isEmptySquare(x + 2, y - 2)) {
jumps.add(new Jump(y, x, x + 1, y - 1, x + 2, y - 2));
}
} else {
if (isOnBoard(x - 1, y - 1)
&& isOnBoard(x - 2, y - 2)
&& !isEmptySquare(x - 1, y - 1)
&& getPiece(y - 1, x - 1).isEnemyColor(piece.getColor())
&& isEmptySquare(x - 2, y - 2)) {
jumps.add(new Jump(y, x, x - 1, y - 1, x - 2, y - 2));
}
if (isOnBoard(x + 1, y - 1)
&& isOnBoard(x + 2, y - 2)
&& !isEmptySquare(x + 1, y - 1)
&& getPiece(y - 1, x + 1).isEnemyColor(piece.getColor())
&& isEmptySquare(x + 2, y - 2)) {
jumps.add(new Jump(y, x, x + 1, y - 1, x + 2, y - 2));
}
if (isOnBoard(x - 1, y + 1)
&& isOnBoard(x - 2, y + 2)
&& !isEmptySquare(x - 1, y + 1)
&& getPiece(y + 1, x - 1).isEnemyColor(piece.getColor())
&& isEmptySquare(x - 2, y + 2)) {
jumps.add(new Jump(y, x, x - 1, y + 1, x - 2, y + 2));
}
if (isOnBoard(x + 1, y + 1)
&& isOnBoard(x + 2, y + 2)
&& !isEmptySquare(x + 1, y + 1)
&& getPiece(y + 1, x + 1).isEnemyColor(piece.getColor())
&& isEmptySquare(x + 2, y + 2)) {
jumps.add(new Jump(y, x, x + 1, y + 1, x + 2, y + 2));
}
}
return jumps;
}
}
public static Set<Coordinate> getPossibleCoordinates(
Coordinate startingCoord, Board board, boolean includeThreateningOwnPiece) {
Set<Coordinate> coordinates = new LinkedHashSet<Coordinate>();
Color startingColor = board.getPiece(startingCoord).getColor();
// add entries to the top left
for (int i = 1; i < 8; i++) {
Coordinate coord = startingCoord.transform(-i, +i);
if (!board.contains(coord)) break;
Piece piece = board.getPiece(coord);
if (piece.isNone()) {
coordinates.add(coord);
} else if (includeThreateningOwnPiece && piece.getColor() == startingColor) {
coordinates.add(coord);
break;
} else if (!includeThreateningOwnPiece && piece.getColor() == startingColor) {
break;
} else {
coordinates.add(coord);
break;
}
}
// add entries to the top right
for (int i = 1; i < 8; i++) {
Coordinate coord = startingCoord.transform(+i, +i);
if (!board.contains(coord)) break;
Piece piece = board.getPiece(coord);
if (piece.isNone()) {
coordinates.add(coord);
} else if (includeThreateningOwnPiece && piece.getColor() == startingColor) {
coordinates.add(coord);
break;
} else if (!includeThreateningOwnPiece && piece.getColor() == startingColor) {
break;
} else {
coordinates.add(coord);
break;
}
}
// add entries to the bottom left
for (int i = 1; i < 8; i++) {
Coordinate coord = startingCoord.transform(-i, -i);
if (!board.contains(coord)) break;
Piece piece = board.getPiece(coord);
if (piece.isNone()) {
coordinates.add(coord);
} else if (includeThreateningOwnPiece && piece.getColor() == startingColor) {
coordinates.add(coord);
break;
} else if (!includeThreateningOwnPiece && piece.getColor() == startingColor) {
break;
} else {
coordinates.add(coord);
break;
}
}
// add entries to the bottom right
for (int i = 1; i < 8; i++) {
Coordinate coord = startingCoord.transform(+i, -i);
if (!board.contains(coord)) break;
Piece piece = board.getPiece(coord);
if (piece.isNone()) {
coordinates.add(coord);
} else if (includeThreateningOwnPiece && piece.getColor() == startingColor) {
coordinates.add(coord);
break;
} else if (!includeThreateningOwnPiece && piece.getColor() == startingColor) {
break;
} else {
coordinates.add(coord);
break;
}
}
return coordinates;
}
@Override
public void actionPerformed(ActionEvent e) {
JButton button = (JButton) e.getSource();
Point rv = new Point();
int rank = button.getLocation(rv).y / 100;
int file = button.getLocation(rv).x / 100;
Piece selection = game.gameBoard.spaces[rank][file];
if (selectedPiece != null) {
boolean reachable = false;
Vector<Space> showMoves = BoardLogic.movesOnBoard(game.gameBoard, selectedPiece);
for (int i = 0; i < showMoves.size(); i++) {
if (showMoves.elementAt(i).getFile() == file && showMoves.elementAt(i).getRank() == rank)
reachable = true;
}
if (reachable == false) {
JOptionPane.showMessageDialog(null, "Selected space is unreachable");
JButton moves;
for (int i = 0; i < showMoves.size(); i++) {
moves = jButtonList[showMoves.elementAt(i).getRank()][showMoves.elementAt(i).getFile()];
Border thickBorder = new LineBorder(Color.BLACK, 1);
moves.setBorder(thickBorder);
}
selectedPiece = null;
} else {
game.move.push(
new Step(
selectedPiece.getRank(),
selectedPiece.getFile(),
rank,
file,
game.gameBoard.spaces[rank][file]));
BoardLogic.movePiece(game.gameBoard, selectedPiece, rank, file);
JButton moves;
for (int i = 0; i < showMoves.size(); i++) {
moves = jButtonList[showMoves.elementAt(i).getRank()][showMoves.elementAt(i).getFile()];
Border thickBorder = new LineBorder(Color.BLACK, 1);
moves.setBorder(thickBorder);
}
Icon img = selectedSquare.getIcon();
button.setIcon(img);
selectedSquare.setIcon(null);
currPlayer = game.nextPlayer(currPlayer);
selectedPiece = null;
// memorization
if (BoardLogic.inCheckmate(game.gameBoard, currPlayer.pieceColor)) {
JOptionPane.showMessageDialog(
null,
currPlayer.name
+ " is in CheckMate, "
+ game.nextPlayer(currPlayer).name
+ " win!");
game.nextPlayer(currPlayer).score++;
} else if (BoardLogic.inStalemate(game.gameBoard, currPlayer.pieceColor)) {
JOptionPane.showMessageDialog(null, "The game is in StaleMate");
currPlayer.score++;
game.nextPlayer(currPlayer).score++;
} else if (BoardLogic.inCheck(game.gameBoard, currPlayer.pieceColor)) {
JOptionPane.showMessageDialog(null, currPlayer.name + " is in Check");
}
}
} else if (selection.getColor() == currPlayer.pieceColor) {
JButton moves;
selectedPiece = game.gameBoard.spaces[rank][file];
Vector<Space> showMoves = BoardLogic.movesOnBoard(game.gameBoard, selectedPiece);
for (int i = 0; i < showMoves.size(); i++) {
moves = jButtonList[showMoves.elementAt(i).getRank()][showMoves.elementAt(i).getFile()];
Border thickBorder = new LineBorder(Color.YELLOW, 3);
moves.setBorder(thickBorder);
}
selectedSquare = button;
}
}
