1685 lines
57 KiB
Python
1685 lines
57 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
import collections
|
|
import re
|
|
import math
|
|
import plugin_super_class
|
|
|
|
from PyQt5.QtCore import *
|
|
from PyQt5.QtWidgets import *
|
|
from PyQt5.QtGui import *
|
|
from PyQt5.QtSvg import *
|
|
|
|
|
|
START_FEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
|
|
|
|
|
|
def opposite_color(color):
|
|
""":return: The opposite color.
|
|
|
|
:param color:
|
|
"w", "white, "b" or "black".
|
|
"""
|
|
if color == "w":
|
|
return "b"
|
|
elif color == "white":
|
|
return "black"
|
|
elif color == "b":
|
|
return "w"
|
|
elif color == "black":
|
|
return "white"
|
|
else:
|
|
raise ValueError("Expected w, b, white or black, got: %s." % color)
|
|
|
|
|
|
class Piece(object):
|
|
|
|
__cache = dict()
|
|
|
|
def __init__(self, symbol):
|
|
self.__symbol = symbol
|
|
|
|
self.__color = "w" if symbol != symbol.lower() else "b"
|
|
self.__full_color = "white" if self.__color == "w" else "black"
|
|
|
|
self.__type = symbol.lower()
|
|
if self.__type == "p":
|
|
self.__full_type = "pawn"
|
|
elif self.__type == "n":
|
|
self.__full_type = "knight"
|
|
elif self.__type == "b":
|
|
self.__full_type = "bishop"
|
|
elif self.__type == "r":
|
|
self.__full_type = "rook"
|
|
elif self.__type == "q":
|
|
self.__full_type = "queen"
|
|
elif self.__type == "k":
|
|
self.__full_type = "king"
|
|
else:
|
|
raise ValueError("Expected valid piece symbol, got: %s." % symbol)
|
|
|
|
self.__hash = ord(self.__symbol)
|
|
|
|
@classmethod
|
|
def from_color_and_type(cls, color, type):
|
|
"""Creates a piece object from color and type.
|
|
"""
|
|
if type == "p" or type == "pawn":
|
|
symbol = "p"
|
|
elif type == "n" or type == "knight":
|
|
symbol = "n"
|
|
elif type == "b" or type == "bishop":
|
|
symbol = "b"
|
|
elif type == "r" or type == "rook":
|
|
symbol = "r"
|
|
elif type == "q" or type == "queen":
|
|
symbol = "q"
|
|
elif type == "k" or type == "king":
|
|
symbol = "k"
|
|
else:
|
|
raise ValueError("Expected piece type, got: %s." % type)
|
|
|
|
if color == "w" or color == "white":
|
|
return cls(symbol.upper())
|
|
elif color == "b" or color == "black":
|
|
return cls(symbol)
|
|
else:
|
|
raise ValueError("Expected w, b, white or black, got: %s." % color)
|
|
|
|
@property
|
|
def symbol(self):
|
|
return self.__symbol
|
|
|
|
@property
|
|
def color(self):
|
|
"""The color of the piece as `"b"` or `"w"`."""
|
|
return self.__color
|
|
|
|
@property
|
|
def full_color(self):
|
|
"""The full color of the piece as `"black"` or `"white`."""
|
|
return self.__full_color
|
|
|
|
@property
|
|
def type(self):
|
|
"""The type of the piece as `"p"`, `"b"`, `"n"`, `"r"`, `"k"`,
|
|
or `"q"` for pawn, bishop, knight, rook, king or queen.
|
|
"""
|
|
return self.__type
|
|
|
|
@property
|
|
def full_type(self):
|
|
"""The full type of the piece as `"pawn"`, `"bishop"`,
|
|
`"knight"`, `"rook"`, `"king"` or `"queen"`.
|
|
"""
|
|
return self.__full_type
|
|
|
|
def __str__(self):
|
|
return self.__symbol
|
|
|
|
def __repr__(self):
|
|
return "Piece('%s')" % self.__symbol
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, Piece) and self.__symbol == other.symbol
|
|
|
|
def __ne__(self, other):
|
|
return not self.__eq__(other)
|
|
|
|
def __hash__(self):
|
|
return self.__hash
|
|
|
|
|
|
class Square(object):
|
|
"""Represents a square on the chess board.
|
|
|
|
:param name: The name of the square in algebraic notation.
|
|
|
|
Square objects that represent the same square compare as equal.
|
|
"""
|
|
|
|
__cache = dict()
|
|
|
|
def __init__(self, name):
|
|
if not len(name) == 2:
|
|
raise ValueError("Expected square name, got: %s." % repr(name))
|
|
self.__name = name
|
|
|
|
if not name[0] in ["a", "b", "c", "d", "e", "f", "g", "h"]:
|
|
raise ValueError("Expected file, got: %s." % repr(name[0]))
|
|
self.__file = name[0]
|
|
self.__x = ord(self.__name[0]) - ord("a")
|
|
|
|
if not name[1] in ["1", "2", "3", "4", "5", "6", "7", "8"]:
|
|
raise ValueError("Expected rank, got: %s." % repr(name[1]))
|
|
self.__rank = int(name[1])
|
|
self.__y = ord(self.__name[1]) - ord("1")
|
|
|
|
self.__x88 = self.__x + 16 * (7 - self.__y)
|
|
|
|
@classmethod
|
|
def from_x88(cls, x88):
|
|
"""Creates a square object from an `x88 <http://en.wikipedia.org/wiki/Board_representation_(chess)#0x88_method>`_
|
|
index.
|
|
|
|
:param x88:
|
|
The x88 index as integer between 0 and 128.
|
|
"""
|
|
if x88 < 0 or x88 > 128:
|
|
raise ValueError("x88 index is out of range: %s." % repr(x88))
|
|
|
|
if x88 & 0x88:
|
|
raise ValueError("x88 is not on the board: %s." % repr(x88))
|
|
|
|
return cls("abcdefgh"[x88 & 7] + "87654321"[x88 >> 4])
|
|
|
|
@classmethod
|
|
def from_rank_and_file(cls, rank, file):
|
|
"""Creates a square object from rank and file.
|
|
|
|
:param rank:
|
|
An integer between 1 and 8.
|
|
:param file:
|
|
The rank as a letter between `"a"` and `"h"`.
|
|
"""
|
|
if rank < 1 or rank > 8:
|
|
raise ValueError("Expected rank to be between 1 and 8: %s." % repr(rank))
|
|
|
|
if not file in ["a", "b", "c", "d", "e", "f", "g", "h"]:
|
|
raise ValueError("Expected the file to be a letter between 'a' and 'h': %s." % repr(file))
|
|
|
|
return cls(file + str(rank))
|
|
|
|
@classmethod
|
|
def from_x_and_y(cls, x, y):
|
|
"""Creates a square object from x and y coordinates.
|
|
|
|
:param x:
|
|
An integer between 0 and 7 where 0 is the a-file.
|
|
:param y:
|
|
An integer between 0 and 7 where 0 is the first rank.
|
|
"""
|
|
return cls("abcdefgh"[x] + "12345678"[y])
|
|
|
|
@property
|
|
def name(self):
|
|
"""The algebraic name of the square."""
|
|
return self.__name
|
|
|
|
@property
|
|
def file(self):
|
|
"""The file as a letter between `"a"` and `"h"`."""
|
|
return self.__file
|
|
|
|
@property
|
|
def x(self):
|
|
"""The x-coordinate, starting with 0 for the a-file."""
|
|
return self.__x
|
|
|
|
@property
|
|
def rank(self):
|
|
"""The rank as an integer between 1 and 8."""
|
|
return self.__rank
|
|
|
|
@property
|
|
def y(self):
|
|
"""The y-coordinate, starting with 0 for the first rank."""
|
|
return self.__y
|
|
|
|
@property
|
|
def x88(self):
|
|
"""The `x88 <http://en.wikipedia.org/wiki/Board_representation_(chess)#0x88_method>`_
|
|
index of the square."""
|
|
return self.__x88
|
|
|
|
def is_dark(self):
|
|
""":return: Whether it is a dark square."""
|
|
return (self.__x - self.__y % 2) == 0
|
|
|
|
def is_light(self):
|
|
""":return: Whether it is a light square."""
|
|
return not self.is_dark()
|
|
|
|
def is_backrank(self):
|
|
""":return: Whether the square is on either sides backrank."""
|
|
return self.__y == 0 or self.__y == 7
|
|
|
|
def __str__(self):
|
|
return self.__name
|
|
|
|
def __repr__(self):
|
|
return "Square('%s')" % self.__name
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, Square) and self.__name == other.name
|
|
|
|
def __ne__(self, other):
|
|
return not self.__eq__(other)
|
|
|
|
def __hash__(self):
|
|
return self.__x88
|
|
|
|
|
|
class Move(object):
|
|
"""Represents a move.
|
|
"""
|
|
|
|
__uci_move_regex = re.compile(r"^([a-h][1-8])([a-h][1-8])([rnbq]?)$")
|
|
|
|
def __init__(self, source, target, promotion=None):
|
|
if not isinstance(source, Square):
|
|
raise TypeError("Expected source to be a Square.")
|
|
self.__source = source
|
|
|
|
if not isinstance(target, Square):
|
|
raise TypeError("Expected target to be a Square.")
|
|
self.__target = target
|
|
|
|
if not promotion:
|
|
self.__promotion = None
|
|
self.__full_promotion = None
|
|
else:
|
|
promotion = promotion.lower()
|
|
if promotion == "n" or promotion == "knight":
|
|
self.__promotion = "n"
|
|
self.__full_promotion = "knight"
|
|
elif promotion == "b" or promotion == "bishop":
|
|
self.__promotion = "b"
|
|
self.__full_promotion = "bishop"
|
|
elif promotion == "r" or promotion == "rook":
|
|
self.__promotion = "r"
|
|
self.__full_promotion = "rook"
|
|
elif promotion == "q" or promotion == "queen":
|
|
self.__promotion = "q"
|
|
self.__full_promotion = "queen"
|
|
else:
|
|
raise ValueError("Expected promotion type, got: %s." % repr(promotion))
|
|
|
|
@classmethod
|
|
def from_uci(cls, uci):
|
|
"""The UCI move string like `"a1a2"` or `"b7b8q"`."""
|
|
if uci == "0000":
|
|
return cls.get_null()
|
|
|
|
match = cls.__uci_move_regex.match(uci)
|
|
|
|
return cls(
|
|
source=Square(match.group(1)),
|
|
target=Square(match.group(2)),
|
|
promotion=match.group(3) or None)
|
|
|
|
@classmethod
|
|
def get_null(cls):
|
|
""":return: A null move."""
|
|
return cls(Square("a1"), Square("a1"))
|
|
|
|
@property
|
|
def source(self):
|
|
"""The source square."""
|
|
return self.__source
|
|
|
|
@property
|
|
def target(self):
|
|
"""The target square."""
|
|
return self.__target
|
|
|
|
@property
|
|
def promotion(self):
|
|
"""The promotion type as `None`, `"r"`, `"n"`, `"b"` or `"q"`."""
|
|
return self.__promotion
|
|
|
|
@property
|
|
def full_promotion(self):
|
|
"""Like `promotion`, but with full piece type names."""
|
|
return self.__full_promotion
|
|
|
|
@property
|
|
def uci(self):
|
|
"""The UCI move string like `"a1a2"` or `"b7b8q"`."""
|
|
if self.is_null():
|
|
return "0000"
|
|
else:
|
|
if self.__promotion:
|
|
return self.__source.name + self.__target.name + self.__promotion
|
|
else:
|
|
return self.__source.name + self.__target.name
|
|
|
|
def is_null(self):
|
|
""":return: Whether the move is a null move."""
|
|
return self.__source == self.__target
|
|
|
|
def __nonzero__(self):
|
|
return not self.is_null()
|
|
|
|
def __str__(self):
|
|
return self.uci
|
|
|
|
def __repr__(self):
|
|
return "Move.from_uci(%s)" % repr(self.uci)
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, Move) and self.uci == other.uci
|
|
|
|
def __ne__(self, other):
|
|
return not self.__eq__(other)
|
|
|
|
def __hash__(self):
|
|
return hash(self.uci)
|
|
|
|
|
|
MoveInfo = collections.namedtuple("MoveInfo", [
|
|
"move",
|
|
"piece",
|
|
"captured",
|
|
"san",
|
|
"is_enpassant",
|
|
"is_king_side_castle",
|
|
"is_queen_side_castle",
|
|
"is_castle",
|
|
"is_check",
|
|
"is_checkmate"])
|
|
|
|
|
|
class Position(object):
|
|
"""Represents a chess position.
|
|
|
|
:param fen:
|
|
Optional. The FEN of the position. Defaults to the standard
|
|
chess start position.
|
|
"""
|
|
|
|
__san_regex = re.compile('^([NBKRQ])?([a-h])?([1-8])?x?([a-h][1-8])(=[NBRQ])?(\+|#)?$')
|
|
|
|
def __init__(self, fen=START_FEN):
|
|
self.__castling = "KQkq"
|
|
self.fen = fen
|
|
|
|
def copy(self):
|
|
"""Gets a copy of the position. The copy will not change when the
|
|
original instance is changed.
|
|
|
|
:return:
|
|
An exact copy of the positon.
|
|
"""
|
|
return Position(self.fen)
|
|
|
|
def __get_square_index(self, square_or_int):
|
|
if type(square_or_int) is int:
|
|
# Validate the index by passing it through the constructor.
|
|
return Square.from_x88(square_or_int).x88
|
|
elif isinstance(square_or_int, str):
|
|
return Square(square_or_int).x88
|
|
elif type(square_or_int) is Square:
|
|
return square_or_int.x88
|
|
else:
|
|
raise TypeError(
|
|
"Expected integer or Square, got: %s." % repr(square_or_int))
|
|
|
|
def __getitem__(self, key):
|
|
return self.__board[self.__get_square_index(key)]
|
|
|
|
def __setitem__(self, key, value):
|
|
if value is None or type(value) is Piece:
|
|
self.__board[self.__get_square_index(key)] = value
|
|
else:
|
|
raise TypeError("Expected Piece or None, got: %s." % repr(value))
|
|
|
|
def __delitem__(self, key):
|
|
self.__board[self.__get_square_index(key)] = None
|
|
|
|
def clear_board(self):
|
|
"""Removes all pieces from the board."""
|
|
self.__board = [None] * 128
|
|
|
|
def reset(self):
|
|
"""Resets to the standard chess start position."""
|
|
self.set_fen(START_FEN)
|
|
|
|
def __get_disambiguator(self, move):
|
|
same_rank = False
|
|
same_file = False
|
|
piece = self[move.source]
|
|
|
|
for m in self.get_legal_moves():
|
|
ambig_piece = self[m.source]
|
|
if (piece == ambig_piece and move.source != m.source and
|
|
move.target == m.target):
|
|
if move.source.rank == m.source.rank:
|
|
same_rank = True
|
|
|
|
if move.source.file == m.source.file:
|
|
same_file = True
|
|
|
|
if same_rank and same_file:
|
|
break
|
|
|
|
if same_rank and same_file:
|
|
return move.source.name
|
|
elif same_file:
|
|
return str(move.source.rank)
|
|
elif same_rank:
|
|
return move.source.file
|
|
else:
|
|
return ""
|
|
|
|
def get_move_from_san(self, san):
|
|
"""Gets a move from standard algebraic notation.
|
|
|
|
:param san:
|
|
A move string in standard algebraic notation.
|
|
|
|
:return:
|
|
A Move object.
|
|
|
|
:raise Exception:
|
|
If not exactly one legal move matches.
|
|
"""
|
|
# Castling moves.
|
|
if san == "O-O" or san == "O-O-O":
|
|
rank = 1 if self.turn == "w" else 8
|
|
if san == "O-O":
|
|
return Move(
|
|
source=Square.from_rank_and_file(rank, 'e'),
|
|
target=Square.from_rank_and_file(rank, 'g'))
|
|
else:
|
|
return Move(
|
|
source=Square.from_rank_and_file(rank, 'e'),
|
|
target=Square.from_rank_and_file(rank, 'c'))
|
|
# Regular moves.
|
|
else:
|
|
matches = Position.__san_regex.match(san)
|
|
if not matches:
|
|
raise ValueError("Invalid SAN: %s." % repr(san))
|
|
|
|
piece = Piece.from_color_and_type(
|
|
color=self.turn,
|
|
type=matches.group(1).lower() if matches.group(1) else 'p')
|
|
target = Square(matches.group(4))
|
|
|
|
source = None
|
|
for m in self.get_legal_moves():
|
|
if self[m.source] != piece or m.target != target:
|
|
continue
|
|
|
|
if matches.group(2) and matches.group(2) != m.source.file:
|
|
continue
|
|
if matches.group(3) and matches.group(3) != str(m.source.rank):
|
|
continue
|
|
|
|
# Move matches. Assert it is not ambiguous.
|
|
if source:
|
|
raise Exception(
|
|
"Move is ambiguous: %s matches %s and %s."
|
|
% san, source, m)
|
|
source = m.source
|
|
|
|
if not source:
|
|
raise Exception("No legal move matches %s." % san)
|
|
|
|
return Move(source, target, matches.group(5) or None)
|
|
|
|
def get_move_info(self, move):
|
|
"""Gets information about a move.
|
|
|
|
:param move:
|
|
The move to get information about.
|
|
|
|
:return:
|
|
A named tuple with these properties:
|
|
|
|
`move`:
|
|
The move object.
|
|
`piece`:
|
|
The piece that has been moved.
|
|
`san`:
|
|
The standard algebraic notation of the move.
|
|
`captured`:
|
|
The piece that has been captured or `None`.
|
|
`is_enpassant`:
|
|
A boolean indicating if the move is an en-passant
|
|
capture.
|
|
`is_king_side_castle`:
|
|
Whether it is a king-side castling move.
|
|
`is_queen_side_castle`:
|
|
Whether it is a queen-side castling move.
|
|
`is_castle`:
|
|
Whether it is a castling move.
|
|
`is_check`:
|
|
Whether the move gives check.
|
|
`is_checkmate`:
|
|
Whether the move gives checkmate.
|
|
|
|
:raise Exception:
|
|
If the move is not legal in the position.
|
|
"""
|
|
resulting_position = self.copy().make_move(move)
|
|
|
|
capture = self[move.target]
|
|
piece = self[move.source]
|
|
|
|
# Pawn moves.
|
|
enpassant = False
|
|
if piece.type == "p":
|
|
# En-passant.
|
|
if move.target.file != move.source.file and not capture:
|
|
enpassant = True
|
|
capture = Piece.from_color_and_type(
|
|
color=resulting_position.turn, type='p')
|
|
|
|
# Castling.
|
|
if piece.type == "k":
|
|
is_king_side_castle = move.target.x - move.source.x == 2
|
|
is_queen_side_castle = move.target.x - move.source.x == -2
|
|
else:
|
|
is_king_side_castle = is_queen_side_castle = False
|
|
|
|
# Checks.
|
|
is_check = resulting_position.is_check()
|
|
is_checkmate = resulting_position.is_checkmate()
|
|
|
|
# Generate the SAN.
|
|
san = ""
|
|
if is_king_side_castle:
|
|
san += "o-o"
|
|
elif is_queen_side_castle:
|
|
san += "o-o-o"
|
|
else:
|
|
if piece.type != 'p':
|
|
san += piece.type.upper()
|
|
|
|
san += self.__get_disambiguator(move)
|
|
|
|
if capture:
|
|
if piece.type == 'p':
|
|
san += move.source.file
|
|
san += "x"
|
|
san += move.target.name
|
|
|
|
if move.promotion:
|
|
san += "="
|
|
san += move.promotion.upper()
|
|
|
|
if is_checkmate:
|
|
san += "#"
|
|
elif is_check:
|
|
san += "+"
|
|
|
|
if enpassant:
|
|
san += " (e.p.)"
|
|
|
|
# Return the named tuple.
|
|
return MoveInfo(
|
|
move=move,
|
|
piece=piece,
|
|
captured=capture,
|
|
san=san,
|
|
is_enpassant=enpassant,
|
|
is_king_side_castle=is_king_side_castle,
|
|
is_queen_side_castle=is_queen_side_castle,
|
|
is_castle=is_king_side_castle or is_queen_side_castle,
|
|
is_check=is_check,
|
|
is_checkmate=is_checkmate)
|
|
|
|
def make_move(self, move, validate=True):
|
|
"""Makes a move.
|
|
|
|
:param move:
|
|
The move to make.
|
|
:param validate:
|
|
Defaults to `True`. Whether the move should be validated.
|
|
|
|
:return:
|
|
Making a move changes the position object. The same
|
|
(changed) object is returned for chainability.
|
|
|
|
:raise Exception:
|
|
If the validate parameter is `True` and the move is not
|
|
legal in the position.
|
|
"""
|
|
if validate and move not in self.get_legal_moves():
|
|
raise Exception(
|
|
"%s is not a legal move in the position %s." % (move, self.fen))
|
|
piece = self[move.source]
|
|
capture = self[move.target]
|
|
|
|
# Move the piece.
|
|
self[move.target] = self[move.source]
|
|
del self[move.source]
|
|
|
|
# It is the next players turn.
|
|
self.toggle_turn()
|
|
|
|
# Pawn moves.
|
|
self.ep_file = None
|
|
if piece.type == "p":
|
|
# En-passant.
|
|
if move.target.file != move.source.file and not capture:
|
|
if self.turn == "w":
|
|
self[move.target.x88 - 16] = None
|
|
else:
|
|
self[move.target.x88 + 16] = None
|
|
capture = True
|
|
# If big pawn move, set the en-passant file.
|
|
if abs(move.target.rank - move.source.rank) == 2:
|
|
if self.get_theoretical_ep_right(move.target.file):
|
|
self.ep_file = move.target.file
|
|
|
|
# Promotion.
|
|
if move.promotion:
|
|
self[move.target] = Piece.from_color_and_type(
|
|
color=piece.color, type=move.promotion)
|
|
|
|
# Potential castling.
|
|
if piece.type == "k":
|
|
steps = move.target.x - move.source.x
|
|
if abs(steps) == 2:
|
|
# Queen-side castling.
|
|
if steps == -2:
|
|
rook_target = move.target.x88 + 1
|
|
rook_source = move.target.x88 - 2
|
|
# King-side castling.
|
|
else:
|
|
rook_target = move.target.x88 - 1
|
|
rook_source = move.target.x88 + 1
|
|
self[rook_target] = self[rook_source]
|
|
del self[rook_source]
|
|
|
|
# Increment the half move counter.
|
|
if piece.type == "p" or capture:
|
|
self.half_moves = 0
|
|
else:
|
|
self.half_moves += 1
|
|
|
|
# Increment the move number.
|
|
if self.turn == "w":
|
|
self.ply += 1
|
|
|
|
# Update castling rights.
|
|
for type in ["K", "Q", "k", "q"]:
|
|
if not self.get_theoretical_castling_right(type):
|
|
self.set_castling_right(type, False)
|
|
|
|
return self
|
|
|
|
@property
|
|
def turn(self):
|
|
"""Whos turn it is as `"w"` or `"b"`."""
|
|
return self.__turn
|
|
|
|
@turn.setter
|
|
def turn(self, value):
|
|
if value not in ["w", "b"]:
|
|
raise ValueError(
|
|
"Expected 'w' or 'b' for turn, got: %s." % repr(value))
|
|
self.__turn = value
|
|
|
|
def toggle_turn(self):
|
|
"""Toggles whos turn it is."""
|
|
self.turn = opposite_color(self.turn)
|
|
|
|
def get_castling_right(self, type):
|
|
"""Checks the castling rights.
|
|
|
|
:param type:
|
|
The castling move to check. "K" for king-side castling of
|
|
the white player, "Q" for queen-side castling of the white
|
|
player. "k" and "q" for the corresponding castling moves of
|
|
the black player.
|
|
|
|
:return:
|
|
A boolean indicating whether the player has that castling
|
|
right.
|
|
"""
|
|
if not type in ["K", "Q", "k", "q"]:
|
|
raise KeyError(
|
|
"Expected 'K', 'Q', 'k' or 'q' as a castling type, got: %s." % repr(type))
|
|
return type in self.__castling
|
|
|
|
def get_theoretical_castling_right(self, type):
|
|
"""Checks if a player could have a castling right in theory from
|
|
looking just at the piece positions.
|
|
|
|
:param type:
|
|
The castling move to check. See
|
|
`Position.get_castling_right(type)` for values.
|
|
|
|
:return:
|
|
A boolean indicating whether the player could theoretically
|
|
have that castling right.
|
|
"""
|
|
if not type in ["K", "Q", "k", "q"]:
|
|
raise KeyError(
|
|
"Expected 'K', 'Q', 'k' or 'q' as a castling type, got: %s."
|
|
% repr(type))
|
|
if type == "K" or type == "Q":
|
|
if self["e1"] != Piece("K"):
|
|
return False
|
|
if type == "K":
|
|
return self["h1"] == Piece("R")
|
|
elif type == "Q":
|
|
return self["a1"] == Piece("R")
|
|
elif type == "k" or type == "q":
|
|
if self["e8"] != Piece("k"):
|
|
return False
|
|
if type == "k":
|
|
return self["h8"] == Piece("r")
|
|
elif type == "q":
|
|
return self["a8"] == Piece("r")
|
|
|
|
def get_theoretical_ep_right(self, file):
|
|
"""Checks if a player could have an ep-move in theory from
|
|
looking just at the piece positions.
|
|
|
|
:param file:
|
|
The file to check as a letter between `"a"` and `"h"`.
|
|
|
|
:return:
|
|
A boolean indicating whether the player could theoretically
|
|
have that en-passant move.
|
|
"""
|
|
if not file in ["a", "b", "c", "d", "e", "f", "g", "h"]:
|
|
raise KeyError(
|
|
"Expected a letter between 'a' and 'h' for the file, got: %s."
|
|
% repr(file))
|
|
|
|
# Check there is a pawn.
|
|
pawn_square = Square.from_rank_and_file(
|
|
rank=4 if self.turn == "b" else 5, file=file)
|
|
opposite_color_pawn = Piece.from_color_and_type(
|
|
color=opposite_color(self.turn), type="p")
|
|
if self[pawn_square] != opposite_color_pawn:
|
|
return False
|
|
|
|
# Check the square below is empty.
|
|
square_below = Square.from_rank_and_file(
|
|
rank=3 if self.turn == "b" else 6, file=file)
|
|
if self[square_below]:
|
|
return False
|
|
|
|
# Check there is a pawn of the other color on a neighbor file.
|
|
f = ord(file) - ord("a")
|
|
p = Piece("p")
|
|
P = Piece("P")
|
|
if self.turn == "b":
|
|
if f > 0 and self[Square.from_x_and_y(f - 1, 3)] == p:
|
|
return True
|
|
elif f < 7 and self[Square.from_x_and_y(f + 1, 3)] == p:
|
|
return True
|
|
else:
|
|
if f > 0 and self[Square.from_x_and_y(f - 1, 4)] == P:
|
|
return True
|
|
elif f < 7 and self[Square.from_x_and_y(f + 1, 4)] == P:
|
|
return True
|
|
return False
|
|
|
|
def set_castling_right(self, type, status):
|
|
"""Sets a castling right.
|
|
|
|
:param type:
|
|
`"K"`, `"Q"`, `"k"`, or `"q"` as used by
|
|
`Position.get_castling_right(type)`.
|
|
:param status:
|
|
A boolean indicating whether that castling right should be
|
|
granted or denied.
|
|
"""
|
|
if not type in ["K", "Q", "k", "q"]:
|
|
raise KeyError(
|
|
"Expected 'K', 'Q', 'k' or 'q' as a castling type, got: %s."
|
|
% repr(type))
|
|
|
|
castling = ""
|
|
for t in ["K", "Q", "k", "q"]:
|
|
if type == t:
|
|
if status:
|
|
castling += t
|
|
elif self.get_castling_right(t):
|
|
castling += t
|
|
self.__castling = castling
|
|
|
|
@property
|
|
def ep_file(self):
|
|
"""The en-passant file as a lowercase letter between `"a"` and
|
|
`"h"` or `None`."""
|
|
return self.__ep_file
|
|
|
|
@ep_file.setter
|
|
def ep_file(self, value):
|
|
if not value in ["a", "b", "c", "d", "e", "f", "g", "h", None]:
|
|
raise ValueError(
|
|
"Expected None or a letter between 'a' and 'h' for the "
|
|
"en-passant file, got: %s." % repr(value))
|
|
|
|
self.__ep_file = value
|
|
|
|
@property
|
|
def half_moves(self):
|
|
"""The number of half-moves since the last capture or pawn move."""
|
|
return self.__half_moves
|
|
|
|
@half_moves.setter
|
|
def half_moves(self, value):
|
|
if type(value) is not int:
|
|
raise TypeError(
|
|
"Expected integer for half move count, got: %s." % repr(value))
|
|
if value < 0:
|
|
raise ValueError("Half move count must be >= 0.")
|
|
|
|
self.__half_moves = value
|
|
|
|
@property
|
|
def ply(self):
|
|
"""The number of this move. The game starts at 1 and the counter
|
|
is incremented every time white moves.
|
|
"""
|
|
return self.__ply
|
|
|
|
@ply.setter
|
|
def ply(self, value):
|
|
if type(value) is not int:
|
|
raise TypeError(
|
|
"Expected integer for ply count, got: %s." % repr(value))
|
|
if value < 1:
|
|
raise ValueError("Ply count must be >= 1.")
|
|
self.__ply = value
|
|
|
|
def get_piece_counts(self, color = "wb"):
|
|
"""Counts the pieces on the board.
|
|
|
|
:param color:
|
|
Defaults to `"wb"`. A color to filter the pieces by. Valid
|
|
values are "w", "b", "wb" and "bw".
|
|
|
|
:return:
|
|
A dictionary of piece counts, keyed by lowercase piece type
|
|
letters.
|
|
"""
|
|
if not color in ["w", "b", "wb", "bw"]:
|
|
raise KeyError(
|
|
"Expected color filter to be one of 'w', 'b', 'wb', 'bw', "
|
|
"got: %s." % repr(color))
|
|
|
|
counts = {
|
|
"p": 0,
|
|
"b": 0,
|
|
"n": 0,
|
|
"r": 0,
|
|
"k": 0,
|
|
"q": 0,
|
|
}
|
|
for piece in self.__board:
|
|
if piece and piece.color in color:
|
|
counts[piece.type] += 1
|
|
return counts
|
|
|
|
def get_king(self, color):
|
|
"""Gets the square of the king.
|
|
|
|
:param color:
|
|
`"w"` for the white players king. `"b"` for the black
|
|
players king.
|
|
|
|
:return:
|
|
The first square with a matching king or `None` if that
|
|
player has no king.
|
|
"""
|
|
if not color in ["w", "b"]:
|
|
raise KeyError("Invalid color: %s." % repr(color))
|
|
|
|
for x88, piece in enumerate(self.__board):
|
|
if piece and piece.color == color and piece.type == "k":
|
|
return Square.from_x88(x88)
|
|
|
|
@property
|
|
def fen(self):
|
|
"""The FEN string representing the position."""
|
|
# Board setup.
|
|
empty = 0
|
|
fen = ""
|
|
for y in range(7, -1, -1):
|
|
for x in range(0, 8):
|
|
square = Square.from_x_and_y(x, y)
|
|
|
|
# Add pieces.
|
|
if not self[square]:
|
|
empty += 1
|
|
else:
|
|
if empty > 0:
|
|
fen += str(empty)
|
|
empty = 0
|
|
fen += self[square].symbol
|
|
|
|
# Boarder of the board.
|
|
if empty > 0:
|
|
fen += str(empty)
|
|
if not (x == 7 and y == 0):
|
|
fen += "/"
|
|
empty = 0
|
|
|
|
if self.ep_file and self.get_theoretical_ep_right(self.ep_file):
|
|
ep_square = self.ep_file + ("3" if self.turn == "b" else "6")
|
|
else:
|
|
ep_square = "-"
|
|
|
|
# Join the parts together.
|
|
return " ".join([
|
|
fen,
|
|
self.turn,
|
|
self.__castling if self.__castling else "-",
|
|
ep_square,
|
|
str(self.half_moves),
|
|
str(self.__ply)])
|
|
|
|
@fen.setter
|
|
def fen(self, fen):
|
|
# Split into 6 parts.
|
|
tokens = fen.split()
|
|
if len(tokens) != 6:
|
|
raise Exception("A FEN does not consist of 6 parts.")
|
|
|
|
# Check that the position part is valid.
|
|
rows = tokens[0].split("/")
|
|
assert len(rows) == 8
|
|
for row in rows:
|
|
field_sum = 0
|
|
previous_was_number = False
|
|
for char in row:
|
|
if char in "12345678":
|
|
if previous_was_number:
|
|
raise Exception(
|
|
"Position part of the FEN is invalid: "
|
|
"Multiple numbers immediately after each other.")
|
|
field_sum += int(char)
|
|
previous_was_number = True
|
|
elif char in "pnbrkqPNBRKQ":
|
|
field_sum += 1
|
|
previous_was_number = False
|
|
else:
|
|
raise Exception(
|
|
"Position part of the FEN is invalid: "
|
|
"Invalid character in the position part of the FEN.")
|
|
|
|
if field_sum != 8:
|
|
Exception(
|
|
"Position part of the FEN is invalid: "
|
|
"Row with invalid length.")
|
|
|
|
# Check that the other parts are valid.
|
|
if not tokens[1] in ["w", "b"]:
|
|
raise Exception(
|
|
"Turn part of the FEN is invalid: Expected b or w.")
|
|
if not re.compile(r"^(KQ?k?q?|Qk?q?|kq?|q|-)$").match(tokens[2]):
|
|
raise Exception("Castling part of the FEN is invalid.")
|
|
if not re.compile(r"^(-|[a-h][36])$").match(tokens[3]):
|
|
raise Exception("En-passant part of the FEN is invalid.")
|
|
if not re.compile(r"^(0|[1-9][0-9]*)$").match(tokens[4]):
|
|
raise Exception("Half move part of the FEN is invalid.")
|
|
if not re.compile(r"^[1-9][0-9]*$").match(tokens[5]):
|
|
raise Exception("Ply part of the FEN is invalid.")
|
|
|
|
# Set pieces on the board.
|
|
self.__board = [None] * 128
|
|
i = 0
|
|
for symbol in tokens[0]:
|
|
if symbol == "/":
|
|
i += 8
|
|
elif symbol in "12345678":
|
|
i += int(symbol)
|
|
else:
|
|
self.__board[i] = Piece(symbol)
|
|
i += 1
|
|
|
|
# Set the turn.
|
|
self.__turn = tokens[1]
|
|
|
|
# Set the castling rights.
|
|
for type in ["K", "Q", "k", "q"]:
|
|
self.set_castling_right(type, type in tokens[2])
|
|
|
|
# Set the en-passant file.
|
|
if tokens[3] == "-":
|
|
self.__ep_file = None
|
|
else:
|
|
self.__ep_file = tokens[3][0]
|
|
|
|
# Set the move counters.
|
|
self.__half_moves = int(tokens[4])
|
|
self.__ply = int(tokens[5])
|
|
|
|
def is_king_attacked(self, color):
|
|
""":return: Whether the king of the given color is attacked.
|
|
|
|
:param color: `"w"` or `"b"`.
|
|
"""
|
|
square = self.get_king(color)
|
|
if square:
|
|
return self.is_attacked(opposite_color(color), square)
|
|
else:
|
|
return False
|
|
|
|
def get_pseudo_legal_moves(self):
|
|
""":yield: Pseudo legal moves in the current position."""
|
|
PAWN_OFFSETS = {
|
|
"b": [16, 32, 17, 15],
|
|
"w": [-16, -32, -17, -15]
|
|
}
|
|
|
|
PIECE_OFFSETS = {
|
|
"n": [-18, -33, -31, -14, 18, 33, 31, 14],
|
|
"b": [-17, -15, 17, 15],
|
|
"r": [-16, 1, 16, -1],
|
|
"q": [-17, -16, -15, 1, 17, 16, 15, -1],
|
|
"k": [-17, -16, -15, 1, 17, 16, 15, -1]
|
|
}
|
|
|
|
for x88, piece in enumerate(self.__board):
|
|
# Skip pieces of the opponent.
|
|
if not piece or piece.color != self.turn:
|
|
continue
|
|
|
|
square = Square.from_x88(x88)
|
|
|
|
# Pawn moves.
|
|
if piece.type == "p":
|
|
# Single square ahead. Do not capture.
|
|
target = Square.from_x88(x88 + PAWN_OFFSETS[self.turn][0])
|
|
if not self[target]:
|
|
# Promotion.
|
|
if target.is_backrank():
|
|
for promote_to in "bnrq":
|
|
yield Move(square, target, promote_to)
|
|
else:
|
|
yield Move(square, target)
|
|
|
|
# Two squares ahead. Do not capture.
|
|
if (self.turn == "w" and square.rank == 2) or (self.turn == "b" and square.rank == 7):
|
|
target = Square.from_x88(square.x88 + PAWN_OFFSETS[self.turn][1])
|
|
if not self[target]:
|
|
yield Move(square, target)
|
|
|
|
# Pawn captures.
|
|
for j in [2, 3]:
|
|
target_index = square.x88 + PAWN_OFFSETS[self.turn][j]
|
|
if target_index & 0x88:
|
|
continue
|
|
target = Square.from_x88(target_index)
|
|
if self[target] and self[target].color != self.turn:
|
|
# Promotion.
|
|
if target.is_backrank():
|
|
for promote_to in "bnrq":
|
|
yield Move(square, target, promote_to)
|
|
else:
|
|
yield Move(square, target)
|
|
# En-passant.
|
|
elif not self[target] and target.file == self.ep_file:
|
|
yield Move(square, target)
|
|
# Other pieces.
|
|
else:
|
|
for offset in PIECE_OFFSETS[piece.type]:
|
|
target_index = square.x88
|
|
while True:
|
|
target_index += offset
|
|
if target_index & 0x88:
|
|
break
|
|
target = Square.from_x88(target_index)
|
|
if not self[target]:
|
|
yield Move(square, target)
|
|
else:
|
|
if self[target].color == self.turn:
|
|
break
|
|
yield Move(square, target)
|
|
break
|
|
|
|
# Knight and king do not go multiple times in their
|
|
# direction.
|
|
if piece.type in ["n", "k"]:
|
|
break
|
|
|
|
opponent = opposite_color(self.turn)
|
|
|
|
# King-side castling.
|
|
k = "k" if self.turn == "b" else "K"
|
|
if self.get_castling_right(k):
|
|
of = self.get_king(self.turn).x88
|
|
to = of + 2
|
|
if not self[of + 1] and not self[to] and not self.is_check() and not self.is_attacked(opponent, Square.from_x88(of + 1)) and not self.is_attacked(opponent, Square.from_x88(to)):
|
|
yield Move(Square.from_x88(of), Square.from_x88(to))
|
|
|
|
# Queen-side castling
|
|
q = "q" if self.turn == "b" else "Q"
|
|
if self.get_castling_right(q):
|
|
of = self.get_king(self.turn).x88
|
|
to = of - 2
|
|
|
|
if not self[of - 1] and not self[of - 2] and not self[of - 3] and not self.is_check() and not self.is_attacked(opponent, Square.from_x88(of - 1)) and not self.is_attacked(opponent, Square.from_x88(to)):
|
|
yield Move(Square.from_x88(of), Square.from_x88(to))
|
|
|
|
def get_legal_moves(self):
|
|
""":yield: All legal moves in the current position."""
|
|
for move in self.get_pseudo_legal_moves():
|
|
potential_position = self.copy()
|
|
potential_position.make_move(move, False)
|
|
if not potential_position.is_king_attacked(self.turn):
|
|
yield move
|
|
|
|
def get_attackers(self, color, square):
|
|
"""Gets the attackers of a specific square.
|
|
|
|
:param color:
|
|
Filter attackers by this piece color.
|
|
:param square:
|
|
The square to check for.
|
|
|
|
:yield:
|
|
Source squares of the attack.
|
|
"""
|
|
if color not in ["b", "w"]:
|
|
raise KeyError("Invalid color: %s." % repr(color))
|
|
|
|
ATTACKS = [
|
|
20, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 20, 0,
|
|
0, 20, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 20, 0, 0,
|
|
0, 0, 20, 0, 0, 0, 0, 24, 0, 0, 0, 0, 20, 0, 0, 0,
|
|
0, 0, 0, 20, 0, 0, 0, 24, 0, 0, 0, 20, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 20, 0, 0, 24, 0, 0, 20, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 20, 2, 24, 2, 20, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 2, 53, 56, 53, 2, 0, 0, 0, 0, 0, 0,
|
|
24, 24, 24, 24, 24, 24, 56, 0, 56, 24, 24, 24, 24, 24, 24, 0,
|
|
0, 0, 0, 0, 0, 2, 53, 56, 53, 2, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 20, 2, 24, 2, 20, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 20, 0, 0, 24, 0, 0, 20, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 20, 0, 0, 0, 24, 0, 0, 0, 20, 0, 0, 0, 0,
|
|
0, 0, 20, 0, 0, 0, 0, 24, 0, 0, 0, 0, 20, 0, 0, 0,
|
|
0, 20, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 20, 0, 0,
|
|
20, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 20
|
|
]
|
|
|
|
RAYS = [
|
|
17, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 15, 0,
|
|
0, 17, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 15, 0, 0,
|
|
0, 0, 17, 0, 0, 0, 0, 16, 0, 0, 0, 0, 15, 0, 0, 0,
|
|
0, 0, 0, 17, 0, 0, 0, 16, 0, 0, 0, 15, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 17, 0, 0, 16, 0, 0, 15, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 17, 0, 16, 0, 15, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 17, 16, 15, 0, 0, 0, 0, 0, 0, 0,
|
|
1, 1, 1, 1, 1, 1, 1, 0, -1, -1, -1, -1, -1, -1, -1, 0,
|
|
0, 0, 0, 0, 0, 0, -15, -16, -17, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, -15, 0, -16, 0, -17, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, -15, 0, 0, -16, 0, 0, -17, 0, 0, 0, 0, 0,
|
|
0, 0, 0, -15, 0, 0, 0, -16, 0, 0, 0, -17, 0, 0, 0, 0,
|
|
0, 0, -15, 0, 0, 0, 0, -16, 0, 0, 0, 0, -17, 0, 0, 0,
|
|
0, -15, 0, 0, 0, 0, 0, -16, 0, 0, 0, 0, 0, -17, 0, 0,
|
|
-15, 0, 0, 0, 0, 0, 0, -16, 0, 0, 0, 0, 0, 0, -17
|
|
]
|
|
|
|
SHIFTS = {
|
|
"p": 0,
|
|
"n": 1,
|
|
"b": 2,
|
|
"r": 3,
|
|
"q": 4,
|
|
"k": 5
|
|
}
|
|
|
|
for x88, piece in enumerate(self.__board):
|
|
if not piece or piece.color != color:
|
|
continue
|
|
source = Square.from_x88(x88)
|
|
|
|
difference = source.x88 - square.x88
|
|
index = difference + 119
|
|
|
|
if ATTACKS[index] & (1 << SHIFTS[piece.type]):
|
|
# Handle pawns.
|
|
if piece.type == "p":
|
|
if difference > 0:
|
|
if piece.color == "w":
|
|
yield source
|
|
else:
|
|
if piece.color == "b":
|
|
yield source
|
|
continue
|
|
|
|
# Handle knights and king.
|
|
if piece.type in ["n", "k"]:
|
|
yield source
|
|
|
|
# Handle the others.
|
|
offset = RAYS[index]
|
|
j = source.x88 + offset
|
|
blocked = False
|
|
while j != square.x88:
|
|
if self[j]:
|
|
blocked = True
|
|
break
|
|
j += offset
|
|
if not blocked:
|
|
yield source
|
|
|
|
def is_attacked(self, color, square):
|
|
"""Checks whether a square is attacked.
|
|
|
|
:param color:
|
|
Check if this player is attacking.
|
|
:param square:
|
|
The square the player might be attacking.
|
|
|
|
:return:
|
|
A boolean indicating whether the given square is attacked
|
|
by the player of the given color.
|
|
"""
|
|
x = list(self.get_attackers(color, square))
|
|
return len(x) > 0
|
|
|
|
def is_check(self):
|
|
""":return: Whether the current player is in check."""
|
|
return self.is_king_attacked(self.turn)
|
|
|
|
def is_checkmate(self):
|
|
""":return: Whether the current player has been checkmated."""
|
|
if not self.is_check():
|
|
return False
|
|
else:
|
|
arr = list(self.get_legal_moves())
|
|
return len(arr) == 0
|
|
|
|
def is_stalemate(self):
|
|
""":return: Whether the current player is in stalemate."""
|
|
if self.is_check():
|
|
return False
|
|
else:
|
|
arr = list(self.get_legal_moves())
|
|
return len(arr) == 0
|
|
|
|
def is_insufficient_material(self):
|
|
"""Checks if there is sufficient material to mate.
|
|
|
|
Mating is impossible in:
|
|
|
|
* A king versus king endgame.
|
|
* A king with bishop versus king endgame.
|
|
* A king with knight versus king endgame.
|
|
* A king with bishop versus king with bishop endgame, where both
|
|
bishops are on the same color. Same goes for additional
|
|
bishops on the same color.
|
|
|
|
Assumes that the position is valid and each player has exactly
|
|
one king.
|
|
|
|
:return:
|
|
Whether there is insufficient material to mate.
|
|
"""
|
|
piece_counts = self.get_piece_counts()
|
|
if sum(piece_counts.values()) == 2:
|
|
# King versus king.
|
|
return True
|
|
elif sum(piece_counts.values()) == 3:
|
|
# King and knight or bishop versus king.
|
|
if piece_counts["b"] == 1 or piece_counts["n"] == 1:
|
|
return True
|
|
elif sum(piece_counts.values()) == 2 + piece_counts["b"]:
|
|
# Each player with only king and any number of bishops, where all
|
|
# bishops are on the same color.
|
|
white_has_bishop = self.get_piece_counts("w")["b"] != 0
|
|
black_has_bishop = self.get_piece_counts("b")["b"] != 0
|
|
if white_has_bishop and black_has_bishop:
|
|
color = None
|
|
for x88, piece in enumerate(self.__board):
|
|
if piece and piece.type == "b":
|
|
square = Square.from_x88(x88)
|
|
if color is not None and color != square.is_light():
|
|
return False
|
|
color = square.is_light()
|
|
return True
|
|
return False
|
|
|
|
def is_game_over(self):
|
|
"""Checks if the game is over.
|
|
|
|
:return:
|
|
Whether the game is over by the rules of chess,
|
|
disregarding that players can agree on a draw, claim a draw
|
|
or resign.
|
|
"""
|
|
return (self.is_checkmate() or self.is_stalemate() or
|
|
self.is_insufficient_material())
|
|
|
|
def __str__(self):
|
|
return self.fen
|
|
|
|
def __repr__(self):
|
|
return "Position.from_fen(%s)" % repr(self.fen)
|
|
|
|
def __eq__(self, other):
|
|
return self.fen == other.fen
|
|
|
|
def __ne__(self, other):
|
|
return self.fen != other.fen
|
|
|
|
|
|
class Board(QWidget):
|
|
|
|
def __init__(self, parent):
|
|
super(Board, self).__init__()
|
|
self.margin = 0.1
|
|
self.padding = 0.06
|
|
self.showCoordinates = True
|
|
self.lightSquareColor = QColor(255, 255, 255)
|
|
self.darkSquareColor = QColor(100, 100, 255)
|
|
self.borderColor = QColor(100, 100, 200)
|
|
self.shadowWidth = 2
|
|
self.rotation = 0
|
|
self.ply = 1
|
|
self.setWindowTitle('Chess')
|
|
self.backgroundPixmap = QPixmap(plugin_super_class.path_to_data('chess') + "background.png")
|
|
|
|
self.draggedSquare = None
|
|
self.dragPosition = None
|
|
|
|
self.position = Position()
|
|
|
|
self.parent = parent
|
|
|
|
# Load piece set.
|
|
self.pieceRenderers = dict()
|
|
for symbol in "PNBRQKpnbrqk":
|
|
piece = Piece(symbol)
|
|
self.pieceRenderers[piece] = QSvgRenderer(plugin_super_class.path_to_data('chess') + "classic-pieces/%s-%s.svg" % (piece.full_color, piece.full_type))
|
|
|
|
def update_title(self, my_move=False):
|
|
if self.position.is_checkmate():
|
|
self.setWindowTitle('Checkmate')
|
|
elif self.position.is_stalemate():
|
|
self.setWindowTitle('Stalemate')
|
|
else:
|
|
self.setWindowTitle('Chess' + (' [Your move]' if my_move else ''))
|
|
|
|
def mousePressEvent(self, e):
|
|
self.dragPosition = e.pos()
|
|
square = self.squareAt(e.pos())
|
|
if self.canDragSquare(square):
|
|
self.draggedSquare = square
|
|
|
|
def mouseMoveEvent(self, e):
|
|
if self.draggedSquare:
|
|
self.dragPosition = e.pos()
|
|
self.repaint()
|
|
|
|
def mouseReleaseEvent(self, e):
|
|
if self.draggedSquare:
|
|
dropSquare = self.squareAt(e.pos())
|
|
if dropSquare == self.draggedSquare:
|
|
self.onSquareClicked(self.draggedSquare)
|
|
elif dropSquare:
|
|
move = self.moveFromDragDrop(self.draggedSquare, dropSquare)
|
|
if move:
|
|
self.position.make_move(move)
|
|
self.parent.move(move)
|
|
self.ply += 1
|
|
self.draggedSquare = None
|
|
self.repaint()
|
|
|
|
def closeEvent(self, *args):
|
|
self.parent.stop_game()
|
|
|
|
def paintEvent(self, event):
|
|
painter = QPainter()
|
|
painter.begin(self)
|
|
|
|
# Light shines from upper left.
|
|
if math.cos(math.radians(self.rotation)) >= 0:
|
|
lightBorderColor = self.borderColor.lighter()
|
|
darkBorderColor = self.borderColor.darker()
|
|
else:
|
|
lightBorderColor = self.borderColor.darker()
|
|
darkBorderColor = self.borderColor.lighter()
|
|
|
|
# Draw the background.
|
|
backgroundBrush = QBrush(Qt.red, self.backgroundPixmap)
|
|
backgroundBrush.setStyle(Qt.TexturePattern)
|
|
painter.fillRect(QRect(QPoint(0, 0), self.size()), backgroundBrush)
|
|
|
|
# Do the rotation.
|
|
painter.save()
|
|
painter.translate(self.width() / 2, self.height() / 2)
|
|
painter.rotate(self.rotation)
|
|
|
|
# Draw the border.
|
|
frameSize = min(self.width(), self.height()) * (1 - self.margin * 2)
|
|
borderSize = min(self.width(), self.height()) * self.padding
|
|
painter.translate(-frameSize / 2, -frameSize / 2)
|
|
painter.fillRect(QRect(0, 0, frameSize, frameSize), self.borderColor)
|
|
painter.setPen(QPen(QBrush(lightBorderColor), self.shadowWidth))
|
|
painter.drawLine(0, 0, 0, frameSize)
|
|
painter.drawLine(0, 0, frameSize, 0)
|
|
painter.setPen(QPen(QBrush(darkBorderColor), self.shadowWidth))
|
|
painter.drawLine(frameSize, 0, frameSize, frameSize)
|
|
painter.drawLine(0, frameSize, frameSize, frameSize)
|
|
|
|
# Draw the squares.
|
|
painter.translate(borderSize, borderSize)
|
|
squareSize = (frameSize - 2 * borderSize) / 8.0
|
|
for x in range(0, 8):
|
|
for y in range(0, 8):
|
|
rect = QRect(x * squareSize, y * squareSize, squareSize, squareSize)
|
|
if (x - y) % 2 == 0:
|
|
painter.fillRect(rect, QBrush(self.lightSquareColor))
|
|
else:
|
|
painter.fillRect(rect, QBrush(self.darkSquareColor))
|
|
|
|
# Draw the inset.
|
|
painter.setPen(QPen(QBrush(darkBorderColor), self.shadowWidth))
|
|
painter.drawLine(0, 0, 0, squareSize * 8)
|
|
painter.drawLine(0, 0, squareSize * 8, 0)
|
|
painter.setPen(QPen(QBrush(lightBorderColor), self.shadowWidth))
|
|
painter.drawLine(squareSize * 8, 0, squareSize * 8, squareSize * 8)
|
|
painter.drawLine(0, squareSize * 8, squareSize * 8, squareSize * 8)
|
|
|
|
# Display coordinates.
|
|
if self.showCoordinates:
|
|
painter.setPen(QPen(QBrush(self.borderColor.lighter()), self.shadowWidth))
|
|
coordinateSize = min(borderSize, squareSize)
|
|
font = QFont()
|
|
font.setPixelSize(coordinateSize * 0.6)
|
|
painter.setFont(font)
|
|
for i, rank in enumerate(["8", "7", "6", "5", "4", "3", "2", "1"]):
|
|
pos = QRect(-borderSize, squareSize * i, borderSize, squareSize).center()
|
|
painter.save()
|
|
painter.translate(pos.x(), pos.y())
|
|
painter.rotate(-self.rotation)
|
|
painter.drawText(QRect(-coordinateSize / 2, -coordinateSize / 2, coordinateSize, coordinateSize), Qt.AlignCenter, rank)
|
|
painter.restore()
|
|
for i, file in enumerate(["a", "b", "c", "d", "e", "f", "g", "h"]):
|
|
pos = QRect(squareSize * i, squareSize * 8, squareSize, borderSize).center()
|
|
painter.save()
|
|
painter.translate(pos.x(), pos.y())
|
|
painter.rotate(-self.rotation)
|
|
painter.drawText(QRect(-coordinateSize / 2, -coordinateSize / 2, coordinateSize, coordinateSize), Qt.AlignCenter, file)
|
|
painter.restore()
|
|
|
|
# Draw pieces.
|
|
for x in range(0, 8):
|
|
for y in range(0, 8):
|
|
square = Square.from_x_and_y(x, 7 - y)
|
|
piece = self.position[square]
|
|
if piece and square != self.draggedSquare:
|
|
painter.save()
|
|
painter.translate((x + 0.5) * squareSize, (y + 0.5) * squareSize)
|
|
painter.rotate(-self.rotation)
|
|
self.pieceRenderers[piece].render(painter, QRect(-squareSize / 2, -squareSize / 2, squareSize, squareSize))
|
|
painter.restore()
|
|
|
|
# Draw a floating piece.
|
|
painter.restore()
|
|
if self.draggedSquare:
|
|
piece = self.position[self.draggedSquare]
|
|
if piece:
|
|
painter.save()
|
|
painter.translate(self.dragPosition.x(), self.dragPosition.y())
|
|
painter.rotate(-self.rotation)
|
|
self.pieceRenderers[piece].render(painter, QRect(-squareSize / 2, -squareSize / 2, squareSize, squareSize))
|
|
painter.restore()
|
|
|
|
painter.end()
|
|
|
|
def squareAt(self, point):
|
|
# Undo the rotation.
|
|
transform = QTransform()
|
|
transform.translate(self.width() / 2, self.height() / 2)
|
|
transform.rotate(self.rotation)
|
|
logicalPoint = transform.inverted()[0].map(point)
|
|
|
|
frameSize = min(self.width(), self.height()) * (1 - self.margin * 2)
|
|
borderSize = min(self.width(), self.height()) * self.padding
|
|
squareSize = (frameSize - 2 * borderSize) / 8.0
|
|
x = int(logicalPoint.x() / squareSize + 4)
|
|
y = 7 - int(logicalPoint.y() / squareSize + 4)
|
|
try:
|
|
return Square.from_x_and_y(x, y)
|
|
except IndexError:
|
|
return None
|
|
|
|
def canDragSquare(self, square):
|
|
if (self.ply % 2 == 0 and self.parent.white) or (self.ply % 2 == 1 and not self.parent.white):
|
|
return False
|
|
for move in self.position.get_legal_moves():
|
|
if move.source == square:
|
|
return True
|
|
return False
|
|
|
|
def onSquareClicked(self, square):
|
|
pass
|
|
|
|
def moveFromDragDrop(self, source, target):
|
|
for move in self.position.get_legal_moves():
|
|
if move.source == source and move.target == target:
|
|
if move.promotion:
|
|
dialog = PromotionDialog(self.position[move.source].color, self)
|
|
if dialog.exec_():
|
|
return Move(source, target, dialog.selectedType())
|
|
else:
|
|
return move
|
|
return move
|
|
|
|
|
|
class PromotionDialog(QDialog):
|
|
|
|
def __init__(self, color, parent=None):
|
|
super(PromotionDialog, self).__init__(parent)
|
|
|
|
self.promotionTypes = ["q", "n", "r", "b"]
|
|
|
|
grid = QGridLayout()
|
|
hbox = QHBoxLayout()
|
|
grid.addLayout(hbox, 0, 0)
|
|
|
|
# Add the piece buttons.
|
|
self.buttonGroup = QButtonGroup(self)
|
|
for i, promotionType in enumerate(self.promotionTypes):
|
|
# Create an icon for the piece.
|
|
piece = Piece.from_color_and_type(color, promotionType)
|
|
renderer = QSvgRenderer(plugin_super_class.path_to_data('chess') + "classic-pieces/%s-%s.svg" % (piece.full_color, piece.full_type))
|
|
pixmap = QPixmap(32, 32)
|
|
pixmap.fill(Qt.transparent)
|
|
painter = QPainter()
|
|
painter.begin(pixmap)
|
|
renderer.render(painter, QRect(0, 0, 32, 32))
|
|
painter.end()
|
|
|
|
# Add the button.
|
|
button = QPushButton(QIcon(pixmap), '', self)
|
|
button.setCheckable(True)
|
|
self.buttonGroup.addButton(button, i)
|
|
hbox.addWidget(button)
|
|
|
|
self.buttonGroup.button(0).setChecked(True)
|
|
|
|
# Add the ok and cancel buttons.
|
|
buttons = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok)
|
|
buttons.rejected.connect(self.reject)
|
|
buttons.accepted.connect(self.accept)
|
|
grid.addWidget(buttons, 1, 0)
|
|
|
|
self.setLayout(grid)
|
|
self.setWindowFlags(self.windowFlags() & ~Qt.WindowContextHelpButtonHint)
|
|
|
|
def selectedType(self):
|
|
return self.promotionTypes[self.buttonGroup.checkedId()]
|
|
|
|
|
|
class Chess(plugin_super_class.PluginSuperClass):
|
|
|
|
def __init__(self, *args):
|
|
super(Chess, self).__init__('Chess', 'chess', *args)
|
|
self.game = -1
|
|
self.board = None
|
|
self.white = True
|
|
self.pre = None
|
|
self.last_move = None
|
|
self.is_my_move = False
|
|
|
|
def get_description(self):
|
|
return QApplication.translate("Chess", 'Plugin which allows you to play chess with your friends.')
|
|
|
|
def lossless_packet(self, data, friend_number):
|
|
if data == 'new':
|
|
self.pre = None
|
|
friend = self._profile.get_friend_by_number(friend_number)
|
|
reply = QMessageBox.question(None,
|
|
'New chess game',
|
|
'Friend {} wants to play chess game against you. Start?'.format(friend.name),
|
|
QMessageBox.Yes,
|
|
QMessageBox.No)
|
|
if reply != QMessageBox.Yes:
|
|
self.send_lossless('no', friend_number)
|
|
else:
|
|
self.send_lossless('yes', friend_number)
|
|
self.board = Board(self)
|
|
self.board.show()
|
|
self.game = friend_number
|
|
self.white = False
|
|
self.is_my_move = False
|
|
elif data == 'yes' and friend_number == self.game:
|
|
self.board = Board(self)
|
|
self.board.show()
|
|
self.board.update_title(True)
|
|
self.is_my_move = True
|
|
self.last_move = None
|
|
elif data == 'no':
|
|
self.game = -1
|
|
elif data != self.pre: # move
|
|
self.pre = data
|
|
self.is_my_move = True
|
|
self.last_move = None
|
|
a = Square.from_x_and_y(ord(data[0]) - ord('a'), ord(data[1]) - ord('1'))
|
|
b = Square.from_x_and_y(ord(data[2]) - ord('a'), ord(data[3]) - ord('1'))
|
|
self.board.position.make_move(Move(a, b, data[4] if len(data) == 5 else None))
|
|
self.board.repaint()
|
|
self.board.update_title(True)
|
|
self.board.ply += 1
|
|
|
|
def start_game(self, num):
|
|
self.white = True
|
|
self.send_lossless('new', num)
|
|
self.game = num
|
|
|
|
def resend_move(self):
|
|
if self.is_my_move or self.last_move is None:
|
|
return
|
|
self.send_lossless(str(self.last_move), self.game)
|
|
QTimer.singleShot(1000, self.resend_move)
|
|
|
|
def stop_game(self):
|
|
self.last_move = None
|
|
|
|
def move(self, move):
|
|
self.is_my_move = False
|
|
self.last_move = move
|
|
self.send_lossless(str(move), self.game)
|
|
self.board.update_title()
|
|
QTimer.singleShot(1000, self.resend_move)
|
|
|
|
def get_menu(self, menu, num):
|
|
act = QAction(QApplication.translate("Chess", "Start chess game"), menu)
|
|
act.triggered.connect(lambda: self.start_game(num))
|
|
return [act]
|