--->Kartenspiel programmieren<----

[Michael Schneider]

Hi,

sorry, habe nicht beachtet, dass randint auch die Obergrenze zurückgeben kann. In dem Fall muss man noch 1 von der Länge der Liste abziehen. Habe das mal angepasst.

Grüße,
Michael

[AphrodiTe]

@raphael:
thx...habe ich als buch ...ich komme nur nich sogut damit klar...

@black:
was soll ich nun nehmen? shuffle oder das andere?

thx
kai

[BlackJack]

Ich würde `shuffle()` zum Mischen nehmen, Slice-Syntax zum "massenweise" Karten austeilen, und zum ziehen einzelner Karten `list.pop()` ohne Index, also von hinten. Das ist am effizientesten.

[AphrodiTe]

also...kurz noch zum erlären...ich bin ein anfänger in python....ich kann eine handvoll befehle,mehr nciht.
Das was ich jetzt ahbe ist:

Code: Alles auswählen

from random import randint

def draw_card(lKarten):
    if not lKarten:
        return ()
    return lKarten.pop(randint(0, len(lKarten)-1))
   
lFarben = ["Kreuz", "Pik", "Herz", "Karo"]
lWerte = ["7", "8", "9", "10", "Bube", "Dame", "Koenig", "Ass"]
lKarten = [(sFarbe, sWert) for sWert in lWerte for sFarbe in lFarben]

print "Deine Hand"
for i in xrange(10):
    print "gezogene Karte: %s %s" % draw_card(lKarten)


print "andere hand"
for i in xrange(10):
    print "gezogene Karte: %s %s" % draw_card(lKarten)

print "dritte hand"
for i in xrange(10):
    print "gezogene Karte: %s %s" % draw_card(lKarten)

print "skat"
for i in xrange(10):
    print "gezogene Karte: %s %s" % draw_card(lKarten)

dass das programm den skat ausgibt ist nur zur kontrolle, dass es auch richtig arbeitet.

also. wollte jetzt eigentlich nur dass man selber ("Deine Hand") anfängt eine Karte zu legen und dass die andern jeder auch eine legen und dann überprüft wird welche gewinnt(welche den höchsten wert hat)

Vielen Dank
Kai

[merlin_emrys]

also. wollte jetzt eigentlich nur ...

Das "nur" gefällt mir .

Wie sollen die beiden "KI-Mitspieler" denn Karten legen? Rein willkürlich oder nach irgendeinem Schema?

Und hast Du schon Ideen zum Vergleich, welche Karte den höchsten Wert hat?

[AphrodiTe]

ja habe ich =),
also eigentlich genau wie beim skat.
karo<herz<pik<kreuz <----Trumpf lassen wir mal weg...

7<8<9<10<dame<könig<ass<bube

die gegner sollen nach keinem schema ziehen(noch nciht)...sie sollen erstmal von anderen spielern (indem fall mir) gesteuert werden

vielen dank#
kai

[schlangenbeschwörer]

Ich hab auch mal ein Kartenspiel geschrieben (ich müsste es mal fertigschreiben), und das mit den Werten ist echt ein kleines Problem...
Ich habe es so gelöst, das ich im Programm die Karten so verarbeitet hab, das eine Karte durch ein Zahlenpaar dargestellt wurde. Eine Zahl für die Farbe und eine für den Wert. Damit kann man gut rechnen und auch leicht bestimmen, welche "wertvoller" ist. Vor der Ausgabe/ nach der Eingabe, wird dann halt noch übersetzt. Aber ich denke das ist einfacher, als jedesmal Strings zu vergleichen. Und so kann man auch leichter kompliziertere Sachen prüfen, zB ob es sich um eine Bildkarte handelt usw.

[AphrodiTe]

heißt das z.b alle herz karten zahlen zuzuordnen die durch drei teilbar sind??

[BlackJack]

Er hat jeder Karte ein Zahlen*paar* zugeordnet, am besten in der Reihenfolge (Wert, Farbe), weil die Tupel selbst dann schon einfach vergleichbar sind.

Allerdings sollte man das IMHO schon in Klassen verpacken.

[AphrodiTe]

könnt ihr vielleicht ein beispiel machen weil ich das os nciht verstehe sryy
was kommt danahc

[AphrodiTe]

Code: Alles auswählen

from random import randint

def draw_card(lKarten):
    if not lKarten:
        return ()
    return lKarten.pop(randint(0, len(lKarten)-1))
   
lFarben = ["Kreuz", "Pik", "Herz", "Karo"]
lWerte = ["7", "8", "9", "10", "Bube", "Dame", "Koenig", "Ass"]
lKarten = [(sFarbe, sWert) for sWert in lWerte for sFarbe in lFarben]

print "Deine Hand"
for i in xrange(10):
    print "gezogene Karte: %s %s" % draw_card(lKarten)

wie kann ich die gezogenen karten in eine seperate liste apcken?

[merlin_emrys]

wie kann ich die gezogenen karten in eine seperate liste apcken?

Indem Du zunächst eine leere Liste erzeugst und die Karten dann vor oder nach der Bildschirmmeldung mit append() hinzufügst.

Edit:
Ich habe keine Ahnung von Skat. Pokern kann ich, aber Skat...
Wenn alle Karokarten geringeren "Wert" haben als alle Herzkarten, kann man das "Symbol" als Zehnerstelle einer zweiziffrigen Zahl nehmen und die "Zahl" bzw. das "Bild" als Einerstelle.
Was ich mir vorstellen könnte, ist, daß bei der Tupel-Version etwas ähnliches gemacht wurde. Du kannst für jede Karte ein Tupel ("Symbolwert", "Bildwert") erstellen, wobei Symbolwert z.B. Karo = 1, Herz = 2 usw. ist und Bildwert Sieben = 1, Acht = 2 usw.
Dann kannst Du einfacher als bei der zweiziffrigen Zahl sagen: "Ich möchte jetzt die Symbole vergleichen" oder "Ich möchte den Bildwert vergleichen" - Du nimmst einfach den jeweiligen Tupelwert, indem Du die erste Position oder die zweite abfragst. Dabei mußt Du nur darauf achten, daß die erste Position des Tupels die Nummer "0" hat, also Tupel[1] die zweite Position ist.

Verstehe ich Dich jetzt richtig, daß Du im Grunde alle drei Spieler steuern willst? Oder soll ein anderer Mensch den eigentlichen Spieler darstellen?

[AphrodiTe]

Also...
die 2 andern spieler sollen erstmal von mir gesteuert werden.wenn das spiel fertig ist will ich dass sie sich sozusagen selber steuern...
aber ncohmal zu den listen.
ich verstehe das mit dem append nciht.
python sagt mir dass append nciht defeniert ist...kannste mir den append() befehl mal mit einbauen in das:

Code: Alles auswählen

from random import randint

def draw_card(lKarten):
    if not lKarten:
        return ()
    return lKarten.pop(randint(0, len(lKarten)-1))
   
lFarben = ["Kreuz", "Pik", "Herz", "Karo"]
lWerte = ["7", "8", "9", "10", "Bube", "Dame", "Koenig", "Ass"]
lKarten = [(sFarbe, sWert) for sWert in lWerte for sFarbe in lFarben]

print "Deine Hand"
for i in xrange(10):
    print "gezogene Karte: %s %s" % draw_card(lKarten)

[Michael Schneider]

Hallo BlackJack,

Nimm um Himmels willen `shuffle()`. Dieses gepoppe ist ja nicht mit anzusehen.

Deine Abneigung gegenüber Poppen kann ich nicht nachvollziehen. Gerade weil das Problem war, von einem Stapel zu ziehen, kommt das pop der Realität doch am nächsten. Du kannst Elemente entnehmen (pop) und auch wieder draufschieben. Dass das Poppen aus der Liste nicht die effektivste Methode ist, sollte beim Ausgeben von Skatkarten nebensächlich sein, selbst auf einem 386er.
Das Slicen von Teillisten ist kein Ziehen und die Objekte gibt es dann mehrfach.

@Michael: Was immer Du da über `shuffle()` denkst ist mit Sicherheit falsch. Das ist zum Mischen einer Sequenz gedacht und tut auch genau das.

Ok, Du hast recht. Habe mir das Modul nochmal angesehen und es geht tatsächlich nur einmal durch die Liste (wäre auch extrem dumm, wenn nicht). Ich habe damals nur den Austausch gesehen:

Code: Alles auswählen

x[i], x[j] = x[j], x[i]

... und habe das zu fix überflogen.

Grüße,
Michael

[Leonidas]

Nimm um Himmels willen `shuffle()`. Dieses gepoppe ist ja nicht mit anzusehen.

Deine Abneigung gegenüber Poppen kann ich nicht nachvollziehen. Gerade weil das Problem war, von einem Stapel zu ziehen, kommt das pop der Realität doch am nächsten. Du kannst Elemente entnehmen (pop) und auch wieder draufschieben. Dass das Poppen aus der Liste nicht die effektivste Methode ist, sollte beim Ausgeben von Skatkarten nebensächlich sein, selbst auf einem 386er.

Es geht nicht um die Performance sondern darum, dass man quasi selbst etwas nachimplementiert, was es schon gibt. Das Problem ist hierbei, dass man damit Zeit verliert, weil man es implementieren muss und möglicherweise eine Fehlerquelle bekommt, wenn der Code sich irgendwie im Index irrt. ``random.shuffle()`` hingegen funktioniert (da es ja auch sehr ausführlich getestetwurde). Definitiv.

[BlackJack]

@Michael Schneider: Der Realität kommt `shuffle()` und `pop()` ohne Index am nächsten, also das was ich vorgeschlagen habe. Nach dem Slicen gibt's die Objekte nicht mehrfach, nur mehr Referenzen darauf. Und natürlich kann man die Slices in der Originalliste auch löschen. Man muss die Realität auch nicht bis ins kleinste Detail nachbilden wenn es einfachere oder zweckmässigere Modellierungen gibt.

@AphrodiTe: `append()` ist eine Methode auf Listen. Hast Du schon das Tutorial in der Python-Dokumentation durchgearbeitet? Das ist für die Grundlagen zu empfehlen.

Und gewöhn Dir bitte die ungarische Notation bei Namen ab. Das ist schrecklich und irreführend wenn man den Typ mal ändern sollte und nicht die Namen anpasst.

[Michael Schneider]

Hallo,

von mir aus kann man auch Shuffle verwenden. Aber wenn ich das hier eingebe:

Code: Alles auswählen

shuffle(lKarten)
print len(lKarten)

Bekomme ich nur eine Liste mit 28 Karten, statt 32. Warum?

Ich habe mal noch eine Funktion geschrieben, die zu jedem Stich die gueltige Werteliste der Karten berechnet. Den Index der Karte innerhalb dieser Liste kann man verwenden, um den Rang der Karte innerhalb des Stiches zu ermitteln. Die Liste respektiert neben der Farbe und dem Wert auch die Art des Spiels (Grand, Null, Farbe) und die ausgespielte Karte:

Code: Alles auswählen

from random import randint

#   Initialisierung
lFarbspiel = ["Ass", "10", "Koenig", "Dame", "9", "8", "7"]
lNullspiel = ["Ass", "Koenig", "Dame", "Bube", "10", "9", "8", "7"]
lFarben = ["Kreuz", "Pik", "Herz", "Karo"]

lKarten = [(sFarbe, sWert) for sWert in lFarbspiel for sFarbe in lFarben]


def draw_card(lKarten):
    if not lKarten:
        return ()
    return lKarten.pop(randint(0, len(lKarten)-1))

def create_order_list(tAusgespielt, sSpiel="Grand"):
    """Erzeugt eine Liste, die die Reihenfolge der Kartenwerte darstellt.

    tAusgespielt - erwartet ein Kartentupel aus (Farbe, Wert)
    sSpiel       - die Spielart: "Grand", "Null", "Kreuz", "Pik", "Herz", "Karo"
    """
    lOrder = []
    
    #   die Karte wird zerlegt in Farbe und Wert
    sAusspielFarbe, sAusspielWert = tAusgespielt

    #   Beim Grand gilt die Wertordnung des Farbspiels, Buben sind Trumpf    
    if sSpiel == "Grand":
        #   Trumpf (Buben) einfuegen
        lOrder.extend([(sFarbe, "Bube") for sFarbe in lFarben])
        #   Farbe der ausgespielten Karte einfuegen
        lOrder.extend([(sAusspielFarbe, sWert) for sWert in lFarbspiel])
        #   Sonstige Karten einfuegen
        lOrder.extend([(sFarbe, sWert) for sFarbe in lFarben
                                           for sWert in lFarbspiel
                                               if not sFarbe==sAusspielFarbe])

    #   Beim Nullspiel reihen sich 10 und Bube ein
    elif sSpiel == "Null":
        #   Farbe der ausgespielten Karte einfuegen
        lOrder.extend([(sAusspielFarbe, sWert) for sWert in lNullspiel])
        #   Sonstige Karten einfuegen
        lOrder.extend([(sFarbe, sWert) for sFarbe in lFarben
                                           for sWert in lNullspiel
                                               if not sFarbe==sAusspielFarbe])

    #   Bei Farbspielen ist 10 > Koenig, Buben sind hoechste Trumpf
    elif sSpiel in lFarben:
        #   Buben einfuegen
        lOrder.extend([(sFarbe, "Bube") for sFarbe in lFarben])
        #   Trumpffarbe (= Spielfarbe) einfuegen
        lOrder.extend([(sSpiel, sWert) for sWert in lFarbspiel])
        #   Farbe der ausgespielten Karte einfuegen, wenn sie nicht Trumpf ist
        if not sSpiel == sAusspielFarbe:
            lOrder.extend([(sAusspielFarbe, sWert) for sWert in lFarbspiel])
        #   Sonstige Karten einfuegen
        lOrder.extend([(sFarbe, sWert) for sFarbe in lFarben
                                           for sWert in lFarbspiel
                                               if not sFarbe in (sAusspielFarbe, sSpiel)])

    else:
        print "Spielart '%s' ist nicht bekannt" % sSpiel
    return lOrder        

#   erzeugt 3 Kartensets a 10 Karten ('Spieler 1', 'Spieler 2', 'Spieler 3') und den Skat
dKartenSets = {}
for iSpieler in xrange(1, 4):
    dKartenSets["Spieler %i" % iSpieler] = [draw_card(lKarten) for i in xrange(10)]
dKartenSets["Skat"] = lKarten

################################################################################
#   Auswertung/Test
print "Deine Hand"
for tKarte in sorted(dKartenSets["Spieler 1"]):
    print "gezogene Karte: %s %s" % tKarte

#   einen Stich zusammenstellen und fuer verschiedene Spiele gegenueberstellen
t1, t2, t3 = ("Karo", "Dame"), ("Karo", "10"), ("Kreuz", "Ass")
lStich = [t1, t2, t3]

print "="*60
print "Karten des Stichs:", lStich
print "%s %s wird ausgespielt" % t1
for sSpiel in ("Grand", "Null", "Karo", "Kreuz", "Pik"):
    print "\nbeim %s:" % sSpiel
    lKartenWert = create_order_list(tAusgespielt=t1, sSpiel=sSpiel)
    print sorted(lStich, key=lKartenWert.index)

Geht aber bestimmt auch einfacher und besser für Anfänger geeignet.

@BlackJack, hast wieder mal recht. Ich dachte Du wärst kategorisch gegens Poppen.

Grüße,
Michael

[merlin_emrys]

Aber wenn ich das hier eingebe:

Code: Alles auswählen

shuffle(lKarten)
print len(lKarten)

Bekomme ich nur eine Liste mit 28 Karten, statt 32. Warum?

Das kann ich nicht reproduzieren; bei mir sind es nach dem shufflen noch immer 32 Karten... Welche fehlen denn? (Bein Pokern würde ich ja zuerst gezielt nachsehen, ob noch alle Asse dasind, aber ich nehme an, das ist beim Skat nicht so relevant...? Andernfalls würde ich mit der KI mal über Mogeln beim Kartenspiel reden wollen ...)

[Rebecca]

Deine Abneigung gegenüber Poppen kann ich nicht nachvollziehen.

Ich auch nicht.

SCNR

[BlackJack]

Ich wurde ja auch falsch verstanden. Ich bin nur gegen wildes, zufälliges poppen, anstelle eines effizienten poppens immer schön der Reihe nach, von hinten.