Design Chess

interface MoveStrategy {
    boolean isValidMove(Board board, Position from, Position to);
}
 
final class RookMoveStrategy implements MoveStrategy {
    public boolean isValidMove(Board board, Position from, Position to) {
        if (from.row() != to.row() && from.col() != to.col()) return false; // must be straight line
        return board.isPathClear(from, to); // no pieces in between
    }
}
 
final class KnightMoveStrategy implements MoveStrategy {
    public boolean isValidMove(Board board, Position from, Position to) {
        int rowDiff = Math.abs(from.row() - to.row());
        int colDiff = Math.abs(from.col() - to.col());
        return (rowDiff == 2 && colDiff == 1) || (rowDiff == 1 && colDiff == 2);
        // note: knight is the only piece that never needs a path-clear check
    }
}
 
final class BishopMoveStrategy implements MoveStrategy {
    public boolean isValidMove(Board board, Position from, Position to) {
        int rowDiff = Math.abs(from.row() - to.row());
        int colDiff = Math.abs(from.col() - to.col());
        if (rowDiff != colDiff) return false; // must be diagonal
        return board.isPathClear(from, to);
    }
}
 
// Queen composes Rook + Bishop logic rather than duplicating it
final class QueenMoveStrategy implements MoveStrategy {
    private final MoveStrategy rook = new RookMoveStrategy();
    private final MoveStrategy bishop = new BishopMoveStrategy();
    public boolean isValidMove(Board board, Position from, Position to) {
        return rook.isValidMove(board, from, to) || bishop.isValidMove(board, from, to);
    }
}

abstract class Piece {
    protected final Color color;
    protected Position position;
    protected final MoveStrategy moveStrategy;
 
    protected Piece(Color color, Position position, MoveStrategy moveStrategy) {
        this.color = color;
        this.position = position;
        this.moveStrategy = moveStrategy;
    }
 
    boolean canMove(Board board, Position to) {
        Piece target = board.pieceAt(to);
        if (target != null && target.color == this.color) return false; // can't capture own piece
        return moveStrategy.isValidMove(board, position, to);
    }
}

final class MoveValidator {
    boolean isLegal(Game game, Position from, Position to) {
        Piece piece = game.getBoard().pieceAt(from);
        if (piece == null || piece.getColor() != game.getCurrentTurn()) return false;
        if (!piece.canMove(game.getBoard(), to)) return false;
 
        // Simulate the move on a scratch copy of the board — this is the check
        // most naive chess implementations skip, and it's the one that matters most.
        Board scratch = game.getBoard().copy();
        scratch.movePiece(from, to);
        return !isKingInCheck(scratch, piece.getColor());
    }
 
    private boolean isKingInCheck(Board board, Color kingColor) {
        Position kingPos = board.findKing(kingColor);
        return board.allPieces(kingColor.opposite()).stream()
            .anyMatch(enemyPiece -> enemyPiece.canMove(board, kingPos));
    }
}

interface Command {
    void execute();
    void undo();
}
 
final class MoveCommand implements Command {
    private final Board board;
    private final Position from, to;
    private Piece capturedPiece; // remembered for undo
 
    MoveCommand(Board board, Position from, Position to) {
        this.board = board; this.from = from; this.to = to;
    }
 
    public void execute() {
        capturedPiece = board.pieceAt(to);
        board.movePiece(from, to);
    }
 
    public void undo() {
        board.movePiece(to, from);
        if (capturedPiece != null) board.placePiece(capturedPiece, to);
    }
}
 
final class Game {
    private final Deque<Command> history = new ArrayDeque<>();
 
    void makeMove(Position from, Position to) {
        Command move = new MoveCommand(board, from, to);
        move.execute();
        history.push(move);
        switchTurn();
    }
 
    void undoLastMove() {
        if (!history.isEmpty()) {
            history.pop().undo();
            switchTurn();
        }
    }
}

boolean isCheckmate(Game game, Color color) {
    if (!isKingInCheck(game.getBoard(), color)) return false; // not even in check
    return game.getBoard().allPieces(color).stream()
        .flatMap(piece -> game.getBoard().allPositions().stream()
            .filter(to -> new MoveValidator().isLegal(game, piece.getPosition(), to)))
        .findAny()
        .isEmpty(); // no legal move exists anywhere on the board
}