Das deutsche Python-Forum

Code: Alles auswählen

import random

class Player:
    def __init__(self, id, name, symbol):
        self.id = id
        self.name = name
        self.symbol = symbol
        self.automatic = False

class Field:
    def __init__(self, id, name):
        self.id = id
        self.name = name
        self.content = " "

class Board:
    fields = []
    fields.append(Field(1, "oben links"))
    fields.append(Field(2, "oben mitte"))
    fields.append(Field(3, "oben rechts"))
    fields.append(Field(4, "mitte links"))
    fields.append(Field(5, "mitte"))
    fields.append(Field(6, "mitte rechts"))
    fields.append(Field(7, "unten links"))
    fields.append(Field(8, "unten mitte"))
    fields.append(Field(9, "unten rechts"))
    players = []
    players.append(Player(1, "Spieler 1", "X"))
    players.append(Player(2, "Spieler 2", "O"))
    current_player = players[0].id
    gameover = False
    winner = 0
    
    def change_player(self, id, new_name, new_symbol, automatic = False):
        self.players[id - 1].name = new_name
        self.players[id - 1].symbol = new_symbol
        self.players[id - 1].automatic = automatic

    def gen_list_free_fields(self, with_name = False):
        if not with_name:
            for field in self.fields:
                if field.content == " ":
                    yield field.id
        else:
            for field in self.fields:
                if field.content == " ":
                    yield (str(field.id) + ": " + str(field.name))

    def print_board(self):
        print("+---+---+---+")
        print(f'| {self.fields[0].content} | {self.fields[1].content} | {self.fields[2].content} |')
        print("+---+---+---+")
        print(f'| {self.fields[3].content} | {self.fields[4].content} | {self.fields[5].content} |')
        print("+---+---+---+")
        print(f'| {self.fields[6].content} | {self.fields[7].content} | {self.fields[8].content} |')
        print("+---+---+---+")

    def make_selection(self):
        self.print_board()
        selection_is_valid = False
        while not selection_is_valid:
            print("Die folgenden Auswahl steht zur Verfügung:")
            for field in list(self.gen_list_free_fields(True)):
                print(field)
            print("10: Um das Spiel zu beenden")

            if self.current_player == self.players[0].id:
                print(f'{self.players[0].name} wähle ein Feld aus (bitte Zahl eingeben):')
            else:
                print(f'{self.players[1].name} wähle ein feld aus (bitte Zahl eingeben):')

            try:
                player_selection = int(input())
            except ValueError:
                player_selection = -1
            
            if player_selection == 10:
                exit()

            for field in self.fields:
                if player_selection == field.id and field.content == " ":
                    selection_is_valid = True
                    break

            if not selection_is_valid:
                print("Deine Auswahl ist ungültig!")
        return player_selection - 1
    
    def make_automatic_selection(self):
        danger = 0
        if self.current_player == self.players[0].id:
            opponent_symbol = self.players[1].symbol
        else:
            opponent_symbol = self.players[0].symbol
        win1 = [self.fields[0], self.fields[1], self.fields[2]]
        win2 = [self.fields[3], self.fields[4], self.fields[5]]
        win3 = [self.fields[6], self.fields[7], self.fields[8]]
        win4 = [self.fields[0], self.fields[3], self.fields[6]]
        win5 = [self.fields[1], self.fields[4], self.fields[7]]
        win6 = [self.fields[6], self.fields[7], self.fields[8]]
        win7 = [self.fields[0], self.fields[4], self.fields[8]]
        win8 = [self.fields[2], self.fields[4], self.fields[6]]
        allwins = [win1, win2, win3, win4, win5, win6, win7, win8]
        for wins in allwins:
            for field in wins:
                if field.content == opponent_symbol:
                    danger = danger + 1
            if danger > 1:
                for field in wins:
                    if field.content == " ":
                        return field.id - 1
            danger = 0
        return random.choice(list(self.gen_list_free_fields())) - 1

    def make_turn(self):
        if self.current_player == self.players[0].id:
            if self.players[0].automatic == True:
                self.fields[self.make_automatic_selection()].content = self.players[0].symbol
            else:
                self.fields[self.make_selection()].content = self.players[0].symbol
            self.current_player = self.players[1].id
        else:
            if self.players[1].automatic == True:
                self.fields[self.make_automatic_selection()].content = self.players[1].symbol
            else:
                self.fields[self.make_selection()].content = self.players[1].symbol
            self.current_player = self.players[0].id

    def check_gameover(self):
        win1 = [self.fields[0], self.fields[1], self.fields[2]]
        win2 = [self.fields[3], self.fields[4], self.fields[5]]
        win3 = [self.fields[6], self.fields[7], self.fields[8]]
        win4 = [self.fields[0], self.fields[3], self.fields[6]]
        win5 = [self.fields[1], self.fields[4], self.fields[7]]
        win6 = [self.fields[6], self.fields[7], self.fields[8]]
        win7 = [self.fields[0], self.fields[4], self.fields[8]]
        win8 = [self.fields[2], self.fields[4], self.fields[6]]
        allwins = [win1, win2, win3, win4, win5, win6, win7, win8]
        for wins in allwins:
            if all(item.content == self.players[0].symbol for item in wins):
                self.gameover = True
                self.winner = self.players[0].id
                break
            elif all(item.content == self.players[1].symbol for item in wins):
                self.gameover = True
                self.winner = self.players[1].id
                break
        if not self.gameover and all(field.content != " " for field in self.fields):
            self.gameover = True
            self.winner = 0

    def run(self):
        while not self.gameover:
            self.make_turn()
            self.check_gameover()

        self.print_board()
        if self.winner == self.players[0].id:
            print(f'{self.players[0].name} hat gewonnen!')
        elif self.winner == self.players[1].id:
            print(f'{self.players[1].name} hat gewonnen!')
        elif self.winner == 0:
            print("Leider hat niemand gewonnen.")

if __name__ == "__main__":
    board = Board()
    print("Wie viele menschliche Spieler?:")
    correct_choice = False
    while not correct_choice:
        try:
            amount_players = int(input())
        except ValueError:
            amount_players = -1
        if not amount_players < 0 and not amount_players > 2:
            correct_choice = True
        else:
            print("Die Auswahl war ungültig, bitte gültige Auswahl eingeben.")
    match amount_players:
        case 0:
            board.change_player(1 ,"Computer 1", "X", True)
            board.change_player(2 ,"Computer 2", "O", True)
        case 1:
            board.change_player(2 ,"Computer", "O", True)
    board.run()

Code: Alles auswählen

    def make_turn(self):
        if self.current_player.automatic:
            index = self.make_automatic_selection()
        else:
            index = self.make_selection()
        self.fields[index].content = self.current_player.symbol

Code: Alles auswählen

    def make_selection(self):
        self.print_board()
        while True:
            print("Die folgenden Auswahl steht zur Verfügung:")
            for field in self.gen_list_free_fields(True):
                print(field)
            print("10: Um das Spiel zu beenden")
            print(f'{self.current_player.name} wähle ein Feld aus (bitte Zahl eingeben):')
            try:
                player_selection = int(input())
            except ValueError:
                pass
            else:
                if player_selection == 10:
                    # Indikator, dass das Spiel beendet werden soll
                    return None
                player_selection -= 1
                if 0 < player_selection < len(self.fields):
                    if self.fields[player_selection]:
                        return player_selection
            print("Deine Auswahl ist ungültig!")

Code: Alles auswählen

    SERIES_INDICES = [
        [0, 1, 2],
        [3, 4, 5],
        [6, 7, 8],
        [0, 3, 6],
        [1, 4, 7],
        [2, 5, 6],
        [8, 4, 8],
        [2, 4, 6],
    ]

    def make_automatic_selection(self):
        if self.current_player == self.players[0]:
            opponent_symbol = self.players[1].symbol
        else:
            opponent_symbol = self.players[0].symbol
        for indices in self.SERIES_INDICES:
            danger = sum(self.fields[i] == opponent_symbol for i in indices)
            if danger == 2:
                for i in indices:
                    if self.fields[i] == " ":
                        return i
        return random.choice([i for i, c in enumerate(self.fields) if c == " "])

    def check_gameover(self):
        for indices in self.SERIES_INDICES:
            for player in self.players:
                if all(self.fields[i] == player.symbol for i in indices):
                    self.gameover = True
                    self.winner = self.player
                    return
        if not any(f == " " for f in self.fields):
            self.gameover = True
            self.winner = None

Code: Alles auswählen

#!/usr/bin/env python3
import random
import sys


class Player:
    def __init__(self, name, symbol, automatic):
        self.name = name
        self.symbol = symbol
        self.automatic = automatic


class Field:
    def __init__(self, name):
        self.name = name
        self.owner = None

    def __str__(self):
        return " " if self.is_empty else self.owner.symbol

    @property
    def is_empty(self):
        return self.owner is None


class Board:
    ALL_WINS = [
        [0, 1, 2],
        [3, 4, 5],
        [6, 7, 8],
        [0, 3, 6],
        [1, 4, 7],
        [6, 7, 8],
        [0, 4, 8],
        [2, 4, 6],
    ]

    def __init__(self, players):
        self.fields = list(
            map(
                Field,
                [
                    "oben links",
                    "oben mitte",
                    "oben rechts",
                    "mitte links",
                    "mitte",
                    "mitte rechts",
                    "unten links",
                    "unten mitte",
                    "unten rechts",
                ],
            )
        )
        self.players = players
        self.current_player = self.players[0]

    def __str__(self):
        line = "+---+---+---+"
        return "\n".join(
            [
                line,
                f"| {self.fields[0]} | {self.fields[1]} | {self.fields[2]} |",
                line,
                f"| {self.fields[3]} | {self.fields[4]} | {self.fields[5]} |",
                line,
                f"| {self.fields[6]} | {self.fields[7]} | {self.fields[8]} |",
            ]
        )

    def make_selection(self):
        print(self)
        end_game_number = len(self.fields)
        while True:
            print("Die folgenden Auswahl steht zur Verfügung:")
            for number, field in enumerate(self.fields, 1):
                if field.is_empty:
                    print(f"{number}: {field.name}")
            print(f"{end_game_number}: Um das Spiel zu beenden")

            print(
                f"{self.current_player.name} wähle ein Feld aus"
                f" (bitte Zahl eingeben):"
            )

            try:
                player_selection = int(input())
            except ValueError:
                pass
            else:
                if player_selection == end_game_number:
                    sys.exit()  # TODO Rewrite without this hard exit.

                try:
                    field = self.fields[player_selection - 1]
                except IndexError:
                    pass
                else:
                    if field.is_empty:
                        return field

            print("Deine Auswahl ist ungültig!")

    def make_automatic_selection(self):
        for wins in self.ALL_WINS:
            fields = [self.fields[i] for i in wins]
            if (
                sum(
                    field.owner not in [None, self.current_player]
                    for field in fields
                )
                > 1
            ):
                field = next(
                    (field for field in fields if field.is_empty), None
                )
                if field:
                    return field

        return random.choice(
            [field for field in self.fields if field.is_empty]
        )

    def make_turn(self):
        (
            self.make_automatic_selection()
            if self.current_player.automatic
            else self.make_selection()
        ).owner = self.current_player

        self.current_player = (
            self.players[1]
            if self.current_player is self.players[0]
            else self.players[0]
        )

    def get_winner(self):
        for wins in self.ALL_WINS:
            for player in self.players:
                if all(self.fields[i].owner == player for i in wins):
                    return player

        return None

    def run(self):
        winner = None
        while not winner and any(field.is_empty for field in self.fields):
            self.make_turn()
            winner = self.get_winner()

        print(self)
        if winner:
            print(f"{winner.name} hat gewonnen!")
        else:
            print("Leider hat niemand gewonnen.")


def main():
    print("Wie viele menschliche Spieler?:")
    while True:
        try:
            human_player_count = int(input())
        except ValueError:
            pass
        else:
            if 1 <= human_player_count <= 2:
                break

        print("Die Auswahl war ungültig, bitte gültige Auswahl eingeben.")

    if human_player_count == 0:
        players = [
            Player("Computer 1", "X", True),
            Player("Computer 2", "O", True),
        ]
    else:
        players = [Player("Spieler 1", "X", False)]
        another_human = human_player_count == 2
        players.append(
            Player(
                "Spieler 2" if another_human else "Computer",
                "O",
                not another_human,
            )
        )
    assert players[0].symbol != players[1].symbol
    board = Board(players)
    board.run()


if __name__ == "__main__":
    main()

Code: Alles auswählen

data = [
    23,
    42,
    57005
]