# -*- coding: utf-8 -*-

#

# This file is part of the python-chess library.

# Copyright (C) 2012-2017 Niklas Fiekas <niklas.fiekas@backscattering.de>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

"""

A pure Python chess library with move generation and validation, Polyglot

opening book probing, PGN reading and writing, Gaviota tablebase probing,

Syzygy tablebase probing and UCI engine communication.

"""

__author__ = "Niklas Fiekas"

__email__ = "niklas.fiekas@backscattering.de"

__version__ = "0.18.1"

import copy

import re

import itertools

try:

import backport_collections as collections

except ImportError:

import collections

COLORS = [WHITE, BLACK] = [True, False]

COLOR_NAMES = ["black", "white"]

PIECE_TYPES = [PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING] = range(1, 7)

PIECE_SYMBOLS = ["", "p", "n", "b", "r", "q", "k"]

PIECE_NAMES = ["", "pawn", "knight", "bishop", "rook", "queen", "king"]

UNICODE_PIECE_SYMBOLS = {

"R": u"♖", "r": u"♜",

"N": u"♘", "n": u"♞",

"B": u"♗", "b": u"♝",

"Q": u"♕", "q": u"♛",

"K": u"♔", "k": u"♚",

"P": u"♙", "p": u"♟",

}

FILE_NAMES = ["a", "b", "c", "d", "e", "f", "g", "h"]

RANK_NAMES = ["1", "2", "3", "4", "5", "6", "7", "8"]

STARTING_FEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

"""The FEN of the standard chess starting position."""

STARTING_BOARD_FEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"

"""The board part of the FEN of the standard chess starting position."""

STATUS_VALID = 0

STATUS_NO_WHITE_KING = 1

STATUS_NO_BLACK_KING = 2

STATUS_TOO_MANY_KINGS = 4

STATUS_TOO_MANY_WHITE_PAWNS = 8

STATUS_TOO_MANY_BLACK_PAWNS = 16

STATUS_PAWNS_ON_BACKRANK = 32

STATUS_TOO_MANY_WHITE_PIECES = 64

STATUS_TOO_MANY_BLACK_PIECES = 128

STATUS_BAD_CASTLING_RIGHTS = 256

STATUS_INVALID_EP_SQUARE = 512

STATUS_OPPOSITE_CHECK = 1024

STATUS_EMPTY = 2048

STATUS_RACE_CHECK = 4096

STATUS_RACE_OVER = 8192

STATUS_RACE_MATERIAL = 16384

SQUARES = [

A1, B1, C1, D1, E1, F1, G1, H1,

A2, B2, C2, D2, E2, F2, G2, H2,

A3, B3, C3, D3, E3, F3, G3, H3,

A4, B4, C4, D4, E4, F4, G4, H4,

A5, B5, C5, D5, E5, F5, G5, H5,

A6, B6, C6, D6, E6, F6, G6, H6,

A7, B7, C7, D7, E7, F7, G7, H7,

A8, B8, C8, D8, E8, F8, G8, H8] = range(64)

def square(file_index, rank_index):

"""Gets a square number by file and rank index."""

return rank_index * 8 + file_index

def square_file(square):

"""Gets the file index of the square where ``0`` is the a file."""

return square & 7

def square_rank(square):

"""Gets the rank index of the square where ``0`` is the first rank."""

return square >> 3

def square_name(square):

"""Gets the name of the square, e.g. ``a3``."""

return FILE_NAMES[square_file(square)] + RANK_NAMES[square_rank(square)]

def square_distance(a, b):

"""

Gets the distance (i.e. the number of king steps) from square *a* to *b*.

"""

return max(abs(square_file(a) - square_file(b)), abs(square_rank(a) - square_rank(b)))

def square_mirror(square):

"""Mirrors the square vertically."""

return square ^ 0x38

SQUARES_180 = [square_mirror(sq) for sq in SQUARES]

SQUARE_NAMES = [square_name(sq) for sq in SQUARES]

BB_VOID = 0

BB_ALL = 0xffffffffffffffff

BB_SQUARES = [

BB_A1, BB_B1, BB_C1, BB_D1, BB_E1, BB_F1, BB_G1, BB_H1,

BB_A2, BB_B2, BB_C2, BB_D2, BB_E2, BB_F2, BB_G2, BB_H2,

BB_A3, BB_B3, BB_C3, BB_D3, BB_E3, BB_F3, BB_G3, BB_H3,

BB_A4, BB_B4, BB_C4, BB_D4, BB_E4, BB_F4, BB_G4, BB_H4,

BB_A5, BB_B5, BB_C5, BB_D5, BB_E5, BB_F5, BB_G5, BB_H5,

BB_A6, BB_B6, BB_C6, BB_D6, BB_E6, BB_F6, BB_G6, BB_H6,

BB_A7, BB_B7, BB_C7, BB_D7, BB_E7, BB_F7, BB_G7, BB_H7,

BB_A8, BB_B8, BB_C8, BB_D8, BB_E8, BB_F8, BB_G8, BB_H8

] = [1 << sq for sq in SQUARES]

BB_LIGHT_SQUARES = 0x55aa55aa55aa55aa

BB_DARK_SQUARES = 0xaa55aa55aa55aa55

BB_FILES = [

BB_FILE_A,

BB_FILE_B,

BB_FILE_C,

BB_FILE_D,

BB_FILE_E,

BB_FILE_F,

BB_FILE_G,

BB_FILE_H

] = [0x0101010101010101 << i for i in range(8)]

BB_RANKS = [

BB_RANK_1,

BB_RANK_2,

BB_RANK_3,

BB_RANK_4,

BB_RANK_5,

BB_RANK_6,

BB_RANK_7,

BB_RANK_8

] = [0xff << (8 * i) for i in range(8)]

BB_BACKRANKS = BB_RANK_1 | BB_RANK_8

try:

# Added in Python 2.7 and 3.1 respectively.

int.bit_length

except AttributeError:

def _lsb_table():

table = [0 for _ in range(64)]

for square, bb in enumerate(BB_SQUARES):

index = (((bb ^ (bb - 1)) * 0x3f79d71b4cb0a89) & 0xffffffffffffffff) >> 58

table[index] = square

return table

def lsb(bb, _table=_lsb_table()):

return _table[(((bb ^ (bb - 1)) * 0x3f79d71b4cb0a89) & 0xffffffffffffffff) >> 58]

def scan_forward(bb, _bin=bin, _len=len):

string = _bin(bb)

l = _len(string)

r = string.rfind("1")

while r != -1:

yield l - r - 1

r = string.rfind("1", 0, r)

def msb(bb, _bin=bin, _len=len):

string = _bin(bb)

return _len(string) - 1 - string.find("1")

def scan_reversed(bb, _bin=bin, _len=len):

string = _bin(bb)

l = _len(string)

r = string.find("1")

while r != -1:

yield l - r - 1

r = string.find("1", r + 1)

else:

def lsb(bb):

return (bb & -bb).bit_length() - 1

def scan_forward(bb):

while bb:

r = bb & -bb

yield r.bit_length() - 1

bb ^= r

def msb(bb):

return bb.bit_length() - 1

def scan_reversed(bb, _BB_SQUARES=BB_SQUARES):

while bb:

r = bb.bit_length() - 1

yield r

bb ^= _BB_SQUARES[r]

def popcount(b, _bin=bin):

return _bin(b).count("1")

def shift_down(b):

return b >> 8

def shift_2_down(b):

return b >> 16

def shift_up(b):

return (b << 8) & BB_ALL

def shift_2_up(b):

return (b << 16) & BB_ALL

def shift_right(b):

return (b << 1) & ~BB_FILE_A & BB_ALL

def shift_2_right(b):

return (b << 2) & ~BB_FILE_A & ~BB_FILE_B & BB_ALL

def shift_left(b):

return (b >> 1) & ~BB_FILE_H

def shift_2_left(b):

return (b >> 2) & ~BB_FILE_G & ~BB_FILE_H

def shift_up_left(b):

return (b << 7) & ~BB_FILE_H & BB_ALL

def shift_up_right(b):

return (b << 9) & ~BB_FILE_A & BB_ALL

def shift_down_left(b):

return (b >> 9) & ~BB_FILE_H

def shift_down_right(b):

return (b >> 7) & ~BB_FILE_A

def _sliding_attacks(square, occupied, deltas):

attacks = 0

for delta in deltas:

sq = square

while True:

sq += delta

if not (0 <= sq < 64) or square_distance(sq, sq - delta) > 2:

break

attacks |= BB_SQUARES[sq]

if occupied & BB_SQUARES[sq]:

break

return attacks

BB_KNIGHT_ATTACKS = [_sliding_attacks(sq, BB_ALL, [17, 15, 10, 6, -17, -15, -10, -6]) for sq in SQUARES]

BB_KING_ATTACKS = [_sliding_attacks(sq, BB_ALL, [9, 8, 7, 1, -9, -8, -7, -1]) for sq in SQUARES]

BB_PAWN_ATTACKS = [[_sliding_attacks(sq, BB_ALL, deltas) for sq in SQUARES] for deltas in [[-7, -9], [7, 9]]]

def _attack_table(deltas):

mask_table = []

attack_table = []

for square, bb in enumerate(BB_SQUARES):

attacks = {}

edges = (((BB_RANK_1 | BB_RANK_8) & ~BB_RANKS[square_rank(square)]) |

((BB_FILE_A | BB_FILE_H) & ~BB_FILES[square_file(square)]))

mask = _sliding_attacks(square, 0, deltas) & ~edges

# Carry-Rippler trick to iterate subsets of mask.

subset = 0

while True:

attacks[subset] = _sliding_attacks(square, subset, deltas)

subset = (subset - mask) & mask

if not subset:

break

attack_table.append(attacks)

mask_table.append(mask)

return mask_table, attack_table

BB_DIAG_MASKS, BB_DIAG_ATTACKS = _attack_table([-9, -7, 7, 9])

BB_FILE_MASKS, BB_FILE_ATTACKS = _attack_table([-8, 8])

BB_RANK_MASKS, BB_RANK_ATTACKS = _attack_table([-1, 1])

def _rays():

rays = []

between = []

for a, bb_a in enumerate(BB_SQUARES):

rays_row = []

between_row = []

for b, bb_b in enumerate(BB_SQUARES):

if BB_DIAG_ATTACKS[a][0] & bb_b:

rays_row.append((BB_DIAG_ATTACKS[a][0] & BB_DIAG_ATTACKS[b][0]) | bb_a | bb_b)

between_row.append(BB_DIAG_ATTACKS[a][BB_DIAG_MASKS[a] & bb_b] & BB_DIAG_ATTACKS[b][BB_DIAG_MASKS[b] & bb_a])

elif BB_RANK_ATTACKS[a][0] & bb_b:

rays_row.append(BB_RANK_ATTACKS[a][0] | bb_a)

between_row.append(BB_RANK_ATTACKS[a][BB_RANK_MASKS[a] & bb_b] & BB_RANK_ATTACKS[b][BB_RANK_MASKS[b] & bb_a])

elif BB_FILE_ATTACKS[a][0] & bb_b:

rays_row.append(BB_FILE_ATTACKS[a][0] | bb_a)

between_row.append(BB_FILE_ATTACKS[a][BB_FILE_MASKS[a] & bb_b] & BB_FILE_ATTACKS[b][BB_FILE_MASKS[b] & bb_a])

else:

rays_row.append(0)

between_row.append(0)

rays.append(rays_row)

between.append(between_row)

return rays, between

BB_RAYS, BB_BETWEEN = _rays()

SAN_REGEX = re.compile(r"^([NBKRQ])?([a-h])?([1-8])?[\-x]?([a-h][1-8])(=?[nbrqkNBRQK])?(\+|#)?\Z")

FEN_CASTLING_REGEX = re.compile(r"^(?:-|[KQABCDEFGH]{0,2}[kqabcdefgh]{0,2})\Z")

class Piece(object):

"""A piece with type and color."""

def __init__(self, piece_type, color):

self.piece_type = piece_type

self.color = color

def symbol(self):

"""

Gets the symbol ``P``, ``N``, ``B``, ``R``, ``Q`` or ``K`` for white

pieces or the lower-case variants for the black pieces.

"""

if self.color == WHITE:

return PIECE_SYMBOLS[self.piece_type].upper()

else:

return PIECE_SYMBOLS[self.piece_type]

def unicode_symbol(self, invert_color=False):

"""

Gets the unicode character for the piece.

"""

if not invert_color:

return UNICODE_PIECE_SYMBOLS[self.symbol()]

else:

return UNICODE_PIECE_SYMBOLS[self.symbol().swapcase()]

def __hash__(self):

return hash(self.piece_type * (self.color + 1))

def __repr__(self):

return "Piece.from_symbol('{0}')".format(self.symbol())

def __str__(self):

return self.symbol()

def __unicode__(self, invert_color=False):

return self.unicode_symbol(invert_color)

def _repr_svg_(self):

import chess.svg

return chess.svg.piece(self, size=45)

def __eq__(self, other):

ne = self.__ne__(other)

return NotImplemented if ne is NotImplemented else not ne

def __ne__(self, other):

try:

if self.piece_type != other.piece_type:

return True

elif self.color != other.color:

return True

else:

return False

except AttributeError:

return NotImplemented

@classmethod

def from_symbol(cls, symbol):

"""

Creates a piece instance from a piece symbol.

:raises: :exc:`ValueError` if the symbol is invalid.

"""

if symbol.islower():

return cls(PIECE_SYMBOLS.index(symbol), BLACK)

else:

return cls(PIECE_SYMBOLS.index(symbol.lower()), WHITE)

class Move(object):

"""

Represents a move from a square to a square and possibly the promotion

piece type.

Drops and null moves are supported.

"""

def __init__(self, from_square, to_square, promotion=None, drop=None):

self.from_square = from_square

self.to_square = to_square

self.promotion = promotion

self.drop = drop

def uci(self):

"""

Gets an UCI string for the move.

For example a move from A7 to A8 would be ``a7a8`` or ``a7a8q`` if it

is a promotion to a queen.

The UCI representatin of null moves is ``0000``.

"""

if self.drop:

return PIECE_SYMBOLS[self.drop].upper() + "@" + SQUARE_NAMES[self.to_square]

elif self.promotion:

return SQUARE_NAMES[self.from_square] + SQUARE_NAMES[self.to_square] + PIECE_SYMBOLS[self.promotion]

elif self:

return SQUARE_NAMES[self.from_square] + SQUARE_NAMES[self.to_square]

else:

return "0000"

def __bool__(self):

return bool(self.from_square or self.to_square or self.promotion or self.drop)

__nonzero__ = __bool__

def __eq__(self, other):

ne = self.__ne__(other)

return NotImplemented if ne is NotImplemented else not ne

def __ne__(self, other):

try:

if self.from_square != other.from_square:

return True

elif self.to_square != other.to_square:

return True

elif self.promotion != other.promotion:

return True

elif self.drop != other.drop:

return True

else:

return False

except AttributeError:

return NotImplemented

def __repr__(self):

return "Move.from_uci('{0}')".format(self.uci())

def __str__(self):

return self.uci()

def __hash__(self):

return hash((self.to_square, self.from_square, self.promotion, self.drop))

def __copy__(self):

return type(self)(self.from_square, self.to_square, self.promotion, self.drop)

def __deepcopy__(self, memo):

move = self.__copy__()

memo[id(self)] = move

return move

@classmethod

def from_uci(cls, uci):

"""

Parses an UCI string.

:raises: :exc:`ValueError` if the UCI string is invalid.

"""

if uci == "0000":

return cls.null()

elif "@" == uci[1]:

drop = PIECE_SYMBOLS.index(uci[0].lower())

square = SQUARE_NAMES.index(uci[2:])

return cls(square, square, drop=drop)

elif len(uci) == 4:

return cls(SQUARE_NAMES.index(uci[0:2]), SQUARE_NAMES.index(uci[2:4]))

elif len(uci) == 5:

promotion = PIECE_SYMBOLS.index(uci[4])

return cls(SQUARE_NAMES.index(uci[0:2]), SQUARE_NAMES.index(uci[2:4]), promotion=promotion)

else:

raise ValueError("expected uci string to be of length 4 or 5: {0}".format(repr(uci)))

@classmethod

def null(cls):

"""

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.

>>> bool(chess.Move.null())

False

"""

return cls(0, 0)

class BaseBoard(object):

"""

A board representing the position of chess pieces. See

:class:`~chess.Board` for a full board with move generation.

The board is initialized to the standard chess starting position, unless

otherwise specified in the optional *board_fen* argument. If *board_fen*

is ``None`` an empty board is created.

"""

def __init__(self, board_fen=STARTING_BOARD_FEN):

self.occupied_co = [BB_VOID, BB_VOID]

if board_fen is None:

self._clear_board()

elif board_fen == STARTING_BOARD_FEN:

self._reset_board()

else:

self._set_board_fen(board_fen)

def _reset_board(self):

self.pawns = BB_RANK_2 | BB_RANK_7

self.knights = BB_B1 | BB_G1 | BB_B8 | BB_G8

self.bishops = BB_C1 | BB_F1 | BB_C8 | BB_F8

self.rooks = BB_A1 | BB_H1 | BB_A8 | BB_H8

self.queens = BB_D1 | BB_D8

self.kings = BB_E1 | BB_E8

self.promoted = BB_VOID

self.occupied_co[WHITE] = BB_RANK_1 | BB_RANK_2

self.occupied_co[BLACK] = BB_RANK_7 | BB_RANK_8

self.occupied = BB_RANK_1 | BB_RANK_2 | BB_RANK_7 | BB_RANK_8

def reset_board(self):

self._reset_board()

def _clear_board(self):

self.pawns = BB_VOID

self.knights = BB_VOID

self.bishops = BB_VOID

self.rooks = BB_VOID

self.queens = BB_VOID

self.kings = BB_VOID

self.promoted = BB_VOID

self.occupied_co[WHITE] = BB_VOID

self.occupied_co[BLACK] = BB_VOID

self.occupied = BB_VOID

def clear_board(self):

"""Clears the board."""

self._clear_board()

def pieces_mask(self, piece_type, color):

if piece_type == PAWN:

bb = self.pawns

elif piece_type == KNIGHT:

bb = self.knights

elif piece_type == BISHOP:

bb = self.bishops

elif piece_type == ROOK:

bb = self.rooks

elif piece_type == QUEEN:

bb = self.queens

elif piece_type == KING:

bb = self.kings

return bb & self.occupied_co[color]

def pieces(self, piece_type, color):

"""

Gets pieces of the given type and color.

Returns a :class:`set of squares <chess.SquareSet>`.

"""

return SquareSet(self.pieces_mask(piece_type, color))

def piece_at(self, square):

"""Gets the :class:`piece <chess.Piece>` at the given square."""

piece_type = self.piece_type_at(square)

if piece_type:

mask = BB_SQUARES[square]

color = bool(self.occupied_co[WHITE] & mask)

return Piece(piece_type, color)

def piece_type_at(self, square):

"""Gets the piece type at the given square."""

mask = BB_SQUARES[square]

if not self.occupied & mask:

return None

elif self.pawns & mask:

return PAWN

elif self.knights & mask:

return KNIGHT

elif self.bishops & mask:

return BISHOP

elif self.rooks & mask:

return ROOK

elif self.queens & mask:

return QUEEN

elif self.kings & mask:

return KING

def king(self, color):

"""

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.

"""

king_mask = self.occupied_co[color] & self.kings & ~self.promoted

if king_mask:

return msb(king_mask)

def _remove_piece_at(self, square):

piece_type = self.piece_type_at(square)

mask = BB_SQUARES[square]

if piece_type == PAWN:

self.pawns ^= mask

elif piece_type == KNIGHT:

self.knights ^= mask

elif piece_type == BISHOP:

self.bishops ^= mask

elif piece_type == ROOK:

self.rooks ^= mask

elif piece_type == QUEEN:

self.queens ^= mask

elif piece_type == KING:

self.kings ^= mask

else:

return

self.occupied ^= mask

self.occupied_co[WHITE] &= ~mask

self.occupied_co[BLACK] &= ~mask

self.promoted &= ~mask

return piece_type

def remove_piece_at(self, square):

"""

Removes the piece from the given square. Returns the

:class:`~chess.Piece` or ``None`` if the square was already empty.

"""

color = bool(self.occupied_co[WHITE] & BB_SQUARES[square])

piece_type = self._remove_piece_at(square)

if piece_type:

return Piece(piece_type, color)

def _set_piece_at(self, square, piece_type, color, promoted=False):

self._remove_piece_at(square)

mask = BB_SQUARES[square]

if piece_type == PAWN:

self.pawns |= mask

elif piece_type == KNIGHT:

self.knights |= mask

elif piece_type == BISHOP:

self.bishops |= mask

elif piece_type == ROOK:

self.rooks |= mask

elif piece_type == QUEEN:

self.queens |= mask

elif piece_type == KING:

self.kings |= mask

self.occupied ^= mask

self.occupied_co[color] ^= mask

if promoted:

self.promoted ^= mask

def set_piece_at(self, square, piece, promoted=False):

"""

Sets a piece at the given square.

An existing piece is replaced. Setting *piece* to ``None`` is

equivalent to :func:`~chess.Board.remove_piece_at()`.

"""

if piece is None:

self._remove_piece_at(square)

else:

self._set_piece_at(square, piece.piece_type, piece.color, promoted)

def board_fen(self, promoted=False):

"""

Gets the board FEN.

"""

builder = []

empty = 0

for square in SQUARES_180:

piece = self.piece_at(square)

if not piece:

empty += 1

else:

if empty:

builder.append(str(empty))

empty = 0

builder.append(piece.symbol())

if promoted and BB_SQUARES[square] & self.promoted:

builder.append("~")

if BB_SQUARES[square] & BB_FILE_H:

if empty:

builder.append(str(empty))

empty = 0

if square != H1:

builder.append("/")

return "".join(builder)

def _set_board_fen(self, fen):

# Ensure the FEN is valid.

rows = fen.split("/")

if len(rows) != 8:

raise ValueError("expected 8 rows in position part of fen: {0}".format(repr(fen)))

# Validate each row.

for row in rows:

field_sum = 0

previous_was_digit = False

previous_was_piece = False

for c in row:

if c in ["1", "2", "3", "4", "5", "6", "7", "8"]:

if previous_was_digit:

raise ValueError("two subsequent digits in position part of fen: {0}".format(repr(fen)))

field_sum += int(c)

previous_was_digit = True

previous_was_piece = False

elif c == "~":

if not previous_was_piece:

raise ValueError("~ not after piece in position part of fen: {0}".format(repr(fen)))

previous_was_digit = False

previous_was_piece = False

elif c.lower() in ["p", "n", "b", "r", "q", "k"]:

field_sum += 1

previous_was_digit = False

previous_was_piece = True

else:

raise ValueError("invalid character in position part of fen: {0}".format(repr(fen)))

if field_sum != 8:

raise ValueError("expected 8 columns per row in position part of fen: {0}".format(repr(fen)))

# Clear the board.

self._clear_board()

# Put pieces on the board.

square_index = 0

for c in fen:

if c in ["1", "2", "3", "4", "5", "6", "7", "8"]:

square_index += int(c)

elif c.lower() in ["p", "n", "b", "r", "q", "k"]:

piece = Piece.from_symbol(c)

self._set_piece_at(SQUARES_180[square_index], piece.piece_type, piece.color)

square_index += 1

elif c == "~":

self.promoted |= BB_SQUARES[SQUARES_180[square_index - 1]]

def set_board_fen(self, fen):

"""

Parses a FEN and sets the board from it.

:raises: :exc:`ValueError` if the FEN string is invalid.

"""

self._set_board_fen(fen)

def _set_chess960_pos(self, sharnagl):

if not 0 <= sharnagl <= 959:

raise ValueError("chess960 position index not 0 <= {0} <= 959".format(repr(sharnagl)))

# See http://www.russellcottrell.com/Chess/Chess960.htm for

# a description of the algorithm.

n, bw = divmod(sharnagl, 4)

n, bb = divmod(n, 4)

n, q = divmod(n, 6)

for n1 in range(0, 4):

n2 = n + (3 - n1) * (4 - n1) // 2 - 5

if n1 < n2 and 1 <= n2 <= 4:

break

# Bishops.

bw_file = bw * 2 + 1

bb_file = bb * 2

self.bishops = (BB_FILES[bw_file] | BB_FILES[bb_file]) & BB_BACKRANKS

# Queens.

q_file = q

q_file += int(min(bw_file, bb_file) <= q_file)

q_file += int(max(bw_file, bb_file) <= q_file)

self.queens = BB_FILES[q_file] & BB_BACKRANKS

used = [bw_file, bb_file, q_file]

# Knights.

self.knights = BB_VOID

for i in range(0, 8):

if i not in used:

if n1 == 0 or n2 == 0:

self.knights |= BB_FILES[i] & BB_BACKRANKS

used.append(i)

n1 -= 1

n2 -= 1

# RKR.

for i in range(0, 8):

if i not in used:

self.rooks = BB_FILES[i] & BB_BACKRANKS

used.append(i)

break

for i in range(1, 8):

if i not in used:

self.kings = BB_FILES[i] & BB_BACKRANKS

used.append(i)

break

for i in range(2, 8):

if i not in used:

self.rooks |= BB_FILES[i] & BB_BACKRANKS

break

# Finalize.

self.pawns = BB_RANK_2 | BB_RANK_7

self.occupied_co[WHITE] = BB_RANK_1 | BB_RANK_2

self.occupied_co[BLACK] = BB_RANK_7 | BB_RANK_8

self.occupied = BB_RANK_1 | BB_RANK_2 | BB_RANK_7 | BB_RANK_8

self.promoted = BB_VOID

def set_chess960_pos(self, sharnagl):

"""

Sets up a Chess960 starting position given its index between 0 and 959.

>>> board.set_chess960_pos(random.randint(0, 959))

"""

self._set_chess960_pos(sharnagl)

def chess960_pos(self):

"""

Gets the Chess960 starting position index between 0 and 959

or ``None``.

"""

if self.occupied_co[WHITE] != BB_RANK_1 | BB_RANK_2:

return None

if self.occupied_co[BLACK] != BB_RANK_7 | BB_RANK_8:

return None

if self.pawns != BB_RANK_2 | BB_RANK_7:

return None

if self.promoted:

return None

if popcount(self.bishops) != 4:

return None

if popcount(self.rooks) != 4:

return None

if popcount(self.knights) != 4:

return None

if popcount(self.queens) != 2:

return None

if popcount(self.kings) != 2:

return None

if (BB_RANK_1 & self.knights) << 56 != BB_RANK_8 & self.knights:

return None

if (BB_RANK_1 & self.bishops) << 56 != BB_RANK_8 & self.bishops:

return None

if (BB_RANK_1 & self.rooks) << 56 != BB_RANK_8 & self.rooks:

return None

if (BB_RANK_1 & self.queens) << 56 != BB_RANK_8 & self.queens:

return None

if (BB_RANK_1 & self.kings) << 56 != BB_RANK_8 & self.kings:

return None

x = self.bishops & (2 + 8 + 32 + 128)

if not x:

return None

bs1 = (lsb(x) - 1) // 2

cc_pos = bs1

x = self.bishops & (1 + 4 + 16 + 64)

if not x:

return None

bs2 = lsb(x) * 2

cc_pos += bs2

# Algorithm from ChessX src/database/bitboard.cpp r2254.

q = 0

qf = False

n0 = 0

n1 = 0

n0f = False

n1f = False

rf = 0

n0s = [0, 4, 7, 9]

for square in range(A1, H1 + 1):

bb = BB_SQUARES[square]

if bb & self.queens:

qf = True

elif bb & self.rooks or bb & self.kings:

if bb & self.kings:

if rf != 1:

return None

else:

rf += 1

if not qf:

q += 1

if not n0f:

n0 += 1

elif not n1f:

n1 += 1

elif bb & self.knights:

if not qf:

q += 1

if not n0f:

n0f = True

elif not n1f:

n1f = True

if n0 < 4 and n1f and qf:

cc_pos += q * 16

krn = n0s[n0] + n1

cc_pos += krn * 96

return cc_pos

else:

return None

def __repr__(self):

return "{0}('{1}')".format(type(self).__name__, self.board_fen())

def __str__(self):

builder = []

for square in SQUARES_180:

piece = self.piece_at(square)

if piece:

builder.append(piece.symbol())

else:

builder.append(".")

if BB_SQUARES[square] & BB_FILE_H:

if square != H1:

builder.append("\n")

else:

builder.append(" ")

return "".join(builder)

def __unicode__(self, invert_color=False, borders=False):

builder = []

for rank_index in range(7, -1, -1):

if borders:

builder.append(" ")

builder.append("-" * 17)

builder.append("\n")

builder.append(RANK_NAMES[rank_index])

builder.append(" ")

for file_index in range(8):

square_index = square(file_index, rank_index)

if borders:

builder.append("|")

elif file_index > 0: