Das deutsche Python-Forum

Code: Alles auswählen

import random
Farben = ["Kreuz", "Pik", "Herz", "Karo"]
Werte = ["7", "8", "9", "10", "Bube", "Dame", "Koenig", "Ass"]
Skat = [(sFarbe, sWert) for sWert in Werte for sFarbe in Farben]

class Spieler:
    name = ""
    handKarten = []

    def ziehe_Karte(self, karte):
        self.handKarten.append(karte)

    def lege_Karte(self, nummer):
        if not self.handKarten:
            return()
        self.handKarten.pop(nummer)
        return()

    def zeige_Handkarten(self):
        for i in range(0, len(self.handKarten)):
            print(self.handKarten[i])
        return()

def draw_card(lKarten):
    if not lKarten:
        print("Keine Karte mehr im Deck")
        return ()
    karte = lKarten.pop(0)
    print("gezogene Karte %s %s" % karte)
    return karte

def start_game(spieler, deck):
    for i in range(5):
        spieler.ziehe_Karte(draw_card(deck))
    return ()

print ("Das Spiel beginnt mische das Deck")
random.shuffle(Skat)
print ("Deck gemischt kann losgehen")

p1 = Spieler()
p2 = Spieler()

p1.name = input("Spieler 1, wie lautet dein Name? ")
p2.name = input("Spieler 2, wie lautet Dein Name? ")

start_game(p1, Skat)
print("Spieler 1 Deine Karten")
p1.zeige_Handkarten()
print("Spieler 2 Deine karten")
p2.zeige_Handkarten()

Code: Alles auswählen

In [568]: def f():
     ...:     return()
     ...: 

In [569]: f()
Out[569]: ()

In [570]: type(f())
Out[570]: tuple

Code: Alles auswählen

#!/usr/bin/env python3
import random
from collections import namedtuple

SUITS = ["Kreuz", "Pik", "Herz", "Karo"]
VALUES = ["7", "8", "9", "10", "Bube", "Dame", "Koenig", "Ass"]

Card = namedtuple("Card", "suite value")


class Player:
    def __init__(self, name, cards=None):
        if cards is None:
            cards = []
        self.name = name
        self.cards = cards

    def add_card(self, card):
        self.cards.append(card)

    def get_card(self, index):
        return self.cards.pop(index)

    def show_cards(self):
        for card in self.cards:
            print(card)


def draw_card(deck):
    card = deck.pop()
    print(f"gezogene Karte {card.suite} {card.value}")
    return card


def start_game(player, deck):
    for _ in range(5):
        player.add_card(draw_card(deck))


def main():
    deck = [Card(suite, value) for value in VALUES for suite in SUITS]
    print("Das Spiel beginnt mische das Deck")
    random.shuffle(deck)
    print("Deck gemischt kann losgehen")

    player_a = Player(input("Spieler 1, wie lautet dein Name? "))
    player_b = Player(input("Spieler 2, wie lautet Dein Name? "))

    start_game(player_a, deck)
    print("Spieler 1 Deine Karten")
    player_a.show_cards()
    print("Spieler 2 Deine karten")
    player_b.show_cards()


if __name__ == "__main__":
    main()

Code: Alles auswählen

import random

Farben = ["Kreuz", "Pik", "Herz", "Karo"]
Werte = ["7", "8", "9", "10", "Bube", "Dame", "Koenig", "Ass"]
Skat = [(sFarbe, sWert) for sWert in Werte for sFarbe in Farben]


class Spieler:

    def __init__(self):
        self.name = None
        self.handKarten = []

    def ziehe_Karte(self, karte):
        self.handKarten.append(karte)

    def lege_Karte(self, nummer):
        if not self.handKarten:
            return ()
        karte = self.handKarten.pop(nummer)
        return karte

    def zeige_Handkarten(self):
        for i in range(0, len(self.handKarten)):
            print(self.handKarten[i])
        return ()

#Wenn keine Karten mehr zum Ziehen vorhanden sind, sollen die Karten auf dem Spielfeld gemischtt und als neues Deck genutzt werden. Ausnahme ist die letzt Karte auf dem Spielfeld, die bleibt im Spiel 
def neue_Spiefeldkarten(lKarten, spielfeldKarten):
    karte = spielfeldKarten.pop(len(spielfeldKarten)-1)
    lKarten = spielfeldKarten
    random.shuffle(lKarten)
    spielfeldKarten.clear()
    spielfeldKarten.append(karte)


def draw_card(lKarten, spielfeldKarten):
    if not lKarten:
        print("Keine Karte mehr im Deck")
        neue_Spiefeldkarten(lKarten, spielfeldKarten)
    karte = lKarten.pop(0)
    print("gezogene Karte %s %s" % karte)
    return karte


def start_game(spieler, deck, spielfeldkarten):
    for i in range(5):
        spieler.ziehe_Karte(draw_card(deck, spielfeldkarten))
    return ()


spielfeldkarten = []
print("Das Spiel beginnt mische das Deck")
random.shuffle(Skat)
print("Deck gemischt kann losgehen")

p1 = Spieler()
p2 = Spieler()

p1.name = input("Spieler 1, wie lautet dein Name? ")
p2.name = input("Spieler 2, wie lautet Dein Name? ")

start_game(p1, Skat, spielfeldkarten)
print("Spieler 1 Deine Karten")
p1.zeige_Handkarten()
spielfeldkarten.append(p1.lege_Karte(0))
spielfeldkarten.append(p1.lege_Karte(0))
neue_Spiefeldkarten(Skat, spielfeldkarten)
print("Zeige Spielfeldkarte")
for i in range(0, len(spielfeldkarten)):
    print(spielfeldkarten[i])

Code: Alles auswählen

    if not card.matches(table.top_card):
        print(f"{card} passt nicht auf {table.top_card}")

Code: Alles auswählen

In [622]: deck = []

In [623]: spielfeldkarten = [1, 2, 3, 4, 5]

In [624]: neue_Spiefeldkarten(deck, spielfeldkarten)

In [625]: deck
Out[625]: []

In [626]: spielfeldkarten
Out[626]: [5]

Code: Alles auswählen

In [627]: def neue_spiefeldkarten(spielfeldkarten):
     ...:     karte = spielfeldkarten[-1]
     ...:     karten = spielfeldkarten[:-1]
     ...:     random.shuffle(karten)
     ...:     return karten, [karte]
     ...: 

In [628]: spielfeldkarten = [1, 2, 3, 4, 5]

In [629]: neue_spiefeldkarten(spielfeldkarten)
Out[629]: ([2, 4, 1, 3], [5])

Code: Alles auswählen

spielfeldkarten = [karte]

Code: Alles auswählen

Spielfeldkarten = [karte]

Code: Alles auswählen

In [1]: spielfeldkarten = []

In [2]: spielfeldkarten[-1]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In [2], line 1
----> 1 spielfeldkarten[-1]

IndexError: list index out of range

In [3]: spielfeldkarten.pop()
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In [3], line 1
----> 1 spielfeldkarten.pop()

IndexError: pop from empty list

Code: Alles auswählen

deck, spielfeldkarten = neue_spiefeldkarten(spielfeldkarten)

Code: Alles auswählen

variable = 1000
def funktion(argument):
    argument = 2
funktion(variable)
print(variable)

Code: Alles auswählen

numbers = list(range(10))

def remove_odds(numbers):
    return [i for i in numbers if i % 2 == 0] # komplett neue Liste!

numbers = remove_odds(numbers) 

Code: Alles auswählen

import random
import os
from enum import Enum

class bcolors :
    OK = '\033[92m' #GREEN
    WARNING = '\033[93m' #YELLOW
    FAIL = '\033[91m' #RED
    RESET = '\033[0m' #RESET COLOR


class Kartenwert (Enum):
    SIEBEN = 0
    ACHT = 1
    NEUN = 2
    ZEHN = 3
    BUBE = 4
    DAME = 5
    KÖNIG = 6
    ASS = 8


class Sonderfunktion (Enum):
    NONE = 0
    SIEBEN = 1
    ACHT = 2
    BUBE = 3

class Kartenfarbe (Enum):
    NONE = 0
    KARO = 1
    HERZ = 2
    PIK = 3
    KREUZ = 4



class Spieler:

    def __init__(self, nummer = None, name= None, handKarten = None, aktiv = False):
        self.spielernummer = nummer
        self.name = name
        if handKarten is None:
            handKarten = []
        self.handKarten = handKarten
        self.aktiv = aktiv

    def get_Karte(self, karte):
        self.handKarten.append(karte)

    def lege_Karte(self, nummer):
        if not self.handKarten:
            return ()
        return self.handKarten.pop(nummer)

    def spieler_hat_sieben(self):
        return [wort for wort in self.handKarten if Kartenwert.SIEBEN in wort]

    def is_spieler_aktiv(self):
        return self.aktiv

class Spiel:

    def __init__(self, startspieler = None, farben = None, werte = None, spielkarten = None, karte = None, wunschfarbe = Kartenfarbe.NONE, sonderfunktion = None, spielanzahl = 0, maumauSpieler=[]):
        self.aktiverspieler = startspieler
        self.farben = farben
        self.werte = werte
        self.skat = [(sFarbe, sWert) for sWert in werte for sFarbe in farben]
        self.spielkarten = spielkarten
        self.karte =  karte
        self.sonderfunktion = sonderfunktion
        self.wunschfarbe = wunschfarbe
        self.spielanzahl = spielanzahl
        self.siebene = 0
        self.spieler = maumauSpieler
        self.karte_gezogen = False

    def bildschirm_leeren(self):
        self.loesche_console()
        text = bcolors.OK + "Als nächstes ist " + self.aktiverspieler.name + " dran, bitte Taste drücken" + bcolors.RESET
        input(text)
        self.loesche_console()

    def wechsel_spieler(self):
        kartengezogentext = None
        if self.sonderfunktion == Sonderfunktion.ACHT:
            self.sonderfunktion = Sonderfunktion.NONE
         #   self.bildschirm_leeren()
            #self.zeige_spieler_handkarten()
            return
        if(self.spieler[0].aktiv):
            self.spieler[0].aktiv = False
            self.aktiverspieler = self.spieler[1]
            self.spieler[1].aktiv = True
        else:
            self.spieler[1].aktiv = False
            self.aktiverspieler = self.spieler[0]
            self.spieler[0].aktiv = True
        if self.sonderfunktion == Sonderfunktion.SIEBEN and not self.aktiverspieler.spieler_hat_sieben():
            anzahlgezogen = self.siebene * 2
            kartengezogentext= bcolors.FAIL + ""+ str(anzahlgezogen)  +" Karten gezogen"+ bcolors.RESET
            for zahl in range(self.siebene):
                self.karte_ziehen()
                self.karte_ziehen()
                self.siebene = 0
            self.sonderfunktion= Sonderfunktion.NONE
        self.bildschirm_leeren()
        if kartengezogentext is not None:
            print(kartengezogentext)
        self.zeige_spieler_handkarten()

    def spielkarten_zurueckfuehren(self):
        karte = self.spielkarten[-1]
        self.skat = self.spielkarten[:-1]
        random.shuffle(self.skat)
        random.shuffle(self.skat)
        random.shuffle(self.skat)
        self.spielkarten.clear()
        self.spielkarten.append(karte)

    def karte_ziehen(self):
        if len(self.skat) == 0:
            self.spielkarten_zurueckfuehren()
        self.aktiverspieler.get_Karte(self.skat.pop())

    def alles_aufräumen(self):
        self.spieler[0].aktiv = False
        self.spieler[1].aktiv = False
        self.sonderfunktion = Sonderfunktion.NONE
        self.skat = [(sFarbe, sWert) for sWert in self.werte for sFarbe in self.farben]
        self.spielkarten=[]
        self.spieler[0].handKarten=[]
        self.spieler[1].handKarten=[]


    def spiel_starten(self):
        random.shuffle(self.skat)
        random.shuffle(self.skat)
        random.shuffle(self.skat)
        random.shuffle(self.skat)
        self.aktiverspieler = self.spieler[0]
        for i in range(5):
            self.karte_ziehen()
        self.aktiverspieler = self.spieler[1]
        for i in range(5):
            self.karte_ziehen()

    def erlaubter_zug(self):
        aktuelle_spielkarte = self.gib_letzte_Spielkarte()
        if self.sonderfunktion == Sonderfunktion.BUBE:
            if self.karte[0] == self.wunschfarbe and not self.karte[1] == Kartenwert.BUBE:
                self.sonderfunktion = Sonderfunktion.NONE
                return True
            else:
                return False
        else:
            if self.karte[0] == aktuelle_spielkarte[0] or self.karte[1] == aktuelle_spielkarte[1] or \
                    (self.karte[1] == Kartenwert.BUBE and aktuelle_spielkarte[1] != Kartenwert.BUBE):
                return True
            else:
                return False

    def lege_karte (self, index):
        index -= 1

        if index == (len(self.aktiverspieler.handKarten)) and self.karte_gezogen == False:
            self.karte_gezogen = True
            self.karte_ziehen()
            self.loesche_console()
            ziehtext = bcolors.OK + self.aktiverspieler.handKarten[-1][0].name + " " + self.aktiverspieler.handKarten[-1][1].name + " gezogen"+ bcolors.RESET
            input(ziehtext)
            self.zeige_spieler_handkarten()
        elif index == (len(self.aktiverspieler.handKarten) + 1) and self.karte_gezogen:
            spiel.karte_gezogen = False
            self.wechsel_spieler()
        elif index == (len(self.aktiverspieler.handKarten) + 1) and not self.karte_gezogen:
            print(bcolors.FAIL, "Sie müssen erst eine Karte ziehen oder ablegen um den Spieler zu wechseln", bcolors.RESET)
            self.zeige_spieler_handkarten()
        elif index == (len(self.aktiverspieler.handKarten)) and self.karte_gezogen == True:
            print(bcolors.FAIL, "Sie dürfen nur eine Karte ziehen", bcolors.RESET,)
            self.zeige_spieler_handkarten()
        else:
            self.karte = self.aktiverspieler.handKarten[index]
            if self.erlaubter_zug():
                self.karte_gezogen= False
                self.sonderfunktion= Sonderfunktion.NONE
                self.spielkarten.append(self.aktiverspieler.handKarten.pop(index))
                self.ueberpruefe_sonderfunktion()
                self.wunschfarbe= Kartenfarbe.NONE
                if self.sonderfunktion == Sonderfunktion.BUBE:
                   self.waehle_farbe()
                if len(self.aktiverspieler.handKarten) == 0:
                    return
                self.wechsel_spieler()
            else:
                print(bcolors.FAIL,"Unerlaubter Zug",bcolors.RESET)
                self.zeige_spieler_handkarten()


    def gib_letzte_Spielkarte(self):
        return (self.spielkarten[-1])

    def ueberpruefe_sonderfunktion(self):
        if self.gib_letzte_Spielkarte()[1] == Kartenwert.SIEBEN:
            self.sonderfunktion = Sonderfunktion.SIEBEN
            self.siebene += 1
        elif self.gib_letzte_Spielkarte()[1] == Kartenwert.ACHT:
            self.sonderfunktion = Sonderfunktion.ACHT
            if(self.aktiverspieler.spielernummer==1):
                self.bildschirm_leeren()
                print(bcolors.FAIL, self.spieler[1].name, "muss leider aussetzen", bcolors.RESET)
                text = bcolors.OK + self.aktiverspieler.name + " ist nochmal dran" + bcolors.RESET
                input(text)
                self.zeige_spieler_handkarten()
            else:
                self.bildschirm_leeren()
                print(bcolors.FAIL, self.spieler[0].name, "muss leider aussetzen", bcolors.RESET)
                text = bcolors.OK + self.aktiverspieler.name + " ist nochmal dran" + bcolors.RESET
                input(text)
                self.zeige_spieler_handkarten()
        elif self.gib_letzte_Spielkarte()[1] == Kartenwert.BUBE:
            self.sonderfunktion = Sonderfunktion.BUBE
        else:
            self.sonderfunktion = Sonderfunktion.NONE

    def zeige_spieler_handkarten(self):
        karte =self.gib_letzte_Spielkarte()
        if not self.spieler[0].aktiv:
            if len(self.spieler[0].handKarten) == 1:
                print(bcolors.FAIL, "ACHTUNG: ", self.spieler[0].name, " hat letzte Karte", bcolors.RESET)
            else:
                print(self.spieler[0].name, "hat ", len(self.spieler[0].handKarten), " Karten")
        else:
            if len(self.spieler[1].handKarten) == 1:
                print(bcolors.FAIL,"ACHTUNG: ", self.spieler[1].name, " hat letzte Karte", bcolors.RESET)
            else:
                print(self.spieler[1].name, "hat ", len(self.spieler[1].handKarten), " Karten")
        print(bcolors.OK,"Aktuelle Spielkarte: ", karte[0].name, karte[1].name, bcolors.RESET)
        if not(self.wunschfarbe == Kartenfarbe.NONE):
            print(bcolors.WARNING,"Gewünscht Farbe:", self.wunschfarbe.name,bcolors.RESET)
        print(self.aktiverspieler.name, "wähle aktion:")
        for i in range(0, len(self.aktiverspieler.handKarten)):
            print("(", i + 1, ")", " ", self.aktiverspieler.handKarten[i][0].name, self.aktiverspieler.handKarten[i][1].name, " legen")
        print("(", len(self.aktiverspieler.handKarten) + 1, ")", " Karte ziehen")
        print("(", len(self.aktiverspieler.handKarten) + 2, ")", " nächster Spieler")

    def waehle_farbe(self):
        print ("Wählen sie eine Kartenfarbe!")
        print ("1 Karo")
        print("2 Herz")
        print("3 Pik")
        print("4 Kreuz")
        auswahl = int(input("Auswahl"))
        self.wunschfarbe = Kartenfarbe(auswahl)

    def ermittle_nicht_aktiven_spieler(self):
        return ([spieler for spieler in self.spieler if spieler.aktiv==True])

    def ermittle_aktiven_spieler(self):
        return ([spieler for spieler in self.spieler if spieler.aktiv==False])

    def loesche_console(self):
        clearConsole = lambda: os.system('cls' if os.name in ('nt', 'dos') else 'clear')
        clearConsole()


print("==================TEXT MAU MAU============================================")
p1 = Spieler(nummer=1,name=input("Spieler1 bitte Deinen Namen eingeben! "))
p2 = Spieler(nummer=2,name=input("Spieler2 bitte Deinen Namen eingeben! "))


spiel = Spiel(startspieler=None, farben = [Kartenfarbe.KARO, Kartenfarbe.PIK, Kartenfarbe.HERZ, Kartenfarbe.KREUZ], werte= [Kartenwert.SIEBEN, Kartenwert.ACHT, Kartenwert.NEUN, Kartenwert.ZEHN,Kartenwert.BUBE, Kartenwert.DAME,Kartenwert.KÖNIG, Kartenwert.ASS],
              spielkarten= [], wunschfarbe= Kartenfarbe.NONE, sonderfunktion= None, spielanzahl=0, maumauSpieler=[p1,p2])
neues_spiel =True
while(neues_spiel):
    spiel.alles_aufräumen()
    spiel.spielanzahl +=1

    if spiel.spielanzahl%2 == 1:
        spiel.spieler[1].aktiv=True
        spiel.aktiverspieler = spiel.spieler[1]
    else:
        spiel.spieler[0].aktiv = True
        spiel.aktiverspieler = spiel.spieler[0]

    spiel.alles_aufräumen()
    spiel.spiel_starten()

    spiel.spielkarten.append(spiel.skat.pop())
    startkarte = spiel.gib_letzte_Spielkarte()
    print(bcolors.OK,"Erste Karte im Spiel: ", startkarte[0].name, " ",startkarte[1].name,  bcolors.RESET)
    input("Los geht es!")
    spiel.ueberpruefe_sonderfunktion()
    if spiel.sonderfunktion == Sonderfunktion.BUBE:
        spiel.loesche_console()
        spiel.zeige_spieler_handkarten()
        spiel.waehle_farbe()
    else:
        spiel.wechsel_spieler()
    spiel.loesche_console()
    spiel.zeige_spieler_handkarten()
    while(len(spiel.spieler[0].handKarten)>0 and len(spiel.spieler[1].handKarten)>0):
        spiel.lege_karte(int(input("Auswahl")))


    clearConsole = lambda: os.system('cls' if os.name in ('nt', 'dos') else 'clear')
    clearConsole()
    print (bcolors.OK, spiel.aktiverspieler.name, "hat das Spiel gewonnen",bcolors.RESET)
    neues_spiel=input('Neues Spiel? (y/n): ').lower().strip() == 'y'
print ("Danke fürs Spielen bis zum nächsten mal")

Code: Alles auswählen

 if __name__=="__main__":
    main()