Exemplo n.º 1
0
 def _compute_passed_isolated_pawns(
         self, board: SearchBoard,
         piece_list: PieceList) -> Tuple[int, int, int, int]:
     """
     Computes the score for white and black passed and isolated pawns.
     :param board: Board to compute on
     :param piece_list: Piece list
     :return: white passed pawn score, black, white isolated pawn score, black
     """
     white_pawns = board.pieces(chess.PAWN, chess.WHITE).mask
     black_pawns = board.pieces(chess.PAWN, chess.BLACK).mask
     white_passed, black_passed = 0, 0
     white_isolated, black_isolated = 0, 0
     for sq in piece_list.square_list(chess.PAWN, chess.WHITE):
         # Pawn present and it is passed (note that pawn is guaranteed to be here)
         if not self._white_passed_pawns_bbs[sq] & black_pawns:
             white_passed += self.pawn_passed[sq // 8]
         # Pawn present and is isolated
         if not self._isolated_pawns_bbs[sq] & white_pawns:
             white_isolated += self.pawn_isolated
     for sq in piece_list.square_list(chess.PAWN, chess.BLACK):
         if not self._black_passed_pawns_bbs[sq] & white_pawns:
             black_passed += self.pawn_passed[7 - (sq // 8)]
         if not self._isolated_pawns_bbs[sq] & black_pawns:
             black_isolated += self.pawn_isolated
     return white_passed, black_passed, white_isolated, black_isolated
Exemplo n.º 2
0
    def _compute_open_files(self, board: SearchBoard,
                            piece_list: PieceList) -> Tuple[int, int]:
        """
        Computes the score for occupying open files (for rooks and queens)
        :param board: Board to consider
        :param piece_list: Piece list of the board
        :return: White open file score, black open file score
        """
        white_pawns = board.pieces(chess.PAWN, chess.WHITE).mask
        black_pawns = board.pieces(chess.PAWN, chess.BLACK).mask
        pawns = white_pawns | black_pawns
        open_file = lambda s: not (pawns & self._file_bbs[s % 8])
        white_semiopen_file = lambda s: not (white_pawns & self._file_bbs[s % 8
                                                                          ])
        black_semiopen_file = lambda s: not (black_pawns & self._file_bbs[s % 8
                                                                          ])
        white, black = 0, 0
        for sq in piece_list.square_list(chess.ROOK, chess.WHITE):
            if open_file(sq):
                white += self.rook_open_file
            elif white_semiopen_file(sq):
                white += self.rook_semiopen_file
        for sq in piece_list.square_list(chess.ROOK, chess.BLACK):
            if open_file(sq):
                black += self.rook_open_file
            elif black_semiopen_file(sq):
                black += self.rook_semiopen_file

        # Queens
        for sq in piece_list.square_list(chess.QUEEN, chess.WHITE):
            if open_file(sq):
                white += self.queen_open_file
            elif white_semiopen_file(sq):
                white += self.queen_semiopen_file
        for sq in piece_list.square_list(chess.QUEEN, chess.BLACK):
            if open_file(sq):
                black += self.queen_open_file
            elif black_semiopen_file(sq):
                black += self.queen_semiopen_file
        return white, black