clj-chess.board — clj-chess 0.5.0

ancestors clj/s

(ancestors board)

A sequence of all ancestors of the board, ordered from the root board, up to and including the input board.

attacked? clj

(attacked? board square color)

attacks-from clj

(attacks-from board square)

The set of squares attacked by the piece on the given square.

attacks-to clj

(attacks-to board square)

(attacks-to board square color)

The set of squares containing pieces that attack the given square. If the third, optional argument 'color' is supplied, only attackers of that color are included.

bishop clj/s

bishop-attacks clj

(bishop-attacks board square)

The set of squares that would be attacked by a bishop on the given square.

bishop-squares clj

(bishop-squares board color)

The set of squares containing bishops of the given color.

black clj/s

black-bishop clj/s

black-king clj/s

black-knight clj/s

black-pawn clj/s

black-queen clj/s

black-rook clj/s

blocker clj/s

board-to-map clj/s

(board-to-map board)

Translates a board and its list of legal moves to a map of the following format (for the initial position):

{:pieces [[:br 56] [:bn 57] [:bb 58] [:bq 59] ... [wr 7]] :moves [{:piece :white-pawn, :from 8, :to 16} ... ] :checks [...]}

Every move map needs at least the keys :piece, :from and :to. In addition, capture moves take a :captured-piece and an optional :capture-square (if omitted, assumed to be equal to the :to square). Promotion moves include a :promote-to key. Castle moves include the :rook-from and :rook-to keys. Some examples:

The white move fxg8=R, where the captured piece is a knight, would be represented by the map

{:piece :wp, :from 53, :to 62, :captured-piece :bn, :promote-to :wr}

Black queenside castling would be represented by the map

{:piece :bk, :from 60, :to 58, :rook-from 56, :rook-to 59}

An en passant capture exd6 would be represented by the map

{:piece :wp, :from 36, :to 43, :captured-piece :bp, :capture-square 35}

No assumptions can be made about the ordering of the lists of pieces and legal moves.

The value attached to the :checks key is a sequence of checking pieces. For each checking piece, the sequence contains a map of the form {:from <sq-1> :to <sq-2>}, where :from is the square of the checking piece, and :to the square of the king.

board-to-uci clj/s

(board-to-uci board)

Translates the board state (including as much of the move history as necessary) to a format ready to be sent to a UCI chess engine, i.e. like 'position fen' followed by a sequence of moves.

can-castle-kingside? clj/s

(can-castle-kingside? board side)

Tests whether the given side still has the right to castle kingside.

can-castle-queenside? clj/s

(can-castle-queenside? board side)

Tests whether the given side still has the right to castle queenside.

castle-rights clj/s

(castle-rights board)

Castle rights, a subset of #{:white-oo :white-ooo :black-oo :black-ooo}

check? clj/s

(check? board)

Tests whether the side to move is in check.

checking-pieces clj/s

(checking-pieces board)

Returns a vector of all squares containing checking pieces (0, 1 or 2).

checkmate? clj/s

(checkmate? board)

Tests whether the board position is checkmate.

disable-king-capture clj

(disable-king-capture board)

Returns an identical board, except that king captures are not allowed.

divide clj

(divide board depth)

divide function for testing move generator, see https://chessprogramming.wikispaces.com/Perft

do-map-move clj/s

(do-map-move board move-map)

Execute the move given by the provided move map. For the format of this map, see the documentation of board-to-map.

do-move clj/s

(do-move board move)

Do a move (encoded as an integer) from the current board, and returns the new board. The move is assumed to be legal.

do-null-move clj

(do-null-move board)

Do a null move, i.e. just change the side to move without making a move. This will only work if the side to move is not in check, or if the board is a pseudo-chess board where king captures are allowed.

do-san-move clj/s

(do-san-move board san-move)

Do the move represented by a SAN string, and return the new board. If no matching move exists, returns nil.

do-san-move-sequence clj/s

(do-san-move-sequence board san-move-sequence)

Executes a sequence of moves in short algebraic notation, and returns the new board, assuming that all moves in the sequence are valid, legal moves. Returns nil if the sequence contains an invalid move.

do-uci-move clj/s

(do-uci-move board uci-move)

Do the move represented by a UCI string, and return the new board. If no matching move exists, returns nil.

do-uci-move-sequence clj/s

(do-uci-move-sequence board uci-move-sequence)

Executes a sequence of moves in UCI notation, and returns the new board, assuming that all moves in the sequence are valid, legal moves. Returns nil if the sequence contains an invalid move.

empty-board clj

(empty-board file-count rank-count & [allow-king-capture?])

Creates an empty board with the given number of files and ranks, optionally allowing king captures.

empty-square clj/s

empty-square? clj/s

(empty-square? board square)

Tests whether the given square is empty.

empty-squares clj

(empty-squares board)

The set of all empty squares on the board.

enable-king-capture clj

(enable-king-capture board)

Returns an identical board, except that king captures are allowed.

equal? clj/s

(equal? board-1 board-2)

(equal? board-1 board-2 & rest)

Tests whether two or more boards are equal.

file-count clj/s

(file-count board)

Number of files on the board.

flip clj

(flip board)

Returns a flipped copy of a board, with the black and white pieces, the side to move, the castle rights and the en passant capture square flipped.

immediate-draw? clj/s

(immediate-draw? board)

Tests whether the board position is an immediate draw.

is-kingside-castle? clj/s

(is-kingside-castle? move)

is-queenside-castle? clj/s

(is-queenside-castle? move)

king clj/s

king-attacks clj

(king-attacks board square)

The set of squares that would be attacked by a king on the given square.

king-capture-allowed? clj

(king-capture-allowed? board)

king-square clj/s

(king-square board color)

The square of the king for the given color.

king-squares clj

(king-squares board color)

The set of squares containing kings of the given color.

knight clj/s

knight-attacks clj

(knight-attacks board square)

The set of squares that would be attacked by a knight on the given square.

knight-squares clj

(knight-squares board color)

The set of squares containing knights of the given color.

last-move clj/s

(last-move board)

The last move played to reach this board position, or nil if we are at the beginning of the game.

last-move-to-san clj/s

(last-move-to-san board)

Translate the last move played to reach this board position to short algebraic notation.

make-board clj/s

(make-board & [fen allow-king-capture?])

Creates a new chess board from a FEN string. If no string is supplied, the standard initial position is used.

move-from clj/s

(move-from move)

move-from-byte clj/s

(move-from-byte board byte-move)

Converts a move in byte format, i.e. an integer representing the index of the move among the legal moves sorted alphabetically in UCI notation, to an actual move.

move-from-map clj/s

(move-from-map board move-map)

Translate a move in map notation to a move from the given board. If no maching move is found, returns nil.

move-from-san clj/s

(move-from-san board san-move)

Translate a move string in short algebraic notation to a move from the given board. If no matching move is found, returns nil.

move-from-uci clj/s

(move-from-uci board uci-move)

move-is-checkmate? clj/s

(move-is-checkmate? board move)

Tests whether the move is a mate in one.

move-is-ep? clj/s

(move-is-ep? move)

move-is-promotion? clj/s

(move-is-promotion? move)

move-none clj/s

move-number clj/s

(move-number board)

Current full move number.

move-promotion clj/s

(move-promotion move)

move-to clj/s

(move-to move)

move-to-byte clj/s

(move-to-byte board move)

Converts a move to a byte by sorting all moves alphabetically in UCI notation and finding the index of the move in the list.

move-to-map clj/s

(move-to-map board move)

Translate a move to a map of the format described in the documentation of the board-to-map function, e.g.

{:piece :wp, :from 53, :to 62, :captured-piece :bn, :promote-to :wr}

for the move fxg8=R.

move-to-san clj/s

(move-to-san board move & {:keys [include-move-number?]})

Translates a move to a string in short algebraic notation, optionally including a preceding move number.

move-to-uci clj/s

(move-to-uci move)

Translates a move to a string in UCI notation.

moves clj/s

(moves board)

Returns the legal moves for the current board.

moves-from clj/s

(moves-from board square)

Returns the legal moves from the given square.

moves-to clj/s

(moves-to board square)

Returns the legal moves to the given square.

occupied-square? clj/s

(occupied-square? board square)

Tests whether the given square is occupied.

occupied-squares clj

(occupied-squares board)

(occupied-squares board color)

The set of occupied squares on the board, including blockers. Supplying the optional 'color' parameter will result in only squares occupied by pieces of that color (and no blockers) to be returned.

parent clj/s

(parent board)

The parent board of the current board (i.e. the board as it was before the last move was played), or nil if we're at the beginning of the game.

pattern-key clj

(pattern-key board file-min file-max rank-min rank-max & [color])

Creates a hash key for a given rectangular area of the board, either for both colors (if the optional 'color' parameter is ommited) or just for one color, ignoring the pieces of the other color, if the 'color' parameter is supplied.

pawn clj/s

pawn-attacks clj

(pawn-attacks board color square)

The set of squares that would be attacked by a pawn of the given color from the given square.

pawn-squares clj

(pawn-squares board color)

The set of squares containing pawns of the given color.

perft clj/s

(perft board depth & [no-pmap])

perft function for testing move generator, see https://chessprogramming.wikispaces.com/Perft

piece-color clj/s

(piece-color piece)

Returns the color of a piece (white or black).

piece-count clj

(piece-count board piece)

(piece-count board color type)

The number of pieces of a given type. There is a two-argument version taking a board and a piece as input, and a three-argument version taking a board, a color and a piece type.

piece-make clj/s

(piece-make color type)

Returns a piece with a given color and type.

piece-on clj/s

(piece-on board square)

The piece on a given square.

piece-type clj/s

(piece-type piece)

Returns the type of a piece (pawn, knight, bishop, etc.).

print-board clj/s

(print-board board)

Prints a board to the console, for debugging.

put-piece clj

(put-piece board piece square)

Puts a piece or a blocker on a given square.

queen clj/s

queen-attacks clj

(queen-attacks board square)

The set of squares that would be attacked by a queen on the given square.

queen-squares clj

(queen-squares board color)

The set of squares containing queens of the given color.

rank-count clj/s

(rank-count board)

Number of ranks on the board.

remove-piece clj

(remove-piece board square)

Removes the piece or blocker on the given square.

rook clj/s

rook-attacks clj

(rook-attacks board square)

The set of squares that would be attacked by a rook on the given square.

rook-squares clj

(rook-squares board color)

The set of squares containing rooks of the given color.

side-to-move clj/s

(side-to-move board)

The current side to move, :white or :black.

square-file clj/s

(square-file square)

square-from-string clj/s

(square-from-string sq-str)

Converts a string in standard coordinate notation to a square.

square-make clj/s

(square-make file rank)

square-rank clj/s

(square-rank square)

square-to-string clj/s

(square-to-string square)

Converts a square to a string in standard coordinate notation.

start-fen clj/s

static-exchange-evaluation clj

(static-exchange-evaluation board move)

Statically evaluates the material gain or loss of a move. The return value is a number of pawns, using a material scale of pawn = 1, knight = 3, bishop = 3, rook = 5, queen = 9.

terminal? clj/s

(terminal? board)

Tests whether the board position is terminal, i.e. checkmate or an immediate draw.

to-fen clj/s

(to-fen board)

Converts the board to a string in Forsyth-Edwards notation.

variation-to-san clj/s

(variation-to-san board uci-moves & {:keys [include-move-numbers]})

Translates a variation from a sequence of UCI moves to a string in short algebraic notation.

white clj/s

white-bishop clj/s

white-king clj/s

white-knight clj/s

white-pawn clj/s

white-queen clj/s

white-rook clj/s