Da ich noch wenig Ahnung von OOP hab, hab ich mir gedacht, ich mach mal irgendwas objektorientiertes. Ich hab einfach mal Poker genommen.
Ich hab 2 grundlegende Klassen, eine für einzelne Karten, eine für mehrere Karten (als Liste zusammengefasst), die erstmal noch nichts mit Poker zu tun haben.
Dann hab ich eine Klasse erstellt, die von der obigen Klasse erbt aber diese noch um eine Vergleichsfunktion nach Pokerregeln erweitern soll. Also diese Vergleichsfunktion sollte Pokerkombinationen erkennen und diese vergleichen können.
Da ist auch im Moment mein Problem, die Ideen die mir da kommen, scheinen mir viel zu umständlich.
Ich poste vielleicht erstmal, was ich habe, damit ihr euch mal ein allgemeines Bild davon machen könnt.
Code: Alles auswählen
# -*- coding: cp1252 -*-
import random
class Card(object):
"""
Stellt einen Datentyp dar, der die Eigenschaften einer Spielkarte (Farbe, Rang) beinhaltet, sowie eine Vergleichsfunktion
"""
colorsList = ["Kreuz", "Pik", "Herz", "Karo"]
ranksList = ["As", "König", "Dame", "Bube",
"10", "9", "8", "7", "6", "5", "4", "3", "2"]
def __init__(self, color=0, rank=0):
self.color = color
self.rank = rank
def __str__(self):
return self.colorsList[self.color] + " " + self.ranksList[self.rank]
def __cmp__(self, other):
"""
Nur Rang wird verglichen
"""
if self.rank == other.rank:
return 0
elif self.rank < other.rank:
return 1
else:
return -1
class CardPackage(object):
"""
Stellt einen Datentyp dar, der mehrere Card-Objekte zusammenfasst
"""
def __init__(self, none=1):
"""
Erstellt, falls none == 0 ist, eine Liste mit 52 Karten
"""
self.package = []
if none == 0:
for x in range(len(Card.colorsList)):
for y in range(len(Card.ranksList)):
self.package.append(Card(x, y))
def __str__(self):
output = ""
for i in xrange(len(self.package)):
output += str(self.package[i]) + "\n"
return output
def __add__(self, other):
newcardpackage = CardPackage()
newcardpackage.package = self.package + other.package
return newcardpackage
def GiveCard(self):
"""
Löscht eine Karte aus self.package und gibt ihren Wert zurück
"""
return self.package.pop()
def GetCard(self, card):
"""
Fügt eine Karte vom Kartenstapel package (vorgesehen als Instanz von CardPackage()) zu self.cards hinzu.
"""
return self.package.append(card)
def mix(self):
"""
Mischt die Karten, die sich im self.package befinden
"""
return random.shuffle(self.package)
def sort(self):
"""
Sortiert die Karten nach der __cmp__ Methode der Klasse Card nach Rang und anschließend zweitrangig nach Farbe
"""
self.package.sort(Card.__cmp__)
for j in xrange(3):
for i in xrange(len(self.package)-1):
if self.package[i].rank == self.package[i+1].rank:
if self.package[i].color < self.package[i+1].color:
self.package[i], self.package[i+1] = self.package[i+1], self.package[i]
class PokerHand(CardPackage):
"""
Das Selbe, wie CardPackage mit Vergleichs-Funktionen nach Poker Texas Hold'em Regeln.
"""
def __init__(self):
CardPackage.__init__(self)
def __add__(self, other):
newpokerhand = PokerHand()
newpokerhand.package = self.package + other.package
newpokerhand.sort()
return newpokerhand
def __cmp__(self, other):
pass
class PokerPlayer(object):
def __init__(self, name):
self.name = name
self.cards = PokerHand()
def __str__(self):
return "Blatt von " + self.name + "\n\n" + self.cards.__str__()
Ihr könnt mir sicher 1000e Kleinigkeiten nennen aber worauf's mir gerade am meisten ankommt: Was haltet ihr von der Klassenaufteilung? Mir kommt das teilweise (dafür dass es nur so ein einfaches (halbes!) Poker ist) viel zu umständlich vor. Zum Beispiel so eine Zeile, wenn ich einem Spieler eine Karte vom Stapel geben will:
Code: Alles auswählen
player.cards.GetCard(stapel.GiveCard())
Also mir kommt es eigentlich hauptsächlich auf die Umsetzung als objektorientiertes Spiel an, das ganze rein prozedual zu schreiben wäre für mich sicherlich kein Problem, ich wollte einfach mal ein wenig praktische Erfahrung im Bereich OOP sammeln und würde jetzt gerne hören, was ihr dazu sagt (negative Kritiken erwünscht :p)
