[PYTHON] Implementieren Sie die Umkehrumkehrverarbeitung mit BitBoard

Implementieren Sie die Umkehrung mit BitBoard. Dieses Mal werden wir den Inversionsprozess implementieren. (Der Einfachheit halber werden wir ein 4x4-Beispiel verwenden, aber die Implementierung ist 8x8. W: Shiraishi, B: Kuroishi, x: Kein Stein.)

xxxx
xWBx
xBWx
xxxx

Dieses Board ist mit schwarzen Steinen in BitBoard angeordnet

0000
0010
0100
0000

Und das Arrangement von Shiraishi

0000
0100
0010
0000

Es wird durch zwei Bitfolgen von dargestellt.

Beginn der schwarzen Wende move:

0000
0000
0001
0000

Im Gegensatz zur umgedrehten Steinplatzierung "umgedreht":

0000
0000
0010
0000

Wenn Sie danach fragen, lautet der White-Turn-Inversionsprozess "gegnerisches Brett ^ = gespiegelt"

0000   0000   0000
0100 ^ 0000 = 0100
0010   0010   0000
0000   0000   0000

Auch die Anordnung der schwarzen Steineself_board ^= flipped | moveOderself_board |= flippled | moveErhalten von.

0000   0000   0000
0010 ^ 0000 = 0010
0100   0011   0111
0000   0000   0000

Von nun an werden wir uns darauf konzentrieren, den umgekehrten Shiraishi "gespiegelt" zu finden. Der flippende Shiraishi ist immer in einer der acht Richtungen diagonal nach oben, unten, links und rechts vom Start "bewegen". Beginnen wir zunächst mit der Suche auf der linken Seite. Die Inversion nach links entspricht einem der folgenden beiden Muster.

BWo
BWWo

(W: Shiraishi, B: Kuroishi, o: Beginn der schwarzen Kurve.)

Verschieben Sie den Start nach links, um die Platzierung der weißen Zahlen und das Produkt zu erhalten. Verschieben Sie das Ergebnis weiter nach links und nehmen Sie das Produkt mit der weißen Zahlenposition, um es umzudrehen. (Bei 8x8 ergeben insgesamt 6 Schichten ein "Umdrehen".) Sie müssen jedoch sicherstellen, dass ein weißer Stein vorhanden ist, der vor der Berechnung nach links umgedreht werden kann. Dies ist dasselbe wie So finden Sie eine legale Hand.

class Board:
    BLACK, WHITE = True, False

    def __init__(self, black=0x000008100000, white=0x000010080000):
        self.board = {Board.BLACK: black, Board.WHITE: white}

    def flipped(self, player, move):
        """ returns flipped stones """
        flipped = 0b0
        player_board = self.board[player]
        opponent_board = self.board[not player]
        blank_board = ~(player_board | opponent_board)

        masked_opponent_board = opponent_board & 0x7e7e7e7e7e7e7e7e

        #Stellen Sie sicher, dass es einen weißen Stein gibt, der nach links gedreht werden kann
        temp = player_board << 1 & masked_opponent_board
        temp |= temp << 1 & masked_opponent_board
        temp |= temp << 1 & masked_opponent_board
        temp |= temp << 1 & masked_opponent_board
        temp |= temp << 1 & masked_opponent_board
        temp |= temp << 1 & masked_opponent_board
        legal_moves = temp << 1 & blank_board

        # move & legal_Züge werden bewegen oder 0b0
        temp = (move & legal_moves) >> 1 & opponent_board
        temp |= temp >> 1 & opponent_board
        temp |= temp >> 1 & opponent_board
        temp |= temp >> 1 & opponent_board
        temp |= temp >> 1 & opponent_board
        temp |= temp >> 1 & opponent_board
        flipped |= temp

        return flipped