Python Piece.klass方法代码示例

# 需要导入模块: from piece import Piece [as 别名]
# 或者: from piece.Piece import klass [as 别名]
    def __init__(self, position, move):

        resulting_position = position.copy().make_move(move)
        captured = position._pieces[move.target._x88]
        piece = position._pieces[move.source._x88]
        ocolor = Piece.opposite_color(position.fen._to_move)

        # Pawn moves.
        enpassant = False
        if Piece.klass(piece) == PAWN:
            # En-passant.
            if move.target.file != move.source.file and not captured:
                enpassant = True
                captured = Piece.from_klass_and_color(PAWN, ocolor)

        # Castling.
        # TODO: Support Chess960.
        # TODO: Validate the castling move.
        if Piece.klass(piece) == KING:
            self.is_king_side_castle = move.target.x - move.source.x == 2
            self.is_queen_side_castle = move.target.x - move.source.x == -2
        else:
            self.is_king_side_castle = self.is_queen_side_castle = False

        # Checks.
        self.is_check = resulting_position.is_check()
        self.is_checkmate = resulting_position.is_checkmate()

        self.move = move
        self.piece = piece
        self.captured = captured
        self.is_enpassant = enpassant

        self._set_text(position)

# 需要导入模块: from piece import Piece [as 别名]
# 或者: from piece.Piece import klass [as 别名]
    def get_piece_counts(self, colors=[WHITE, BLACK]):
        """Counts the pieces on the board.

        :param color:
            list of colors to check. Defualts to black and white

        :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 = {
            PAWN:   0,
            BISHOP: 0,
            KNIGHT: 0,
            ROOK:   0,
            KING:   0,
            QUEEN:  0,
        }
        for piece in self._pieces:
            if piece and Piece.color(piece) in colors:
                counts[Piece.klass(piece)] += 1
        return counts

# 需要导入模块: from piece import Piece [as 别名]
# 或者: from piece.Piece import klass [as 别名]
    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 not color in [BLACK, WHITE]:
            raise KeyError("Invalid color: %s." % repr(color))


        for x88, source in Square._x88_squares.iteritems():

            piece = self._pieces[x88]
            if not piece or Piece.color(piece) != color:
                continue

            difference = x88 - square._x88
            index = difference + X88.ATTACKER_DIFF
            klass = Piece.klass(piece)

            if X88.ATTACKS[index] & (1 << X88.SHIFTS[klass]):
                # Handle pawns.
                if klass == PAWN:
                    if difference > 0:
                        if Piece.color(piece) == WHITE:
                            yield source
                    else:
                        if Piece.color(piece) == BLACK:
                            yield source
                    continue

                # Handle knights and king.
                if klass in [KNIGHT, KING]:
                    yield source

                # Handle the others.
                offset = X88.RAYS[index]
                j = source._x88 + offset
                blocked = False
                while j != square._x88:
                    if self._pieces[j]:
                        blocked = True
                        break
                    j += offset
                if not blocked:
                    yield source

# 需要导入模块: from piece import Piece [as 别名]
# 或者: from piece.Piece import klass [as 别名]
    def to_move(cls, position, san):
        
        san = str(san)

        # Castling moves.
        if san == "O-O" or san == "O-O-O":
            # TODO: Support Chess960, check the castling moves are valid.
            rank = 1 if position.fen.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 = cls.san_regex.match(san)
            if not matches:
                raise ValueError("Invalid SAN: %s." % repr(san))

            if matches.group(1):
                klass = Piece.klass(matches.group(1).lower())
            else:
                klass = PAWN
            piece = Piece.from_klass_and_color(klass, position.fen._to_move)
            target = Square(matches.group(4))

            source = None
            for m in position.get_legal_moves():
                if position._pieces[m.source._x88] != 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 MoveError(
                        "Move is ambiguous: %s matches %s and %s."
                            % san, source, m)
                source = m.source

            if not source:
                raise MoveError("No legal move matches %s." % san)

            return Move(source, target, matches.group(5) or None)

# 需要导入模块: from piece import Piece [as 别名]
# 或者: from piece.Piece import klass [as 别名]
    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()

        # King versus king.
        if sum(piece_counts.values()) == 2:
            return True

        # King and knight or bishop versus king.
        elif sum(piece_counts.values()) == 3:
            if piece_counts["b"] == 1 or piece_counts["n"] == 1:
                return True

        # Each player with only king and any number of bishops, 
        # where all bishops are on the same color.
        elif sum(piece_counts.values()) == 2 + piece_counts[BISHOP]:
            white_has_bishop = self.get_piece_counts([WHITE])[BISHOP] != 0
            black_has_bishop = self.get_piece_counts([BLACK])[BISHOP] != 0
            if white_has_bishop and black_has_bishop:
                color = None
                for square in Square.get_all():
                    p = self._pieces[square._x88]
                    if p and Piece.klass(p) == BISHOP:
                        if color and color != square.is_light():
                            return False
                        color = square.is_light()
                return True
        return False

# 需要导入模块: from piece import Piece [as 别名]
# 或者: from piece.Piece import klass [as 别名]
    def _set_text(self, position):

        move = self.move

        piece_klass = Piece.klass(self.piece)

        # Generate the SAN.
        san = ""
        if self.is_king_side_castle:
            san += "O-O"
        elif self.is_queen_side_castle:
            san += "O-O-O"
        else:
            if piece_klass != PAWN:
                san += Piece.from_klass_and_color(piece_klass, WHITE)

            if position:
                san += self._get_disambiguator(move, position)

            if self.captured:
                if piece_klass == PAWN:
                    san += move.source.file
                san += "x"
            san += move.target.name

            if move.promotion:
                san += "="
                san += move.promotion.upper()

        if self.is_checkmate:
            san += "#"
        elif self.is_check:
            san += "+"

        if self.is_enpassant:
            san += " (e.p.)"

        self._text = san

# 需要导入模块: from piece import Piece [as 别名]
# 或者: from piece.Piece import klass [as 别名]
    def get_pseudo_legal_moves(self, source=None):
        """:yield: Pseudo legal moves in the current position.
         
        :param source: The source square to limit moves or None for
            all possible moves.
        """

        tomove = self.fen._to_move

        for x88 in [ x88 for x88 in Square._x88_squares.keys() 
            if self._pieces[x88] 
            and Piece.color(self._pieces[x88]) == tomove
            and (source is None or x88 == source._x88)]:

            piece = self._pieces[x88]
            klass = Piece.klass(piece)

            # pawn moves
            if klass == PAWN:
                single, double, capleft, capright = X88.PAWN_OFFSETS[tomove]

                # Single square ahead. Do not capture.
                offset = x88 + single
                if not self._pieces[offset]:
                    # Promotion.
                    if X88.is_backrank(offset, tomove):
                        for promote_to in Piece.promote_to:
                            yield Move.from_x88(x88, offset, promote_to)
                    else:
                        yield Move.from_x88(x88, offset)

                    # Two squares ahead. Do not capture.
                    if X88.is_secondrank(x88, tomove):
                        offset = x88 + double
                        if not self._pieces[offset]:
                            yield Move.from_x88(x88, offset)

                # Pawn captures.
                for cap in [capleft, capright]:
                    offset = x88 + cap
                    if offset & X88.X88:
                        continue
                    target = self._pieces[offset]
                    if target and Piece.color(target) != tomove:
                       # Promotion.
                        if X88.is_backrank(offset, tomove):
                            for promote_to in Piece.promote_to:
                                yield Move.from_x88(x88, offset, promote_to)
                        else:
                            yield Move.from_x88(x88, offset)
                   # En-passant.
                    elif not target and offset == self.fen._ep:
                        yield Move.from_x88(target, self.fen._ep)
            
            #piece moves
            else:
                # for each a direction a piece moves in
                for offset in X88.PIECE_OFFSETS[Piece.klass(piece)]:

                    t_x88 = x88 + offset

                    # while we do not fall off the board
                    while not t_x88 & 0x88:
                        
                        # if there was not piece to attack then yield a quiet move
                        if not self._pieces[t_x88]:
                            yield Move.from_x88(x88, t_x88)
                            # do not break out

                        # else there is a piece there
                        else:
                            # if we can attack generate a move
                            if Piece.color(self._pieces[t_x88]) != tomove:
                                yield Move.from_x88(x88, t_x88)
                            # we hit something so break out
                            break

                        # Knight and king do not go multiple times in their direction.
                        if klass in [KNIGHT, KING]:
                            break

                        # travel down the board in the direction
                        t_x88 += offset


        # castling moves
        opponent = Piece.opposite_color(tomove)
        ok = True

        # get possible castling for the side to move
        for castle in [c for c in self.fen._castle_rights if Piece.color(c) == tomove]:

            (square, enum), _ = Piece.castle_squares[castle]
            king = Square(square)

            if Piece.klass(castle) == KING:
                direc = 1
            else:
                direc = -1

#.........这里部分代码省略.........

# 需要导入模块: from piece import Piece [as 别名]
# 或者: from piece.Piece import klass [as 别名]
    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 MoveError:
            If the validate parameter is `True` and the move is not
            legal in the position.
        """

        #if validate:
        if validate:
            if move not in self.get_legal_moves(source=move.source):
                raise MoveError(
                    "%s is not a legal move in the position %s." % (move, self.fen))

        piece = self._pieces[move._source_x88]
        capture = self._pieces[move._target_x88]
        target = move.target
        source = move.source

        # Move the piece.
        self._pieces[move._target_x88] = piece
        self._pieces[move._source_x88] = None

        # It is the next players turn.
        ocolor = Piece.opposite_color(self.fen._to_move)
        self.fen._to_move = ocolor

        # Pawn moves.
        self._ep = None
        if Piece.klass(piece) == PAWN:

            # En-passant.
            if target.x != source.x and not capture:
                offset = 16 if self.fen._to_move == WHITE else -16
                self._pieces[target.x88() + offset] = None
                capture = True

            # If big pawn move, set the en-passant file.
            if abs(target.y - source.y) == 2:
                if self.get_theoretical_ep_right(target.x):
                    self._ep = move.target

        # Promotion.
        if move.promotion:
            self._pieces[move.target._x88] = move.promotion

        # Potential castling.
        if Piece.klass(piece) == KING:
            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._pieces[rook_target] = self._pieces[rook_source]
                self._pieces[rook_source] = None

        # Update castling rights.
        for klass in self.fen._castle_rights:
            if not self.get_theoretical_castling_right(klass):
                self.fen._castle_rights.remove(klass)
                # XXX Castling rights can only be removed 
                #self.set_castling_right(klass, False)


        # Increment the 50 move half move counter.
        if Piece.klass(piece) == PAWN or capture:
            self.fen._fifty_move = 0
        else:
            self.fen._fifty_move += 1

        # Increment the move number.
        if self.fen._to_move == WHITE:
            self.fen._full_move += 1
        
        return self

# 需要导入模块: from piece import Piece [as 别名]
# 或者: from piece.Piece import klass [as 别名]
 def test_klass(self):
     self.assertEqual(piece.PAWN, Piece.klass('P'))