Othello

import random

class Board:
    """
    Othello board with pieces in the self.pieces dict.
    self.pieces format is such that {(x, y): c}, where c is 0 for empty,
    1 for white and 2 for black. x and y range from 0-7.
    """
    def __init__(self):
        self.pieces = {}
        self.setup_board()

    def setup_board(self):
        """Sets up starting board."""
        for x in range(8):
            for y in range(8):
                self.pieces[(x, y)] = 0
        self.pieces[(3, 4)] = self.pieces[(4, 3)] = 1
        self.pieces[(3, 3)] = self.pieces[(4, 4)] = 2

    def draw(self, paint=False, list_of_points=None, marker="x"):
        """Draws board. If paint is enabled, a list of (x,y) points will shown with the
        marker x for debugging purposes."""
        # ┐ └ ─ ┘ ┌ │ ■ □
        print("  x 0 1 2 3 4 5 6 7  ")
        print("y ┌─────────────────┐")
        for y in range(0, 8):
            print(y, "│ ", end="")
            for x in range(0, 8):
                if self.pieces[(x,y)] == 0:
                    c = " "
                elif self.pieces[(x,y)] == 1:
                    c = "■"
                else:
                    c = "□"
                if paint:
                    if (x,y) in list_of_points:
                        c = marker
                print(c + " ", end="")
            print("│")
        print("  └─────────────────┘")

    def place(self, x, y, player):
        assert 0 <= x <= 7 and 0 <= y <= 7
        self.pieces[(x, y)] = player

    def switch(self, x, y):
        """Switches marker from black to white and vice versa."""
        if self.pieces[(x, y)] == 1:
            self.pieces[(x, y)] = 2
        elif self.pieces[(x, y)] == 2:
            self.pieces[(x, y)] = 1
        else:
            raise ValueError("Tried to switch an invalid piece")

    def board_is_full(self):
        return len([x for x in self.pieces.values() if x != 0]) == 64

    def get_score(self):
        white_score = len([c for c in self.pieces.values() if c == 1])
        black_score = len([c for c in self.pieces.values() if c == 2])
        return white_score, black_score

    def position_is_occupied(self, x, y):
        return self.pieces[(x,y)] != 0

    def get_populated_neighbours(self, x, y):
        """Returns list of (x,y) where a marker is placed."""
        neighbours = [(x - 1, y - 1),
                      (x, y - 1),
                      (x + 1, y - 1),
                      (x - 1, y),
                      (x + 1, y),
                      (x - 1, y + 1),
                      (x, y + 1),
                      (x + 1, y + 1),
                      ]
        populated_neighbours = []
        for n in neighbours:
            if n in self.pieces:
                if self.pieces[n] != 0:
                    populated_neighbours.append(n)
        return populated_neighbours

    def get_pieces_taken(self, x, y, player):
        """
        Returns all pieces that are taken if this players piece is placed here. For optimization, this
        method tries to return None as early as possible if no pieces can be taken here.

        :param x: X position of placed piece.
        :param y: Y position of placed piece.
        :param player: 1 if placed piece is white, 2 if black.
        :return: A dict where the keys are adjacent pieces that will be taken if a piece is placed here,
        and the values are lists of all pieces that will be taken in that direction (including the piece
        in the key). Returns None if no pieces can be taken.
        """

        # check self
        if self.position_is_occupied(x, y):
            return None

        # check if neighbours are empty
        populated_neighbours = self.get_populated_neighbours(x, y)
        if not populated_neighbours:
            return None

        # check if populated neighbours are of same type
        populated_neighbours_of_other_type = [n for n in populated_neighbours if self.pieces[n] == opponent_to(player)]
        if not populated_neighbours_of_other_type:
            return None

        pieces_taken = {n: [n] for n in populated_neighbours_of_other_type}
        #Looks in all 8 directions to see if the line can be taken.
        for key, pieces_list in pieces_taken.items():
            a, b = key
            dx = a - x
            dy = b - y
            next_piece = (a + dx, b + dy)
            while True:
                # PIECE OUTSIDE BOARD: None are taken.
                if next_piece not in self.pieces:
                    pieces_list.clear()
                    break
                # PIECE IS SELF: This line ends.
                if self.pieces[next_piece] == player:
                    break
                # PIECE IS EMPTY: None are taken.
                if self.pieces[next_piece] == 0:
                    pieces_list.clear()
                    break
                # PIECE IS OPPONENT: This piece is taken, and next is checked.
                if self.pieces[next_piece] == opponent_to(player):
                    pieces_list.append(next_piece)
                next_piece = (next_piece[0] + dx, next_piece[1] + dy)

        if any(pieces_taken.values()):
            return pieces_taken
        return None

    def read_board(self, board_str):
        """Reads a board as a multi line string, the same format as it is drawn in self.draw(). For debugging."""
        for line in board_str.splitlines():
            if not line:
                continue
            if line[0] in ("01234567"):
                y = int(line[0])
                for i in range(4, 19, 2):
                    c = line[i]
                    x = (i-4)//2
                    if c == " ":
                        a = 0
                    if c == "■":
                        a = 1
                    if c == "□":
                        a = 2
                    self.pieces[(x, y)] = a

class AI:
    def __init__(self, player, board):
        self.player = player
        self.board = board
        self.color = "white" if self.player == 1 else "black"

    def __str__(self):
        return "AI"

    def produce_move(self):
        """
        Main AI move generator. Currently it chooses randomly from all moves that are valid,
        but this method can be made more advanced.
        :return: (x, y) for a move, or "forfeit" if no moves are valid.
        """
        possible_placements = self.get_all_possible_placements()
        if not possible_placements:
            return "forfeit"
        move = random.choice(possible_placements)
        print("AI moves to:", move)
        return move

    def get_all_possible_placements(self):
        placements = []
        for y in range(8):
            for x in range(8):
                placement = self.board.get_pieces_taken(x, y, self.player)
                if placement is not None:
                    placements.append((x, y))
        return placements

class Human:
    def __init__(self, player, board):
        self.player = player
        self.board = board
        self.color = "white" if self.player == 1 else "black"

    def __str__(self):
        return "Human"

    def produce_move(self):
        print("Human move. Input 'exit' to quit, 'forfeit' to forfeit this move.")
        player_str = "White" if self.player == 1 else "Black"
        while True:
            i = input(f"{player_str}: xy - ")
            if i in ("exit", "forfeit"):
                return i
            try:
                i = [c for c in i if c in "0123456789"]
                x, y = int(i[0]), int(i[1])
                if not (0 <= x <= 7 and 0 <= y <= 7):
                    print("Outside board.")
                    continue
            except:
                print("Invalid input.")
                continue
            if self.board.get_pieces_taken(x, y, self.player) is None:
                print("This move takes no pieces.")
            else:
                return x, y


class Player:
    """
    Player class. playertype can be of class Human() or AI().
    """
    def __init__(self, playertype):
        self.playertype = playertype
        self.no_moves_available = False

    def __str__(self):
        return self.playertype.__str__()

    def produce_move(self):
        return self.playertype.produce_move()

    def get_player(self):
        return self.playertype.player

    def get_color(self):
        return self.playertype.color

def opponent_to(player):
    """Returns the opponent to the player."""
    if player == 1:
        return 2
    elif player == 2:
        return 1
    else:
        raise ValueError("Not a valid player")


def main():
    b = Board()
    p1 = Player(Human(2, b)) # Black
    p2 = Player(AI(1, b)) # White
    players = (p1, p2)
    print("STARTING GAME")
    running = True
    while running:
        print()
        print(f"{p1} is {p1.get_color()}, {p2} is {p2.get_color()}.")
        for p in players:
            # Check if game is won.
            if all((p1.no_moves_available, p2.no_moves_available)) or b.board_is_full():
                print()
                white_score, black_score = b.get_score()
                if white_score == black_score:
                    print(f"Game is a tie. White has {white_score} pieces, black has {black_score} pieces.")
                else:
                    winner = "white" if white_score > black_score else "black"
                    print(f"Game won by {winner}. White has {white_score} pieces, black has {black_score} pieces.")
                print("Final board:")
                b.draw()
                running = False
            if not running:
                break
            b.draw()
            move = p.produce_move()
            # Check if player exited.
            if move == "exit":
                running = False
                break
            if move == "forfeit":
                print("Move forfeited.")
                p.no_moves_available = True # If both player forfeited, game ends.
                continue
            p.no_moves_available = False
            x, y = move
            pieces_taken = b.get_pieces_taken(x, y, p.get_player()) # Check what pieces are taken.
            b.place(x, y, p.get_player()) # Place the one piece.
            for direction in pieces_taken.values(): # Switch the pieces that are taken.
                for x, y in direction:
                    b.switch(x, y)


main()