<reponame>KlonicOne/hello-world
import copy
import os
import sys

# Board configuration
#
#  +-- Player 1 and Player 2 has single line
# /
#  [2, 2, 2, 2, 2, 2, 2, 2, Player 1 (Index 0 .. 16)
#   2, 2, 2, 2, 0, 0, 0, 0]
#   ----------------------
#  [0, 0, 0, 0, 2, 2, 2, 2] Player 2
#   0, 1, 2, 3, 4, 5, 6, 7    Index
#  [2, 2, 2, 2, 2, 2, 2, 2]
#   15,14,13,12,11,10,9, 8    Index
#    \
#     +-- This is the field index


class bao_spiel:
    bestes_feld = 0
    bestes_feld_steine_gewonnen = 0
    feld_eingabe = 0
    felder_pro_linie = 8
    spieler_eingabe = ""
    spieler_namen = ["a", "b"]
    spielfeld_spieler_a = [2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 2]
    spielfeld_spieler_a_kopie = []
    spielfeld_spieler_b = [0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
    spielfeld_spieler_b_kopie = []
    steine_gewonnen_letzer_zug = 0

    def spielfeld(self):
        # Referenz auf alle
        for sp_name in self.spieler_namen:
            spielfeld = self.gib_spielfeld_referenz(sp_name)
            print(sp_name + "  ------------------------ " + sp_name)
            erste_reihe = spielfeld[0:self.felder_pro_linie]
            print("0  " + str(erste_reihe) + " 7")
            zweite_reihe = list(spielfeld[self.felder_pro_linie::])
            zweite_reihe.reverse()
            print("15 " + str(zweite_reihe) + " 8")
        print("   ------------------------")
        print("Steine A: " + str(sum(self.spielfeld_spieler_a)))
        print("Steine B: " + str(sum(self.spielfeld_spieler_b)))
        print()

    def ist_spielereingbe_bekannt(self, spieler_name):
        spieler_bekannt = False
        for name_zum_pruefen in self.spieler_namen:
            if (name_zum_pruefen == spieler_name):
                spieler_bekannt = True
        return spieler_bekannt

    def erstelle_spielfeld_kopie(self):
        self.spielfeld_spieler_a_kopie = copy.deepcopy(
            self.spielfeld_spieler_a)
        self.spielfeld_spieler_b_kopie = copy.deepcopy(
            self.spielfeld_spieler_b)

    def spielzug(self, spieler_name, feld_index):
        # Check ob Spieler in liste
        spieler_bekannt = self.ist_spielereingbe_bekannt(spieler_name)
        # Sofort beenden wenn nicht im Spiel
        if spieler_bekannt == False:
            return  # Stopp den Zug
        # Erstelle eine Kopie des Spiels, um Rueckgaengig zu machen
        self.erstelle_spielfeld_kopie()
        # Starte Rekusive Funktion
        self.spielzug_machen(spieler_name, feld_index)
        if self.steine_gewonnen_letzer_zug:
            print("Steine: " +
                  str(self.steine_gewonnen_letzer_zug) + " von Feld: " + str(feld_index))

    def verteile_steine(self, steine_in_hand, spieler_name, feld_index):
        while steine_in_hand > 0:
            feld_index = self.gib_naechstes_feld(feld_index)
            steine_in_hand = self.befuelle_feld_aus_hand(
                spieler_name, feld_index, steine_in_hand)
        return feld_index

    def spielzug_machen(self, spieler_name, feld_index):
        loc_feld_index = copy.copy(feld_index)
        # Referenz auf richtiges Spielfeld
        spielfeld = self.gib_spielfeld_referenz(spieler_name)
        # Pruefe ob Zug erlaubt
        erlaubt = (spielfeld[loc_feld_index] >= 2)
        # Zug nur wenn auch erlaubt
        if erlaubt:
            # Nimm die Steine auf
            steine_in_hand = self.entnehme_steine(spieler_name, loc_feld_index)
            loc_feld_index = self.verteile_steine(
                steine_in_hand, spieler_name, loc_feld_index)
            # <NAME> vom Gegner wenn moeglich
            steine_gewonnen_aktueller_zug = self.nimm_steine_von_gegner(
                spieler_name, loc_feld_index)
            self.steine_gewonnen_letzer_zug = self.steine_gewonnen_letzer_zug + \
                steine_gewonnen_aktueller_zug
            # Steine im Spielfeld und gewonnene zusammen in aktuelles Feld legen
            spielfeld[loc_feld_index] = spielfeld[loc_feld_index] + \
                steine_gewonnen_aktueller_zug
            self.spielzug_machen(spieler_name, loc_feld_index)

    def reset_steine_letzter_zug(self):
        self.steine_gewonnen_letzer_zug = 0

    def gegner_namen(self, eigen_name):
        for name_zum_pruefen in self.spieler_namen:
            if (name_zum_pruefen != eigen_name):
                return name_zum_pruefen

    def nimm_steine_von_gegner(self, spieler_name, feld_index):
        steine_vom_gegner = 0
        # Referenz eigenes Spielfeld
        spielfeld = self.gib_spielfeld_referenz(spieler_name)
        # Nur Steine holen erlaubt wenn im eigenen mehr als zwei sind und
        # Pruefe ob in diesem Feld Stein vom Gegner geholt werden duerfen
        if spielfeld[feld_index] >= 2 and self.passt_feld_um_steine_zu_holen(spieler_name, feld_index):
            # <NAME>amen
            name_gegner = self.gegner_namen(spieler_name)
            # Hole Referenz auf Gegnerfeld
            spielfeld_gegner = self.gib_spielfeld_referenz(name_gegner)
            # Berechne feld index wo Steine geholt werden duerfen
            feld_1_gegner_zum_pruefen = feld_index - ((feld_index - 8) * 2) - 1
            feld_2_gegner_zum_pruefen = feld_index
            # Steine fuer Spieler A holen wenn moeglich
            if spielfeld_gegner[feld_1_gegner_zum_pruefen] > 0:
                # Steine koennen geholt werden
                steine_vom_gegner = self.entnehme_steine(name_gegner, feld_1_gegner_zum_pruefen)
                steine_vom_gegner = steine_vom_gegner + self.entnehme_steine(name_gegner, feld_2_gegner_zum_pruefen)
            else:
                steine_vom_gegner = 0
        else:
            steine_vom_gegner = 0
        return steine_vom_gegner

    def passt_feld_um_steine_zu_holen(self, spieler_name, feld_index):
        if spieler_name == "a":
            # Pruefe Felder 8 bis 15
            if feld_index >= 8 and feld_index <= 15:
                return True
            else:
                return False
        elif spieler_name == "b":
            # Pruefe Felder 0 bis 7
            if feld_index >= 0 and feld_index <= 7:
                return True
            else:
                return False

    def befuelle_feld_aus_hand(self, spieler_name, feld_index, steine):
        loc_steine = copy.deepcopy(steine)
        if loc_steine > 0:
            # Referenz auf richtiges Spielfeld
            spielfeld = self.gib_spielfeld_referenz(spieler_name)
            # Lege Stein in Feld
            spielfeld[feld_index] = spielfeld[feld_index] + 1
            # Ein Stein weniger in der Hand
            loc_steine = loc_steine - 1
        return loc_steine

    def entnehme_steine(self, spieler_name, feld_index):
        # Referenz auf richtiges Spielfeld
        spielfeld = self.gib_spielfeld_referenz(spieler_name)
        # Nimm alle Steine
        steine = spielfeld[feld_index]
        # Feld danach leer
        spielfeld[feld_index] = 0
        return steine

    def gib_naechstes_feld(self, feld_index):
        # Funktion gibt naechstes feld zurueck
        naechste_feld = (feld_index + 1) % len(self.spielfeld_spieler_a)
        return naechste_feld

    def ist_zug_erlaubt(self, spieler_name, feld_index):
        # Referenz auf richtiges Spielfeld
        spielfeld = self.gib_spielfeld_referenz(spieler_name)

        if spielfeld[feld_index] >= 2:
            return True
        else:
            return False

    def gib_spielfeld_referenz(self, spieler_name):
        if spieler_name == "a":
            return self.spielfeld_spieler_a
        elif spieler_name == "b":
            return self.spielfeld_spieler_b
        else:
            return 0

    def loesche_anzeige(self):
        command = "clear"
        # if os.name in ("nt", "dos"):  # it is windows
        #     command = "cls"
        os.system(command)

    def zug_zuruecknehmen(self):
        self.spielfeld_spieler_a = copy.deepcopy(
            self.spielfeld_spieler_a_kopie)
        self.spielfeld_spieler_b = copy.deepcopy(
            self.spielfeld_spieler_b_kopie)

    def menue(self):
        print()
        print("Bitte Auswahl treffen:")
        print("y: Zug spielen")
        print("z: Zug zuruecknehmen")
        print("x: Spiel beenden")
        print("p: Pruefe besten Zug")
        print("g: Pruefe <NAME>hr")
        m_auswahl = input("Eingabe: ")
        # Weitere eingaben basierend auf Auswahl
        if m_auswahl == "x":
            self.spieler_eingabe = "a"
            self.feld_eingabe = 0
        # Spielername fuer Zug
        if m_auswahl == "p" or m_auswahl == "g":
            self.spieler_eingabe = input("Spielername (a oder b): ")
            self.feld_eingabe = 0
        if m_auswahl == "y":
            self.spieler_eingabe = input("Spielername (a oder b): ")
            feld_index = input("Feld (0..15): ")
            self.feld_eingabe = int(feld_index)
        print()
        # Auswahl zurueckgeben
        return m_auswahl

    def weiterspielen(self, auswahl):
        if auswahl == "y":
            return True
        elif auswahl == "p":
            return True
        elif auswahl == "g":
            return True
        elif auswahl == "z":
            return True
        else:
            return False

    def pruefe_verlierer(self):
        # Check Spieler a
        spielfeld = self.gib_spielfeld_referenz("a")
        spieler_a_lost = True
        for elem in spielfeld:
            if elem > 1:
                spieler_a_lost = False
        spielfeld = self.gib_spielfeld_referenz("b")
        spieler_b_lost = True
        for elem in spielfeld:
            if elem > 1:
                spieler_b_lost = False
        if spieler_a_lost:
            print("Spieler A hat verloren")
        if spieler_b_lost:
            print("Spieler B hat verloren")
            
    def pruefe_besten_spielzug(self):
        self.bestes_feld = 0
        # Teste sol lange bis wieder auf dem ursprungsfeld
        for feld_zu_pruefen in range(0, len(self.spielfeld_spieler_a)):
            self.reset_steine_letzter_zug()
            # Mache Zug fuer aktuelles feld
            self.spielzug(self.spieler_eingabe, feld_zu_pruefen)            
            # Zug zuruecknehmen
            self.zug_zuruecknehmen()

    def pruefe_gefahr_spielzug(self):
        self.bestes_feld = 0
        # Teste sol lange bis wieder auf dem ursprungsfeld
        for feld_zu_pruefen in range(0, len(self.spielfeld_spieler_a)):
            self.reset_steine_letzter_zug()
            # <NAME> fuer aktuelles feld
            gegner = self.gegner_namen(self.spieler_eingabe)
            self.spielzug(gegner, feld_zu_pruefen)
            # Zug zuruecknehmen
            self.zug_zuruecknehmen()

    def spiele_bao(self):
        # Erstmalige Eingabe
        self.spielfeld()
        auswahl = self.menue()
        # Solange spielen wie gewuenscht
        while self.weiterspielen(auswahl):
            self.loesche_anzeige()
            print("Spielfeld vor Zug")
            self.spielfeld()
            # check user input
            if auswahl == "p":
                print("<NAME> fuer Spieler %s" %
                      self.spieler_eingabe)
                # Schau alle Felder durch und nimm jeden Zug zurueck
                self.pruefe_besten_spielzug()
            elif auswahl == "g":
                print("Pr<NAME> fuer Spieler %s" %
                      self.spieler_eingabe)
                # Schau alle Felder durch und nimm jeden Zug zurueck
                self.pruefe_gefahr_spielzug()
            elif auswahl == "y":
                self.reset_steine_letzter_zug()
                self.spielzug(self.spieler_eingabe, self.feld_eingabe)
            elif auswahl == "z":
                self.zug_zuruecknehmen()

            print("Spielfeld nach Zug")
            self.spielfeld()
            self.pruefe_verlierer()
            auswahl = self.menue()


def main():
    # Erstelle Spiel
    bao = bao_spiel()
    bao.spiele_bao()


if __name__ == "__main__":
    main()

import copy
import os
import sys

# Board configuration
#
#  +-- Player 1 and Player 2 has single line
# /
#  [2, 2, 2, 2, 2, 2, 2, 2, Player 1 (Index 0 .. 16)
#   2, 2, 2, 2, 0, 0, 0, 0]
#   ----------------------
#  [0, 0, 0, 0, 2, 2, 2, 2] Player 2
#   0, 1, 2, 3, 4, 5, 6, 7    Index
#  [2, 2, 2, 2, 2, 2, 2, 2]
#   15,14,13,12,11,10,9, 8    Index
#    \
#     +-- This is the field index


class bao_spiel:
    bestes_feld = 0
    bestes_feld_steine_gewonnen = 0
    feld_eingabe = 0
    felder_pro_linie = 8
    spieler_eingabe = ""
    spieler_namen = ["a", "b"]
    spielfeld_spieler_a = [2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 2]
    spielfeld_spieler_a_kopie = []
    spielfeld_spieler_b = [0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
    spielfeld_spieler_b_kopie = []
    steine_gewonnen_letzer_zug = 0

    def spielfeld(self):
        # Referenz auf alle
        for sp_name in self.spieler_namen:
            spielfeld = self.gib_spielfeld_referenz(sp_name)
            print(sp_name + "  ------------------------ " + sp_name)
            erste_reihe = spielfeld[0:self.felder_pro_linie]
            print("0  " + str(erste_reihe) + " 7")
            zweite_reihe = list(spielfeld[self.felder_pro_linie::])
            zweite_reihe.reverse()
            print("15 " + str(zweite_reihe) + " 8")
        print("   ------------------------")
        print("Steine A: " + str(sum(self.spielfeld_spieler_a)))
        print("Steine B: " + str(sum(self.spielfeld_spieler_b)))
        print()

    def ist_spielereingbe_bekannt(self, spieler_name):
        spieler_bekannt = False
        for name_zum_pruefen in self.spieler_namen:
            if (name_zum_pruefen == spieler_name):
                spieler_bekannt = True
        return spieler_bekannt

    def erstelle_spielfeld_kopie(self):
        self.spielfeld_spieler_a_kopie = copy.deepcopy(
            self.spielfeld_spieler_a)
        self.spielfeld_spieler_b_kopie = copy.deepcopy(
            self.spielfeld_spieler_b)

    def spielzug(self, spieler_name, feld_index):
        # Check ob Spieler in liste
        spieler_bekannt = self.ist_spielereingbe_bekannt(spieler_name)
        # Sofort beenden wenn nicht im Spiel
        if spieler_bekannt == False:
            return  # Stopp den Zug
        # Erstelle eine Kopie des Spiels, um Rueckgaengig zu machen
        self.erstelle_spielfeld_kopie()
        # Starte Rekusive Funktion
        self.spielzug_machen(spieler_name, feld_index)
        if self.steine_gewonnen_letzer_zug:
            print("Steine: " +
                  str(self.steine_gewonnen_letzer_zug) + " von Feld: " + str(feld_index))

    def verteile_steine(self, steine_in_hand, spieler_name, feld_index):
        while steine_in_hand > 0:
            feld_index = self.gib_naechstes_feld(feld_index)
            steine_in_hand = self.befuelle_feld_aus_hand(
                spieler_name, feld_index, steine_in_hand)
        return feld_index

    def spielzug_machen(self, spieler_name, feld_index):
        loc_feld_index = copy.copy(feld_index)
        # Referenz auf richtiges Spielfeld
        spielfeld = self.gib_spielfeld_referenz(spieler_name)
        # Pruefe ob Zug erlaubt
        erlaubt = (spielfeld[loc_feld_index] >= 2)
        # Zug nur wenn auch erlaubt
        if erlaubt:
            # Nimm die Steine auf
            steine_in_hand = self.entnehme_steine(spieler_name, loc_feld_index)
            loc_feld_index = self.verteile_steine(
                steine_in_hand, spieler_name, loc_feld_index)
            # <NAME> vom Gegner wenn moeglich
            steine_gewonnen_aktueller_zug = self.nimm_steine_von_gegner(
                spieler_name, loc_feld_index)
            self.steine_gewonnen_letzer_zug = self.steine_gewonnen_letzer_zug + \
                steine_gewonnen_aktueller_zug
            # Steine im Spielfeld und gewonnene zusammen in aktuelles Feld legen
            spielfeld[loc_feld_index] = spielfeld[loc_feld_index] + \
                steine_gewonnen_aktueller_zug
            self.spielzug_machen(spieler_name, loc_feld_index)

    def reset_steine_letzter_zug(self):
        self.steine_gewonnen_letzer_zug = 0

    def gegner_namen(self, eigen_name):
        for name_zum_pruefen in self.spieler_namen:
            if (name_zum_pruefen != eigen_name):
                return name_zum_pruefen

    def nimm_steine_von_gegner(self, spieler_name, feld_index):
        steine_vom_gegner = 0
        # Referenz eigenes Spielfeld
        spielfeld = self.gib_spielfeld_referenz(spieler_name)
        # Nur Steine holen erlaubt wenn im eigenen mehr als zwei sind und
        # Pruefe ob in diesem Feld Stein vom Gegner geholt werden duerfen
        if spielfeld[feld_index] >= 2 and self.passt_feld_um_steine_zu_holen(spieler_name, feld_index):
            # <NAME>amen
            name_gegner = self.gegner_namen(spieler_name)
            # Hole Referenz auf Gegnerfeld
            spielfeld_gegner = self.gib_spielfeld_referenz(name_gegner)
            # Berechne feld index wo Steine geholt werden duerfen
            feld_1_gegner_zum_pruefen = feld_index - ((feld_index - 8) * 2) - 1
            feld_2_gegner_zum_pruefen = feld_index
            # Steine fuer Spieler A holen wenn moeglich
            if spielfeld_gegner[feld_1_gegner_zum_pruefen] > 0:
                # Steine koennen geholt werden
                steine_vom_gegner = self.entnehme_steine(name_gegner, feld_1_gegner_zum_pruefen)
                steine_vom_gegner = steine_vom_gegner + self.entnehme_steine(name_gegner, feld_2_gegner_zum_pruefen)
            else:
                steine_vom_gegner = 0
        else:
            steine_vom_gegner = 0
        return steine_vom_gegner

    def passt_feld_um_steine_zu_holen(self, spieler_name, feld_index):
        if spieler_name == "a":
            # Pruefe Felder 8 bis 15
            if feld_index >= 8 and feld_index <= 15:
                return True
            else:
                return False
        elif spieler_name == "b":
            # Pruefe Felder 0 bis 7
            if feld_index >= 0 and feld_index <= 7:
                return True
            else:
                return False

    def befuelle_feld_aus_hand(self, spieler_name, feld_index, steine):
        loc_steine = copy.deepcopy(steine)
        if loc_steine > 0:
            # Referenz auf richtiges Spielfeld
            spielfeld = self.gib_spielfeld_referenz(spieler_name)
            # Lege Stein in Feld
            spielfeld[feld_index] = spielfeld[feld_index] + 1
            # Ein Stein weniger in der Hand
            loc_steine = loc_steine - 1
        return loc_steine

    def entnehme_steine(self, spieler_name, feld_index):
        # Referenz auf richtiges Spielfeld
        spielfeld = self.gib_spielfeld_referenz(spieler_name)
        # Nimm alle Steine
        steine = spielfeld[feld_index]
        # Feld danach leer
        spielfeld[feld_index] = 0
        return steine

    def gib_naechstes_feld(self, feld_index):
        # Funktion gibt naechstes feld zurueck
        naechste_feld = (feld_index + 1) % len(self.spielfeld_spieler_a)
        return naechste_feld

    def ist_zug_erlaubt(self, spieler_name, feld_index):
        # Referenz auf richtiges Spielfeld
        spielfeld = self.gib_spielfeld_referenz(spieler_name)

        if spielfeld[feld_index] >= 2:
            return True
        else:
            return False

    def gib_spielfeld_referenz(self, spieler_name):
        if spieler_name == "a":
            return self.spielfeld_spieler_a
        elif spieler_name == "b":
            return self.spielfeld_spieler_b
        else:
            return 0

    def loesche_anzeige(self):
        command = "clear"
        # if os.name in ("nt", "dos"):  # it is windows
        #     command = "cls"
        os.system(command)

    def zug_zuruecknehmen(self):
        self.spielfeld_spieler_a = copy.deepcopy(
            self.spielfeld_spieler_a_kopie)
        self.spielfeld_spieler_b = copy.deepcopy(
            self.spielfeld_spieler_b_kopie)

    def menue(self):
        print()
        print("Bitte Auswahl treffen:")
        print("y: Zug spielen")
        print("z: Zug zuruecknehmen")
        print("x: Spiel beenden")
        print("p: Pruefe besten Zug")
        print("g: Pruefe <NAME>hr")
        m_auswahl = input("Eingabe: ")
        # Weitere eingaben basierend auf Auswahl
        if m_auswahl == "x":
            self.spieler_eingabe = "a"
            self.feld_eingabe = 0
        # Spielername fuer Zug
        if m_auswahl == "p" or m_auswahl == "g":
            self.spieler_eingabe = input("Spielername (a oder b): ")
            self.feld_eingabe = 0
        if m_auswahl == "y":
            self.spieler_eingabe = input("Spielername (a oder b): ")
            feld_index = input("Feld (0..15): ")
            self.feld_eingabe = int(feld_index)
        print()
        # Auswahl zurueckgeben
        return m_auswahl

    def weiterspielen(self, auswahl):
        if auswahl == "y":
            return True
        elif auswahl == "p":
            return True
        elif auswahl == "g":
            return True
        elif auswahl == "z":
            return True
        else:
            return False

    def pruefe_verlierer(self):
        # Check Spieler a
        spielfeld = self.gib_spielfeld_referenz("a")
        spieler_a_lost = True
        for elem in spielfeld:
            if elem > 1:
                spieler_a_lost = False
        spielfeld = self.gib_spielfeld_referenz("b")
        spieler_b_lost = True
        for elem in spielfeld:
            if elem > 1:
                spieler_b_lost = False
        if spieler_a_lost:
            print("Spieler A hat verloren")
        if spieler_b_lost:
            print("Spieler B hat verloren")
            
    def pruefe_besten_spielzug(self):
        self.bestes_feld = 0
        # Teste sol lange bis wieder auf dem ursprungsfeld
        for feld_zu_pruefen in range(0, len(self.spielfeld_spieler_a)):
            self.reset_steine_letzter_zug()
            # Mache Zug fuer aktuelles feld
            self.spielzug(self.spieler_eingabe, feld_zu_pruefen)            
            # Zug zuruecknehmen
            self.zug_zuruecknehmen()

    def pruefe_gefahr_spielzug(self):
        self.bestes_feld = 0
        # Teste sol lange bis wieder auf dem ursprungsfeld
        for feld_zu_pruefen in range(0, len(self.spielfeld_spieler_a)):
            self.reset_steine_letzter_zug()
            # <NAME> fuer aktuelles feld
            gegner = self.gegner_namen(self.spieler_eingabe)
            self.spielzug(gegner, feld_zu_pruefen)
            # Zug zuruecknehmen
            self.zug_zuruecknehmen()

    def spiele_bao(self):
        # Erstmalige Eingabe
        self.spielfeld()
        auswahl = self.menue()
        # Solange spielen wie gewuenscht
        while self.weiterspielen(auswahl):
            self.loesche_anzeige()
            print("Spielfeld vor Zug")
            self.spielfeld()
            # check user input
            if auswahl == "p":
                print("<NAME> fuer Spieler %s" %
                      self.spieler_eingabe)
                # Schau alle Felder durch und nimm jeden Zug zurueck
                self.pruefe_besten_spielzug()
            elif auswahl == "g":
                print("Pr<NAME> fuer Spieler %s" %
                      self.spieler_eingabe)
                # Schau alle Felder durch und nimm jeden Zug zurueck
                self.pruefe_gefahr_spielzug()
            elif auswahl == "y":
                self.reset_steine_letzter_zug()
                self.spielzug(self.spieler_eingabe, self.feld_eingabe)
            elif auswahl == "z":
                self.zug_zuruecknehmen()

            print("Spielfeld nach Zug")
            self.spielfeld()
            self.pruefe_verlierer()
            auswahl = self.menue()


def main():
    # Erstelle Spiel
    bao = bao_spiel()
    bao.spiele_bao()


if __name__ == "__main__":
    main()
# Board configuration # #  +-- Player 1 and Player 2 has single line # / #  [2, 2, 2, 2, 2, 2, 2, 2, Player 1 (Index 0 .. 16) #   2, 2, 2, 2, 0, 0, 0, 0] #   ---------------------- #  [0, 0, 0, 0, 2, 2, 2, 2] Player 2 #   0, 1, 2, 3, 4, 5, 6, 7    Index #  [2, 2, 2, 2, 2, 2, 2, 2] #   15,14,13,12,11,10,9, 8    Index #    \ #     +-- This is the field index # Referenz auf alle # Check ob Spieler in liste # Sofort beenden wenn nicht im Spiel # Stopp den Zug # Erstelle eine Kopie des Spiels, um Rueckgaengig zu machen # Starte Rekusive Funktion # Referenz auf richtiges Spielfeld # Pruefe ob Zug erlaubt # Zug nur wenn auch erlaubt # Nimm die Steine auf # <NAME> vom Gegner wenn moeglich # Steine im Spielfeld und gewonnene zusammen in aktuelles Feld legen # Referenz eigenes Spielfeld # Nur Steine holen erlaubt wenn im eigenen mehr als zwei sind und # Pruefe ob in diesem Feld Stein vom Gegner geholt werden duerfen # <NAME>amen # Hole Referenz auf Gegnerfeld # Berechne feld index wo Steine geholt werden duerfen # Steine fuer Spieler A holen wenn moeglich # Steine koennen geholt werden # Pruefe Felder 8 bis 15 # Pruefe Felder 0 bis 7 # Referenz auf richtiges Spielfeld # Lege Stein in Feld # Ein Stein weniger in der Hand # Referenz auf richtiges Spielfeld # Nimm alle Steine # Feld danach leer # Funktion gibt naechstes feld zurueck # Referenz auf richtiges Spielfeld # if os.name in ("nt", "dos"):  # it is windows #     command = "cls" # Weitere eingaben basierend auf Auswahl # Spielername fuer Zug # Auswahl zurueckgeben # Check Spieler a # Teste sol lange bis wieder auf dem ursprungsfeld # Mache Zug fuer aktuelles feld # Zug zuruecknehmen # Teste sol lange bis wieder auf dem ursprungsfeld # <NAME> fuer aktuelles feld # Zug zuruecknehmen # Erstmalige Eingabe # Solange spielen wie gewuenscht # check user input # Schau alle Felder durch und nimm jeden Zug zurueck # Schau alle Felder durch und nimm jeden Zug zurueck # Erstelle Spiel