Kaartspel in OOP
Aub niet het antwoord voorkauwen, probeer de logica achter het denken in objecten door te krijgen.
Wat weten we!
Een kaartendek heeft 52 kaarten.
Daarin zitten 13 type-kaarten (2 t/m de aas)
Elk type heeft 4 kaarten (schoppen, klaver, harten en ruiten)
class KaartSpel
{
private $AantalKaarten;
public function __construct()
{
$this->AantalKaarten = 52;
}
}
Maar waar begin je dan om het geheel in objecten onder te brengen?
Dus onderstaande is uitganspunt dan ?
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<?php
class Kaart
{
private $type;
private $waarde;
public function __construct()
{
$this->type = array(schoppen, klaver, harten, ruiten);
$this->waarde = array(2, 3, 4, 5, 6, 7, 8, 9, 10, boer, vrouw, heer, aas);
}
}
class KaartDek
{
private $AantalKaarten;
public function __construct()
{
$this->AantalKaarten = 52;
}
}
class Hand
{
}
?>
class Kaart
{
private $type;
private $waarde;
public function __construct()
{
$this->type = array(schoppen, klaver, harten, ruiten);
$this->waarde = array(2, 3, 4, 5, 6, 7, 8, 9, 10, boer, vrouw, heer, aas);
}
}
class KaartDek
{
private $AantalKaarten;
public function __construct()
{
$this->AantalKaarten = 52;
}
}
class Hand
{
}
?>
Gewijzigd op 01/01/1970 01:00:00 door patrick
Misschien nog 2 methods erbij om kaarten van een ander object te kunnen krijgen en aan een ander object te kunnen geven. * hint: Hand *
Dus het type en waarde moet ik onderbrengen in KaartDek, en vervolgens moet ik middels count deze tellen en vermenigvuldige met elkaar om op het totaal aantal kaarten in een spel uit te komen?
Is er dan nog wel een class kaart nodig ?
Je zou dat trouwens het beste als een static method kunnen doen, volgens het factory design pattern. Je kan immers ook een leeg dek nodig hebben (als je de kaarten van het ene dek naar het andere wil verplaatsen) en het is onlogisch zijn om KaartDek een method te geven die plotseling zomaar zijn hele huidige toestand reset. Kaarten die bijvoorbeeld eerst missen - omdat ze in een ander dek, of in een hand zitten - zouden dan plotseling dubbel kunnen voorkomen in het spel terwijl dat niet de bedoeling is.
Voorbeeldje van een factory:
Code (php)
merk ook op dat ik constanten voor kleur en waarde gebruik (okee, voor waarde niet echt hier, maar ik raad het je wel aan.) Ik weet niet precies waarom, maar ik heb het idee dat het lekkerder werkt.
define('BOER', 11); define('VROUW', 12); define('HEER', 13);
je hebt een stapel kaarten(deck = class) die heeft een hoop kaarten(array)
je hebt een hand, ook een class, die weet ook welke kaarten hij heeft.
en je hebt kaart(en) dat is ook een object, die weet wat hij is, maar verder niks doet.
volens mij kan je objecten ook in een array stoppen toch?
dus deck zou een array van kaart objecten kunnen zijn(hand ook)
dus je stopt kaart objecten in je hand en in het deck, en dan geef je het deck en je hand een functie voor het verplaatsen van objecten van de ene array naar de ander.
misschien is het duidelijker om de hand speler te noemen.
de kaarten weten alleen wat ze zijn, het deck wat er in hem zit, de speler speelt het spel toch?
dus de speler heeft de fuctions om kaarten van het een naar het ander te verplaatsen.
hand en deck hebben misshcien wel wat functies van getKaart ofzo...
ik hoop dat mijn verhaal een beetje duidelijk is?
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?php
class KaartDek {
private $type;
private $waarde;
public function __construct()
{
$this->type = array(schoppen, klaver, harten, ruiten);
$this->waarde = array(2, 3, 4, 5, 6, 7, 8, 9, 10, boer, vrouw, heer, aas);
}
// Aantal typen
public function aantaltype() {
$aantaltype = count($this->type);
return $aantaltype;
}
// Aantal waarden
public function aantalwaarde() {
$aantalwaarde = count($this->waarde);
return $aantalwaarde;
}
// Totaal aantal kaarten in dek
public function totaalaantal() {
$totaalaantal = $this->aantaltype() * $this->aantalwaarde();
return $totaalaantal;
}
}
?>
class KaartDek {
private $type;
private $waarde;
public function __construct()
{
$this->type = array(schoppen, klaver, harten, ruiten);
$this->waarde = array(2, 3, 4, 5, 6, 7, 8, 9, 10, boer, vrouw, heer, aas);
}
// Aantal typen
public function aantaltype() {
$aantaltype = count($this->type);
return $aantaltype;
}
// Aantal waarden
public function aantalwaarde() {
$aantalwaarde = count($this->waarde);
return $aantalwaarde;
}
// Totaal aantal kaarten in dek
public function totaalaantal() {
$totaalaantal = $this->aantaltype() * $this->aantalwaarde();
return $totaalaantal;
}
}
?>
Wat jij hierboven hebt geschreven doet mij vermoeden dat ik nog steeds compleet de verkeerde richting opzit te denken.
Waarom doe je bijvoorbeeld dit?
class KaartenDek {
static public function compleetDek()
{
$dek = new self();
$dek->kaarten[] = new Kaart(ROOD, 1);
$dek->kaarten[] = new Kaart(ZWART, 1);
return $dek;
}
Rood kan toch harten of ruiten zijn, waar wordt dit onderscheid gemaakt?
Het blijft lastig.
En hoe zorg je er bijvoorbeeld voor dat ee speler niet twee keer dezelfde kaart krijgt?
Las in een ander topic dat jezelf bent begonnen in Java, voor mij is het denken in objecten echt helemaal nieuw en ik moet eerlijk zeggen dat ik het lastig vind.
getType()
getTotaalAantal()
setType()
Zelf vind ik dit overzichtelijker:
get_type()
get_totaal_aantal()
set_type()
Quote:
class KaartenDek {
static public function compleetDek()
{
$dek = new self();
$dek->kaarten[] = new Kaart(ROOD, 1);
$dek->kaarten[] = new Kaart(ZWART, 1);
return $dek;
}
static public function compleetDek()
{
$dek = new self();
$dek->kaarten[] = new Kaart(ROOD, 1);
$dek->kaarten[] = new Kaart(ZWART, 1);
return $dek;
}
Wat ik hiervan begrijp is:
Een kaarten deck bestaat uit een verzameling kaarten. Je maakt in de klasse KaartenDeck dus een array die gevuld wordt met Kaart objecten.
Doordat je constanten gebruikt om de kleur (of type) van een kaart aan te geven kun je vrijwel overal de kleur van een kaart achterhalen. Zo vermijd je dingen als:
Dit is veel duidelijker:
Of stel nu dat je het bovenste code blok meerdere keren in de code hebt staan en je wilt het ID nummer van de kleur rood veranderen. Dan moet je alles aanpassen...
Gewijzigd op 01/01/1970 01:00:00 door Martijn B
hij heeft een variabel, en die zet het deck naar een waarde.
het deck weet welke kaarten er allemaal in een dek zitten en kan dat dus bepalen...
mogelijke manier zou zijn een array met alle verschillende kaarten.
en dan met een while loop een random getal maken, dat getal uit de array halen en die kaart de waarde uit de array geven.
en dan een mannier verzinnen zodat hij niet 10 keer een schoppen 10 maakt en helemaal geen aas.
dat kan je misschien doen door van alle kaarten een multiidimensionale array te maken.
dus met een waarde van is gebruikt true/false.
en dan kan je binnen de while een andere while maken die opnieuw een getal maakt tot hij er een heeft die nog niet is gebruikt.
ik ben idd begonnen met java, wat nogal oop is...
en met dingen verdelen zonder dubbelen heb ik ervaring :S
ik heb eens een taakjes rooster gemaakt.
elk taakje had 2 personen, en dan moest het zelfs zo zijn dat je in een week niet 2 keer het zelfde taakje of met de zelfde persoon kan hebben.
tip: bouw wat in dat hij na 1000 keer opnieuw begint of ophoud, anders krijg je eindeloze loops enzo.
Maar waarom wordt dit topic gebumpt?
is al een tijdje redelijk dood hier.