Seite 1 von 1

OO Frage...

Verfasst: Montag 19. Mai 2008, 12:18
von nemomuk
Hallo,

ich probiere gerade etwas mit oo Programmierung rum und stehe gerade vor einem Problem...

Code: Alles auswählen

import random

class Spielblatt(object):
    def __init__(self):
        self.werte = range(7, 11) + ["Sau", "Ober", "Unter"]
        self.farben = ["Eichel", "Gras", "Herz", "Schelln"]
        self.blatt = []
        for farbe in self.farben:
            for wert in self.werte:
                self.blatt.append([farbe,wert,None])
    
    def mischen(self):
        " Mischt die Karten neu. "
        random.shuffle(self.blatt)
        
    def auszaehlen(self):
        " Zählt die Punkte von beiden Teams. "
        pass
        
class Spieler(Spielblatt):
    def __init__(self):
        Spielblatt.__init__(self)
        print self.blatt
        
a = Spielblatt()
a.mischen()
Spieler()
Ich will hiermit zB einmal die Karten neu austeilen in dem ich ein neues Objekt Spielblatt erstelle und dieses dann mische, danach sollte es dann 4 Spieler geben, die auf diese Karten zugreifen (und jeder Spieler wird als neues Objekt erstellt). Mein Problem ist nun: Wie kann ich der Klasse Spieler beibringen auf ein bestimmtes Objekt "Spielblatt" (hier "a") zuzugreifen (damit auch in jeder Runde auf die gleichen Karten zugegriffen wird)?

Danke!

MfG

Verfasst: Montag 19. Mai 2008, 12:27
von Zap
Ich persönlich finde den Ansatz etwas komisch warum ist ein Spieler von Spielblatt abgeleitet?!
Ableitungen verwendet man dann wenn Objekt die Eigenschaft eines abstrakteren Objekts übernehmen und erweitern.
Wenn dann sollte ein Spieler einen Satz Karten über eine Methode ausgehändigt bekommen. Man muss einfach die Anwendungsfälle und Interaktionen der unterschiedlichen Charactere(Objekte) durchgehen.
Einen Spieler (auf) zu mischen ist vielleicht möglich gehört aber wohl nicht zum Spiel ;)

Ich habe jetzt so auf die schnelle zwar keinen Vorschlag wie man das ganze optimal aufbauen könnte, bin mir aber sicher das es zum Thema Kartenspiel oder andere Spiele wie Schache viele gute OO Designs gibt die man sich angucken könnte.

Verfasst: Montag 19. Mai 2008, 12:29
von nemomuk
ja, das mit dem Ableiten war nur ein verzeifelter Versuch irgendwie das Attribut "self.blatt" in der Klasse Spieler verfügbar zu machen...

Verfasst: Montag 19. Mai 2008, 12:53
von Y0Gi
Ein exemplarischer Vorschlag:

Code: Alles auswählen

class Spieler(object):

    def __init__(self, name):
        self.name = name
        self.blatt = None


# Blatt vorbereiten.
blatt = Spielblatt()
blatt.mischen()

# Spieler erzeugen.
players = []  # `players` ist durch das Mehrzahl-'s' deutlicher als `spieler`.
for i in xrange(1, 5):
    player = Spieler('Spieler #%d' % i)
    # Dem Spieler fünf Karten geben.
    player.blatt = blatt.retrieve(5)
    players.append(player)

Verfasst: Montag 19. Mai 2008, 15:51
von nemomuk
Vielen Dank!

Genau so etwas habe ich gesucht...

Verfasst: Montag 19. Mai 2008, 17:58
von nemomuk
So, nun bin ich schon etwas weiter und habe versucht das ganze Programm so objektorientiert wie möglich zu machen und nach meinen Ermessen auch sinnvoll einzusetzen.

Das ist natürlich noch nicht annähernd fertig, man kann bis jetzt nur Karten anschauen und es wird ermittelt wer spielt... Das ganze geht jetzt auch noch davon aus, dass der User keine falschen Eingaben macht bei der Auswahl. Aber ich habe mir gedacht, das spare ich mir, da das ganze eh noch in ein GUI gepackt werden soll.

http://paste.pocoo.org/show/51415/

Was könnte man noch verbessern?

Danke!

Verfasst: Montag 19. Mai 2008, 22:57
von Leonidas
Na das ``players``-Dict finde ich sehr suspekt wo Zahlen als Keys genutzt weren (Hint: es gibt ein Dict,wo zahlen als Index benutzt werden. Nennt sich List). Die ganzen Zeilen um das zu füllen, lassen sich mit einer LC genauso ausdrücken.

Die Null beim Slice-Beginn ist implizit, die musst du nicht angeben. Genauso wie -1 beim Ende.

Spieler ist kein Spielblatt. Immer noch nicht. Wird er auch nie sein.

Ich würde zusätzlich noch eine Karten-Klasse einführen, die man um ihre Wertigkeit befragen kann (``wertigkeit``-Property), etc.
Dann würde ``Spielblatt.wertigkeit`` etwa durch den Code ``return sum(karte.wertigkeit for karte in self.karten)`` beschrieben werden.

Um die Doppelpunkte um Dicts Leerzeichen schreiben.

Ich weiß nicht, ob ``werte`` und ``farben`` üerhaupt Instanzvariablen sein müssen. Eher Klassenvariablen. Wenn überhaupt.

Code: Alles auswählen

if spielen in ('Y', 'y'):
oder

Code: Alles auswählen

if spielen.lower() == 'y':
``start`` würde man ``main`` nennen.

Verfasst: Dienstag 20. Mai 2008, 08:03
von nemomuk
Wieder mal muss ich mich bei dir ausdrücklichst bedanken, dass du dir die Mühe gemacht hast, diesen Code durchzuarbeiten!

Vielen Dank!