Constants for the side to move or the color of a piece.
You can get the opposite color using not color.
and so on to
Gets the square index for the given square name (e.g., a1 returns 0).
ValueError if the square name is invalid.
Gets the name of the square, like a3.
Gets a square number by file and rank index.
Gets the file index of the square where 0 is the a-file.
Gets the rank index of the square where 0 is the first rank.
Gets the Chebyshev distance (i.e., the number of king steps) from square a to b.
Gets the Manhattan/Taxicab distance (i.e., the number of orthogonal king steps) from square a to b.
Gets the Knight distance (i.e., the number of knight moves) from square a to b.
Mirrors the square vertically.
A piece with type and color.
The piece type.
The piece color.
Gets the symbol P, N, B, R, Q or K for white pieces or the lower-case variants for the black pieces.
Gets the Unicode character for the piece.
Creates a Piece instance from a piece symbol.
ValueError if the symbol is invalid.
Represents a move from a square to a square and possibly the promotion piece type.
Drops and null moves are supported.
The source square.
The target square.
The promotion piece type or None.
The drop piece type or None.
Gets a UCI string for the move.
For example, a move from a7 to a8 would be a7a8 or a7a8q (if the latter is a promotion to a queen).
The UCI representation of a null move is 0000.
Parses a UCI string.
InvalidMoveError if the UCI string is invalid.
Gets a null move.
A null move just passes the turn to the other side (and possibly forfeits en passant capturing). Null moves evaluate to False in boolean contexts.
>>> import chess >>> >>> bool(chess.Move.null()) False
The FEN for the standard chess starting position.
The board part of the FEN for the standard chess starting position.
A BaseBoard, additional information representing a chess position, and a move stack.
Provides move generation, validation, parsing, attack generation, game end detection, and the capability to make and unmake moves.
The board is initialized to the standard chess starting position, unless otherwise specified in the optional fen argument. If fen is None, an empty board is created.
Optionally supports chess960. In Chess960, castling moves are encoded by a king move to the corresponding rook square. Use chess.Board.from_chess960_pos() to create a board with one of the Chess960 starting positions.
It’s safe to set turn, castling_rights, ep_square, halfmove_clock and fullmove_number directly.
Warning
It is possible to set up and work with invalid positions. In this case, Board implements a kind of “pseudo-chess” (useful to gracefully handle errors or to implement chess variants). Use is_valid() to detect invalid positions.
The side to move (chess.WHITE or chess.BLACK).
Bitmask of the rooks with castling rights.
To test for specific squares:
>>> import chess >>> >>> board = chess.Board() >>> bool(board.castling_rights & chess.BB_H1) # White can castle with the h1 rook True
To add a specific square:
>>> board.castling_rights |= chess.BB_A1
Use set_castling_fen() to set multiple castling rights. Also see has_castling_rights(), has_kingside_castling_rights(), has_queenside_castling_rights(), has_chess960_castling_rights(), clean_castling_rights().
Counts move pairs. Starts at 1 and is incremented after every move of the black side.
The number of half-moves since the last capture or pawn move.
A bitmask of pieces that have been promoted.
Whether the board is in Chess960 mode. In Chess960 castling moves are represented as king moves to the corresponding rook square.
The potential en passant square on the third or sixth rank or None.
Use has_legal_en_passant() to test if en passant capturing would actually be possible on the next move.
The move stack. Use Board.push(), Board.pop(), Board.peek() and Board.clear_stack() for manipulation.
A dynamic list of legal moves.
>>> import chess
>>>
>>> board = chess.Board()
>>> board.legal_moves.count()
20
>>> bool(board.legal_moves)
True
>>> move = chess.Move.from_uci("g1f3")
>>> move in board.legal_moves
True
Wraps generate_legal_moves() and is_legal().
A dynamic list of pseudo-legal moves, much like the legal move list.
Pseudo-legal moves might leave or put the king in check, but are otherwise valid. Null moves are not pseudo-legal. Castling moves are only included if they are completely legal.
Wraps generate_pseudo_legal_moves() and is_pseudo_legal().
Restores the starting position.
Clears the board.
Resets move stack and move counters. The side to move is white. There are no rooks or kings, so castling rights are removed.
In order to be in a valid status(), at least kings need to be put on the board.
Clears the board.
Board also clears the move stack.
Clears the move stack.
Returns a copy of the root position.
Returns the number of half-moves since the start of the game, as indicated by fullmove_number and turn.
If moves have been pushed from the beginning, this is usually equal to len(board.move_stack). But note that a board can be set up with arbitrary starting positions, and the stack can be cleared.
Gets the pieces currently giving check.
Returns a set of squares.
Tests if the current side to move is in check.
Probes if the given move would put the opponent in check. The move must be at least pseudo-legal.
Check if a move is legal in the current position.
Checks if the game is over due to a special variant end condition.
Note, for example, that stalemate is not considered a variant-specific end condition (this method will return False), yet it can have a special result in suicide chess (any of is_variant_loss(), is_variant_win(), is_variant_draw() might return True).
Checks if the current side to move lost due to a variant-specific condition.
Checks if the current side to move won due to a variant-specific condition.
Checks if a variant-specific drawing condition is fulfilled.
Check if the game is over by any rule.
The game is not considered to be over by the fifty-move rule or threefold repetition, unless claim_draw is given. Note that checking the latter can be slow.
Return the result of a game: 1-0, 0-1, 1/2-1/2, or *.
The game is not considered to be over by the fifty-move rule or threefold repetition, unless claim_draw is given. Note that checking the latter can be slow.
Checks if the game is over due to checkmate, stalemate, insufficient material, the seventyfive-move rule, fivefold repetition, or a variant end condition. Returns the chess.Outcome if the game has ended, otherwise None.
Alternatively, use is_game_over() if you are not interested in who won the game and why.
The game is not considered to be over by the fifty-move rule or threefold repetition, unless claim_draw is given. Note that checking the latter can be slow.
Checks if the current position is a checkmate.
Checks if the current position is a stalemate.
Checks if neither side has sufficient winning material (has_insufficient_material()).
Checks if color has insufficient winning material.
This is guaranteed to return False if color can still win the game.
The converse does not necessarily hold: The implementation only looks at the material, including the colors of bishops, but not considering piece positions. So fortress positions or positions with forced lines may return False, even though there is no possible winning line.
Since the 1st of July 2014, a game is automatically drawn (without a claim by one of the players) if the half-move clock since a capture or pawn move is equal to or greater than 150. Other means to end a game take precedence.
Since the 1st of July 2014 a game is automatically drawn (without a claim by one of the players) if a position occurs for the fifth time. Originally this had to occur on consecutive alternating moves, but this has since been revised.
Checks if the player to move can claim a draw by the fifty-move rule or by threefold repetition.
Note that checking the latter can be slow.
Checks that the clock of halfmoves since the last capture or pawn move is greater or equal to 100, and that no other means of ending the game (like checkmate) take precedence.
Checks if the player to move can claim a draw by the fifty-move rule.
In addition to is_fifty_moves(), the fifty-move rule can also be claimed if there is a legal move that achieves this condition.
Checks if the player to move can claim a draw by threefold repetition.
Draw by threefold repetition can be claimed if the position on the board occurred for the third time or if such a repetition is reached with one of the possible legal moves.
Note that checking this can be slow: In the worst case scenario, every legal move has to be tested and the entire game has to be replayed because there is no incremental transposition table.
Checks if the current position has repeated 3 (or a given number of) times.
Unlike can_claim_threefold_repetition(), this does not consider a repetition that can be played on the next move.
Note that checking this can be slow: In the worst case, the entire game has to be replayed because there is no incremental transposition table.
Updates the position with the given move and puts it onto the move stack.
>>> import chess
>>>
>>> board = chess.Board()
>>>
>>> Nf3 = chess.Move.from_uci("g1f3")
>>> board.push(Nf3) # Make the move
>>> board.pop() # Unmake the last move
Move.from_uci('g1f3')
Null moves just increment the move counters, switch turns and forfeit en passant capturing.
Warning
Moves are not checked for legality. It is the caller’s responsibility to ensure that the move is at least pseudo-legal or a null move.
Restores the previous position and returns the last move from the stack.
IndexError if the move stack is empty.
Gets the last move from the move stack.
IndexError if the move stack is empty.
Finds a matching legal move for an origin square, a target square, and an optional promotion piece type.
For pawn moves to the backrank, the promotion piece type defaults to chess.QUEEN, unless otherwise specified.
Castling moves are normalized to king moves by two steps, except in Chess960.
IllegalMoveError if no matching legal move is found.
Checks if there is a pseudo-legal en passant capture.
Checks if there is a legal en passant capture.
Gets a FEN representation of the position.
A FEN string (e.g., rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1) consists of the board part board_fen(), the turn, the castling part (castling_rights), the en passant square (ep_square), the halfmove_clock and the fullmove_number.
shredder – Use castling_shredder_fen() and encode castling rights by the file of the rook (like HAha) instead of the default castling_xfen() (like KQkq).
en_passant – By default, only fully legal en passant squares are included (has_legal_en_passant()). Pass fen to strictly follow the FEN specification (always include the en passant square after a two-step pawn move) or xfen to follow the X-FEN specification (has_pseudo_legal_en_passant()).
promoted – Mark promoted pieces like Q~. By default, this is only enabled in chess variants where this is relevant.
Parses a FEN and sets the position from it.
ValueError if syntactically invalid. Use is_valid() to detect invalid positions.
Sets castling rights from a string in FEN notation like Qqk.
Also clears the move stack.
ValueError if the castling FEN is syntactically invalid.
Gets the Chess960 starting position index between 0 and 956, or None if the current position is not a Chess960 starting position.
By default, white to move (ignore_turn) and full castling rights (ignore_castling) are required, but move counters (ignore_counters) are ignored.
Gets an EPD representation of the current position.
See fen() for FEN formatting options (shredder, ep_square and promoted).
EPD operations can be given as keyword arguments. Supported operands are strings, integers, finite floats, legal moves and None. Additionally, the operation pv accepts a legal variation as a list of moves. The operations am and bm accept a list of legal moves in the current position.
The name of the field cannot be a lone dash and cannot contain spaces, newlines, carriage returns or tabs.
hmvc and fmvn are not included by default. You can use:
>>> import chess >>> >>> board = chess.Board() >>> board.epd(hmvc=board.halfmove_clock, fmvn=board.fullmove_number) 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - hmvc 0; fmvn 1;'
Parses the given EPD string and uses it to set the position.
If present, hmvc and fmvn are used to set the half-move clock and the full-move number. Otherwise, 0 and 1 are used.
Returns a dictionary of parsed operations. Values can be strings, integers, floats, move objects, or lists of moves.
ValueError if the EPD string is invalid.
Gets the standard algebraic notation of the given move in the context of the current position.
Gets the long algebraic notation of the given move in the context of the current position.
Given a sequence of moves, returns a string representing the sequence in standard algebraic notation (e.g., 1. e4 e5 2. Nf3 Nc6 or 37...Bg6 38. fxg6).
The board will not be modified as a result of calling this.
IllegalMoveError if any moves in the sequence are illegal.
Uses the current position as the context to parse a move in standard algebraic notation and returns the corresponding move object.
Ambiguous moves are rejected. Overspecified moves (including long algebraic notation) are accepted. Some common syntactical deviations are also accepted.
The returned move is guaranteed to be either legal or a null move.
ValueError (specifically an exception specified below) if the SAN is invalid, illegal or ambiguous.
InvalidMoveError if the SAN is syntactically invalid.
IllegalMoveError if the SAN is illegal.
AmbiguousMoveError if the SAN is ambiguous.
Parses a move in standard algebraic notation, makes the move and puts it onto the move stack.
Returns the move.
ValueError (specifically an exception specified below) if neither legal nor a null move.
InvalidMoveError if the SAN is syntactically invalid.
IllegalMoveError if the SAN is illegal.
AmbiguousMoveError if the SAN is ambiguous.
Gets the UCI notation of the move.
chess960 defaults to the mode of the board. Pass True to force Chess960 mode.
Parses the given move in UCI notation.
Supports both Chess960 and standard UCI notation.
The returned move is guaranteed to be either legal or a null move.
ValueError (specifically an exception specified below) if the move is invalid or illegal in the current position (but not a null move).
InvalidMoveError if the UCI is syntactically invalid.
IllegalMoveError if the UCI is illegal.
Parses a move in UCI notation and puts it on the move stack.
Returns the move.
ValueError (specifically an exception specified below) if the move is invalid or illegal in the current position (but not a null move).
InvalidMoveError if the UCI is syntactically invalid.
IllegalMoveError if the UCI is illegal.
Parses a move in standard algebraic notation, makes the move and puts it onto the move stack.
Returns the move.
ValueError (specifically an exception specified below) if neither legal nor a null move.
InvalidMoveError if the SAN is syntactically invalid.
IllegalMoveError if the SAN is illegal.
AmbiguousMoveError if the SAN is ambiguous.
Checks if the given pseudo-legal move is an en passant capture.
Checks if the given pseudo-legal move is a capture.
Checks if the given pseudo-legal move is a capture or pawn move.
Checks if the given pseudo-legal move is irreversible.
In standard chess, pawn moves, captures, moves that destroy castling rights and moves that cede en passant are irreversible.
This method has false-negatives with forced lines. For example, a check that will force the king to lose castling rights is not considered irreversible. Only the actual king move is.
Checks if the given pseudo-legal move is a castling move.
Checks if the given pseudo-legal move is a kingside castling move.
Checks if the given pseudo-legal move is a queenside castling move.
Returns valid castling rights filtered from castling_rights.
Checks if the given side has castling rights.
Checks if the given side has kingside (that is h-side in Chess960) castling rights.
Checks if the given side has queenside (that is a-side in Chess960) castling rights.
Checks if there are castling rights that are only possible in Chess960.
Gets a bitmask of possible problems with the position.
STATUS_VALID if all basic validity requirements are met. This does not imply that the position is actually reachable with a series of legal moves from the starting position.
Otherwise, bitwise combinations of: STATUS_NO_WHITE_KING, STATUS_NO_BLACK_KING, STATUS_TOO_MANY_KINGS, STATUS_TOO_MANY_WHITE_PAWNS, STATUS_TOO_MANY_BLACK_PAWNS, STATUS_PAWNS_ON_BACKRANK, STATUS_TOO_MANY_WHITE_PIECES, STATUS_TOO_MANY_BLACK_PIECES, STATUS_BAD_CASTLING_RIGHTS, STATUS_INVALID_EP_SQUARE, STATUS_OPPOSITE_CHECK, STATUS_EMPTY, STATUS_RACE_CHECK, STATUS_RACE_OVER, STATUS_RACE_MATERIAL, STATUS_TOO_MANY_CHECKERS, STATUS_IMPOSSIBLE_CHECK.
Checks some basic validity requirements.
See status() for details.
Returns a transformed copy of the board (without move stack) by applying a bitboard transformation function.
Available transformations include chess.flip_vertical(), chess.flip_horizontal(), chess.flip_diagonal(), chess.flip_anti_diagonal(), chess.shift_down(), chess.shift_up(), chess.shift_left(), and chess.shift_right().
Alternatively, apply_transform() can be used to apply the transformation on the board.
Returns a mirrored copy of the board.
The board is mirrored vertically and piece colors are swapped, so that the position is equivalent modulo color. Also swap the “en passant” square, castling rights and turn.
Alternatively, apply_mirror() can be used to mirror the board.
Creates a copy of the board.
Defaults to copying the entire move stack. Alternatively, stack can be False, or an integer to copy a limited number of moves.
Creates a new empty board. Also see clear().
Creates a new board from an EPD string. See set_epd().
Returns the board and the dictionary of parsed operations as a tuple.
Creates a new board, initialized with a Chess960 starting position.
>>> import chess >>> import random >>> >>> board = chess.Board.from_chess960_pos(random.randint(0, 959))
A board representing the position of chess pieces. See Board for a full board with move generation.
The board is initialized with the standard chess starting position, unless otherwise specified in the optional board_fen argument. If board_fen is None, an empty board is created.
Resets pieces to the starting position.
Board also resets the move stack, but not turn, castling rights and move counters. Use chess.Board.reset() to fully restore the starting position.
Clears the board.
Board also clears the move stack.
Gets pieces of the given type and color.
Returns a set of squares.
Gets the piece at the given square.
Gets the piece type at the given square.
Gets the color of the piece at the given square.
Finds the king square of the given side. Returns None if there is no king of that color.
In variants with king promotions, only non-promoted kings are considered.
Gets the set of attacked squares from the given square.
There will be no attacks if the square is empty. Pinned pieces are still attacking other squares.
Returns a set of squares.
Checks if the given side attacks the given square.
Pinned pieces still count as attackers. Pawns that can be captured en passant are not considered attacked.
occupied determines which squares are considered to block attacks. For example, board.occupied ^ board.pieces_mask(chess.KING, board.turn) can be used to consider X-ray attacks through the king. Defaults to board.occupied (all pieces including the king, no X-ray attacks).
Gets the set of attackers of the given color for the given square.
Pinned pieces still count as attackers.
occupied determines which squares are considered to block attacks. For example, board.occupied ^ board.pieces_mask(chess.KING, board.turn) can be used to consider X-ray attacks through the king. Defaults to board.occupied (all pieces including the king, no X-ray attacks).
Returns a set of squares.
Detects an absolute pin (and its direction) of the given square to the king of the given color.
>>> import chess
>>>
>>> board = chess.Board("rnb1k2r/ppp2ppp/5n2/3q4/1b1P4/2N5/PP3PPP/R1BQKBNR w KQkq - 3 7")
>>> board.is_pinned(chess.WHITE, chess.C3)
True
>>> direction = board.pin(chess.WHITE, chess.C3)
>>> direction
SquareSet(0x0000_0001_0204_0810)
>>> print(direction)
. . . . . . . .
. . . . . . . .
. . . . . . . .
1 . . . . . . .
. 1 . . . . . .
. . 1 . . . . .
. . . 1 . . . .
. . . . 1 . . .
Returns a set of squares that mask the rank, file or diagonal of the pin. If there is no pin, then a mask of the entire board is returned.
Detects if the given square is pinned to the king of the given color.
Removes the piece from the given square. Returns the Piece or None if the square was already empty.
Board also clears the move stack.
Sets a piece at the given square.
An existing piece is replaced. Setting piece to None is equivalent to remove_piece_at().
Board also clears the move stack.
Gets the board FEN (e.g., rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR).
Parses fen and sets up the board, where fen is the board part of a FEN.
Board also clears the move stack.
ValueError if syntactically invalid.
Gets a dictionary of pieces by square index.
Sets up the board from a dictionary of pieces by square index.
Board also clears the move stack.
Sets up a Chess960 starting position given its index between 0 and 959. Also see from_chess960_pos().
Gets the Chess960 starting position index between 0 and 959, or None.
Returns a string representation of the board with Unicode pieces. Useful for pretty-printing to a terminal.
invert_color – Invert color of the Unicode pieces.
borders – Show borders and a coordinate margin.
Returns a transformed copy of the board (without move stack) by applying a bitboard transformation function.
Available transformations include chess.flip_vertical(), chess.flip_horizontal(), chess.flip_diagonal(), chess.flip_anti_diagonal(), chess.shift_down(), chess.shift_up(), chess.shift_left(), and chess.shift_right().
Alternatively, apply_transform() can be used to apply the transformation on the board.
Returns a mirrored copy of the board (without move stack).
The board is mirrored vertically and piece colors are swapped, so that the position is equivalent modulo color.
Alternatively, apply_mirror() can be used to mirror the board.
Creates a copy of the board.
Creates a new empty board. Also see clear_board().
Creates a new board, initialized with a Chess960 starting position.
>>> import chess >>> import random >>> >>> board = chess.Board.from_chess960_pos(random.randint(0, 959))
Information about the outcome of an ended game, usually obtained from chess.Board.outcome().
The reason for the game to have ended.
The winning color or None if drawn.
Returns 1-0, 0-1 or 1/2-1/2.
Enum with reasons for a game to be over.
A set of squares.
>>> import chess >>> >>> squares = chess.SquareSet([chess.A8, chess.A1]) >>> squares SquareSet(0x0100_0000_0000_0001)
>>> squares = chess.SquareSet(chess.BB_A8 | chess.BB_RANK_1) >>> squares SquareSet(0x0100_0000_0000_00ff)
>>> print(squares) 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 1 1 1 1 1 1
>>> chess.B1 in squares True
>>> for square in squares: ... # 0 -- chess.A1 ... # 1 -- chess.B1 ... # 2 -- chess.C1 ... # 3 -- chess.D1 ... # 4 -- chess.E1 ... # 5 -- chess.F1 ... # 6 -- chess.G1 ... # 7 -- chess.H1 ... # 56 -- chess.A8 ... print(square) ... 0 1 2 3 4 5 6 7 56
>>> list(squares) [0, 1, 2, 3, 4, 5, 6, 7, 56]
Square sets are internally represented by 64-bit integer masks of the included squares. Bitwise operations can be used to compute unions, intersections and shifts.
>>> int(squares) 72057594037928191
Also supports common set operations like issubset(), issuperset(), union(), intersection(), difference(), symmetric_difference() and copy() as well as update(), intersection_update(), difference_update(), symmetric_difference_update() and clear().
Adds a square to the set.
Discards a square from the set.
Tests if the square sets are disjoint.
Tests if this square set is a subset of another.
Tests if this square set is a superset of another.
Removes a square from the set.
KeyError if the given square was not in the set.
Removes and returns a square from the set.
KeyError if the set is empty.
Removes all elements from this set.
Iterator over the subsets of this set.
Returns a vertically mirrored copy of this square set.
Converts the set to a list of 64 bools.
All squares on the rank, file or diagonal with the two squares, if they are aligned.
>>> import chess >>> >>> print(chess.SquareSet.ray(chess.E2, chess.B5)) . . . . . . . . . . . . . . . . 1 . . . . . . . . 1 . . . . . . . . 1 . . . . . . . . 1 . . . . . . . . 1 . . . . . . . . 1 . .
All squares on the rank, file or diagonal between the two squares (bounds not included), if they are aligned.
>>> import chess >>> >>> print(chess.SquareSet.between(chess.E2, chess.B5)) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 . . . . . . . . 1 . . . . . . . . . . . . . . . . . . . .
Creates a SquareSet from a single square.
>>> import chess >>> >>> chess.SquareSet.from_square(chess.A1) == chess.BB_A1 True
Common integer masks are:
Single squares:
Ranks and files:
Other masks:
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4