OO denkwijze bij kaartspel

[bvp]

Ik wil in mijn vrije tijd een simpel kaartspelletje gaan maken maar dan wel volgens het OO concept.
Nu zit ik eigenlijk vrijwel in het begin al vast omdat ik het kaartspel misschien dus nog wel eens wil gaan uitbreiden met andere kaartspelletjes en dan bijv. de klasse kaart, stok etc. wel wil hergebruiken.

Probleem is als volgt:
Ik heb een Class Kaart met de attributen naam en Image.
Ik heb een Class Stok met als attributen aan array met alle kaarten.

Nu wil ik dus bijv blackjack maken waarin een bepaalde kaart een bepaald aantal punten heeft. Plaatjes 10 etc. etc.

Nu zou ik dus in mijn Class Kaart een attribuut op kunnen nemen met een int waarde, met als argument dat het de verantwoordelijkheid is van de Class Kaart zijn waarde te kennen.
Je zou ook kunnen zeggen dat dit ondergebracht moet worden in een seperate array in de Class Stok omdat de stok de waarde moet kennen van elke kaart die hij in zich heeft.

Voor een ander kaartspel zou de waarde van een kaart wel eens helemaal niet relevant hoeven te zijn (bijv. Pesten) hier zou je dan weer een x-tra attribuut in de Class Kaart op moeten nemen met welke handeling die kaart doet.
Hierdoor zou je dan dus de waarde van elke kaart in bijv. de Class BlackJack op moeten nemen. Maar op wat voor manier hier dan?

Wat zijn jullie ideeën hierover? Of denk ik nog niet 'OO' genoeg op deze manier?

[whoami]

Ik zou 'de waarde' die je aan een kaart toekent, geen member van Card laten zijn. Die waarde is nl. afhankelijk van de context waarin die kaart gebruikt wordt.
Wellicht maak je dus beter een class 'Game', waar je dan de kaart in de juiste context kunt gebruiken, of die de juiste waarde / attribuut / whatever van een kaart kan returnen.

[Yoeri]

Je maakt gewoon een klasse 'Kaart' met eigenschappen die voor alle kaartspellen van belang zijn en in specifieke spelletjes erf je van die klasse kaart, maar met de spelspecifieke uitbreidingen erbij?

[whoami]

specifieke spelletjes erf je van die klasse kaart

Dat vind ik best ugly. Dit zal leiden tot een 'class explosion'.
Dit wil dus zeggen dat je voor iedere Game een nieuwe kaart-class introduceert, terwijl je imho die verantwoordelijkheid best bij de Game class legt.

[kasper_vk]

Tja, je zult die informatie inderdaad moeten scheiden; het aantal punten van een kaart is gerelateert aan een specifiek (kaart)spel.

Ik heb zelf een klaverjas-programma gemaakt (uiteraard in zwaaaaaar aplha / w.i.p. stadium ) en daar liep ik tegen zetzelfde probleem aan. De puntentelling & rangorde kan bijvoorbeeld per spel verschillen (bij klaverjassen zijn er zelfs 3 rangorden die ertoe doen), dus ik heb de puntentelling en rangorde in aparte klassen gestopt.\
Die puntentelling / rangorde zou je dan wel weer kunnen hergebruiken bij een ander kaartspel / andere variant.

Maar zelfs dan is de hoeveelheid te hergebruiken materiaal nog redelijk beperkt; logisch, want er zijn nou eenmaal tig kaartspellen bedacht, die eigenlijk allemaal maar een relatief klein gemeenschappelijk deel hebben, zoals de kaarten zelf (met soort en rang), het schudden & verdelen van kaarten, en een hand met kaarten die een speler heeft.
Daarna wordt het inderdaad allemaal wel erg 'optioneel' of sterk afhankelijk van het spel welke aspecten / decoraties je nog extra nodig hebt.

Wellicht dat er met patterns dan nog een spel-specifiek laagje over dergelijke generieke klassen gelegd kan worden, daar kun je wellicht wel behoorlijk hergebruik mee realiseren, bedenk ik me nu.

Edit: Wellicht dat die class-explosion waar Whoami het over heeft kan worden voorkomen door met een of ander geschikt design pattern te werken. Decorators zijn toch wel eerste waar ik dan aan denk.

[ Voor 6% gewijzigd door kasper_vk op 26-09-2006 09:43 ]

[kenneth]

bvp schreef op dinsdag 26 september 2006 @ 09:28:
... een simpel kaartspelletje ... misschien dus nog wel eens wil gaan uitbreiden ...

Om maar gelijk op de filosofische tour te gaan en het technische te negeren, ligt hier niet je probleem? Als je iets simpels wil maken, moet je dat vooral doen Een bekende valkuil is om vanaf het begin allerlei algemeenheden en uitbreidbaarheden mee te nemen omdat je misschien ooit nog eens ...

YAGNI

[kasper_vk]

kenneth schreef op dinsdag 26 september 2006 @ 09:42:
[...]
Om maar gelijk op de filosofische tour te gaan en het technische te negeren, ligt hier niet je probleem? Als je iets simpels wil maken, moet je dat vooral doen Een bekende valkuil is om vanaf het begin allerlei algemeenheden en uitbreidbaarheden mee te nemen omdat je misschien ooit nog eens ...

En inderdaad; goed nadenken over je verantwoordelijkheden van je klassen is goed, maar nu al veel / uberhaubt gaan kijken naar dit soort abstactie / mogelijk hergebruik levert je straks misschien een 70% compleet frameworkje op voor kaartspellen, terwijl je jouw oorspronkelijke ene kaartspel helemaal niet gemaakt hebt en (daardoor) zwaar gedemotiveerd raakt.

[bvp]

Dank jullie wel voor de snelle antwoorden en kenneth daar heb je misschien wel een heel mooi punt idd.
Maar het is juist dat ik het gewoon generiek op wil zetten puur om die OO denkwijze een beetje te stimuleren en niet 'omdat ik misschien ooit nog eens...'.
En van de andere kant daarvoor is toch juist ook weer het hele concept OO, gemakkelijk uitbreidbaar, beter onderhoudbaar etc. etc.

Maar whoami, met die Class Game bedoel je daar dan dus eigenlijk mee zoals ik de Class BlackJack in dit geval bedoelde. Of juist naast bijv. een class BlackJack, Poker, Pesten nog een Class Game die voor de verschillende varianten gebruikt kan worden? En op wat voor manier zou je hier dan de puntentelling voor verschillende Games in afhandelen?

Eindeloos overerven van de Class Kaart zou ik hier denk ik ook niet direct voor kiezen?

[Verwijderd]

Ik zou zelf een basisklasse Game maken met enkele basis methoden en attributen. Waarschijnlijk zal dit geen erg uitgebreide klasse zijn, omdat de meeste code per spel verschilt. Voor elk spel zou ik overerven van deze Game klasse.

Verder zou ik naast de klasse Card ook een soort Deck klasse maken, die een Collection is van Card. Denk ook na over hoe je spellen met meerdere Decks implementeert: gebruik je 1 Deck waarbij je meer van dezelfde kaarten doet of juist meer decks? In dat eerste geval is kaarten schudden makkelijker, omdat schudden een methode van Deck zou moeten zijn (of zien jullie dit anders?)

Ik ben het eens met de mening dat de waarde van kaarten echt bij het spel hoort en dat je dat dus niet moet opnemen in je Card klasse.

Ik ben trouwens wel benieuwd hoe je het beste met een Hand kan omgaan. Hoort dit bij een spel?

[MicroWhale]

ik zou een kaart maken met

groep
waarde
image

Waar de naam uiteindelijk samengesteld is met <groep><naam>

Zo kun je als groepen schoppen, ruiten, harten en klaveren nemen.
en als waarde 1..9 + boer, koning, dame en aas. (let op dit is niet de 'belangrijkheid van de kaart', zie 'score')

Dit is bij het opstellen van regels in je spel wel zo makkelijk denk ik. Dan kun je namelijk ook alleen de groep of de waarde controleren, zonder dat je die uit de naam hoeft te halen.

In een game-klasse kun je dan voor één of meerdere (combinaties) kaarten een bepaalde scores bepalen. Deze scores kunnen berekend worden aan de hand van datgene wat de speler in zijn hand heeft.

In principe kun je ook nog een klasse "Player Hand" genereren als je wilt.

[ Voor 29% gewijzigd door MicroWhale op 28-09-2006 15:51 ]

[MBV]

Ik vind dat decorator-idee misschien wel aardig. Je kan zeggen dat je kaart een bepaalde 'standaard'-waarde heeft, bijv 2-10-boer-vrouw-heer-aas (1-13). Vervolgens maak je een BlackJackCardDecorator o.i.d. die de waarde omzet naar iets waar je in het spel wat aan hebt

[mulder]

MBV schreef op donderdag 28 september 2006 @ 16:24:
Ik vind dat decorator-idee misschien wel aardig. Je kan zeggen dat je kaart een bepaalde 'standaard'-waarde heeft, bijv 2-10-boer-vrouw-heer-aas (1-13). Vervolgens maak je een BlackJackCardDecorator o.i.d. die de waarde omzet naar iets waar je in het spel wat aan hebt

Niet nodig denk ik, BlackJackGame heeft een collectie van Kaart. Kaart heeft een property Value.

[MBV]

Jij stopt de waarde dus in de game, ik stop het in een decorator. 2 mogelijke oplossingen voor hetzelfde probleem

[MaxxRide]

Ik zie het zo, de kaarten en het dek zijn basiselementen van het spel. Ze dienen enkel iets over zichzelf te zeggen. "Ik ben klaver 10, Ik ben de Joker etc, ik heb nog 48 kaarten op de stapel". En functies die elementair bij hen horen, dus bij Stok, " Geef de bovenste kaart, schud, reset, resetEnSchud" etc.

Verder heb je een class die verantwoordelijk is voor de logica van je spelletje, dus bepaling van de waarde, de voortgang van het spel etc. (Niet gezegd dat dit 1 class is)

Op deze manier verdeel je de verantwoordelijkheden naar de zelfstandige objecten

[Confusion]

Het kaartspel is een klasssiek Java 1.5 voorbeeld voor het gebruik van enums: http://java.sun.com/j2se/...guide/language/enums.html

[Verwijderd]

Ik ben zelf toevallig ook bezig met een kaartspel, maar dan voor Texas Hold'em.

Ik heb dit als volgt aangepakt.

Een Card class met een Guid.
Een PlayingCard die overerft van Card, met 2 attributen, Suit en Rank. Dit zijn 2 enums.

Een StandardDeck class die 52 kaarten bevat en de functies:
Shuffle, sorteert de kaarten op Guid, leek me random genoeg
Deal, geeft de bovenste kaart van deck terug en verwijderd deze van t deck

De kaart is zo goed genoeg om gebruikt te worden in alle spellen die normale speelkaarten gebruiken. Het afhandelen van hoe goed een bepaalde hand met kaarten is lijkt me meer iets voor een aparte class die je spel aanroept. Ik heb bijvoorbeeld een PokerHandRanker, die van de uiteindelijke 7 kaarten je beste 5 kaarten bepaald en er een waarde aan geeft, two pair bijvoorbeeld.

Ik zou het toekennen van waardes altijd laten gebeuren in je gameengine en niet in de Card klasse zelf

[joepP]

Verwijderd schreef op dinsdag 03 oktober 2006 @ 13:00:
Shuffle, sorteert de kaarten op Guid, leek me random genoeg

Voor het schudden van een deck is een betere methode, die ook (veel) sneller is. Zie bijvoorbeeld het volgende topic: [Perl] Kaartspel schudden *