[OOP]Waarde overnemen andere class
Het is vakantie, hier en daar dus terug scriptneigingen.
Vandaag zijn de microben weer overgeslagen op mij en heb een project bedacht. Een Texas Hold'em script. Dit is eveneens een goede reden om te beginnen met OOP. Ik heb enkele tutorials gelezen, onderandere ook van deze site. Daarin staat duidelijk vermeld dat OOP een denkwijze is. Het verband tussen Classes zoals : maand extends dag, mastadizzy extends gebruiker, et cetera.
Nu zie ik deze logische verbanden niet echt terug in classes om kaarten te schudden en de kaarten te delen.
Even over de vraag waarmee ik zit. Hoe kan ik mijn geschudde kaarten ($kaarten) gebruiken in mijn volgend class? Zoals je wel kan zien schud ik de kaarten in mijn eerste class, en wil ik om te testen die geschudde kaartenarray oproepen in mijn volgende functie van een andere class (delen).
edit: Even vergeten bij te vermelden. Ik krijg netjes de array te zien die geprint wordt (dus de output van de eerste print_r van de functie schudden). daarna krijg ik 2 errors.
Notice: Use of undefined constant kaarten - assumed 'kaarten' in D:\wamp\www\class.inc.php on line 20
Notice: Object of class delen could not be converted to int in D:\wamp\www\class.inc.php on line 20
1
class.inc.php
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 shuffle_kaarten
{
var $kaarten = array(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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52);
function schudden()
{
shuffle($this->kaarten); //schud array met kaarten
print_r($this->kaarten); //print array geschudde kaarten
}
}
class delen
{
var $aantal_spelers;
function showkaarten()
{
print_r($this-kaarten); //om te testen array met geschudde kaarten weergeven
}
function delen_speler1()
{
for($i=1;$i<=9;$i++)
{
echo $kaarten;
}
}
function delen_computer()
{
}
}
?>
class shuffle_kaarten
{
var $kaarten = array(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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52);
function schudden()
{
shuffle($this->kaarten); //schud array met kaarten
print_r($this->kaarten); //print array geschudde kaarten
}
}
class delen
{
var $aantal_spelers;
function showkaarten()
{
print_r($this-kaarten); //om te testen array met geschudde kaarten weergeven
}
function delen_speler1()
{
for($i=1;$i<=9;$i++)
{
echo $kaarten;
}
}
function delen_computer()
{
}
}
?>
Het PHP bestand dat de classes oproept:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
<?PHP
include 'class.inc.php';
$shuffle = new shuffle_kaarten;
$shuffle->schudden();
$kaartendelen = new delen;
$kaartendelen->showkaarten();
?>
include 'class.inc.php';
$shuffle = new shuffle_kaarten;
$shuffle->schudden();
$kaartendelen = new delen;
$kaartendelen->showkaarten();
?>
Bij voorbaat dank!
Gewijzigd op 01/01/1970 01:00:00 door Dizzy
Verder hoor je geen echo/print etc in een class te doen maar netjes het resultaat terug te geven. (tenzij de class een view is, daar kan natuurlijk wel output)
pseudocode
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
36
37
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
36
37
<?php
class TexasHoldEm
{
private $kaarten = array();
private $spelers = array();
private $aantalBijDelen = 9;
public function __construct()
{
$this->refillKaarten();
}
public function schudden()
{
$this->kaarten = shuffle($this->kaarten);
}
public function delen()
{
$kaartenSpeler = array();
for($i=0; $i< $this->aantalBijDelen; $i++)
{
$kaarten[] = array_shift($this->kaarten);
}
}
public function addSpeler($speler)
{
$this->spelers[] = $speler;
}
public function refillKaarten()
{
$this->kaarten = array(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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52);
}
}
?>
class TexasHoldEm
{
private $kaarten = array();
private $spelers = array();
private $aantalBijDelen = 9;
public function __construct()
{
$this->refillKaarten();
}
public function schudden()
{
$this->kaarten = shuffle($this->kaarten);
}
public function delen()
{
$kaartenSpeler = array();
for($i=0; $i< $this->aantalBijDelen; $i++)
{
$kaarten[] = array_shift($this->kaarten);
}
}
public function addSpeler($speler)
{
$this->spelers[] = $speler;
}
public function refillKaarten()
{
$this->kaarten = array(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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52);
}
}
?>
Edit:
Vergeet bijna het gebruik.
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
$casinoTafel = new TexasHoldEm();
$casinoTafel->schudden();
$kaartenSpelers = $casinoTafel->delen();
$kaartenComputer = $casinoTafel->delen();
?>
$casinoTafel = new TexasHoldEm();
$casinoTafel->schudden();
$kaartenSpelers = $casinoTafel->delen();
$kaartenComputer = $casinoTafel->delen();
?>
Je kunt het opslaan van de kaarten ook netjes in de class doen.
Gewijzigd op 01/01/1970 01:00:00 door TJVB tvb
Ik vond het persoonlijk raar om alles in 1 class te plaatsen.
Uiteindelijk, moet ik de validator ook in deze class schrijven? Of kan ik de denkpiste volgen: validator extends Texas hold'em ... omdat een validator een deel is van texas hold'em?
Bedankt alvast voor het bovenstaande!
Je zegt zelf al waarom "validator extends texas hold'em" niet kan. Validator is een ONDERDEEL van texas hold'em, het is niet "een texas hold'em"
Maar even terug op je originele post. Je moet bij poker denken aan objecten als:
Game
Player
Card
Deck
Dealer
Pot
Stack
Combination (bijv: Royal Flush of 3 of a kind)
Table
Je start een Game. Die deelt via je Dealer een aantal Cards aan een Player. De Cards haal je uit je Deck zodat er geen dubbele kaarten komen. Elke Player heeft een Stack (aantal fiches), bij inzetten gaat een deel van de Stack naar de Pot. Na inzetten komen er enkele Cards op de Table. Na nog een paar keer inzetten kijk je bij elke Player of zijn Cards met de Cards op de Table een Combination vormen. Als een Player een Combination heeft kun je een compare() uitvoeren tussen verschillende Players om te kijken wie de hoogste combinatie heeft. Vervolgens gaat de inhoud van de Pot naar een Player of wordt het gesplit. Een aantal van deze pokerregels zul je dus in Game (of in Dealer) programmeren, die gebruikt gewoon al die andere objecten.
Qua combinaties.Je maakt dus classes als "RoyalFlush extends Combination" om een combinatie te programmeren, met een functie als RoyalFlush::isHit($playerCards, $tableCards) die true returnt als de kaarten van een speler en de kaarten op tafel valideren tegen geldige pokercombinaties.
Heb ik je al op ideeën gebracht? Er zijn 1000 manieren om dit te doen, bovenstaand zou ook in minder classes kunnen (zo kun je een Stack ook zien als een eigenschap van een Player in plaats van een apart object, maar dat is een keuze).
Gewijzigd op 01/01/1970 01:00:00 door PHP erik
Allereerst heb ik schudden en delen in 1 class gestoken. Zoals TJVB meldde.
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
36
37
38
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
36
37
38
<?PHP
class TexasHoldEm
{
private $deck = array(); //array maken voor 52 speelkaarten
private $spelers = array();
private $TeDelen = 9; //aantal te delen kaarten (2 voor speler, 2 voor computer, 5 voor de tafel)
private $playerCards = array(); //array maken voor de kaarten van de speler
private $computerCards = array(); //array maken voor de kaarten van de computer
private $tableCards = array(); //array maken voor de kaarten die op tafel komen (flop, turn en river)
public function __construct()
{
$this->BijVullen();
}
public function BijVullen()
{
$this->deck = range(1,52); //plaats alle kaarten in het deck
}
public function schudden()
{
shuffle($this->deck); //schud het deck
}
public function delen()
{
for($i=0; $i < 2; $i++)
{
array_push($this->playerCards, array_shift($this->deck)); //geef eerst kaart aan speler
array_push($this->computerCards, array_shift($this->deck)); //geef daarna kaart aan computer
}
for($i=0; $i <5; $i++)
{
array_push($this->tableCards, array_shift($this->deck)); //5 kaarten die later op tafel verschijnen
}
}
}
?>
class TexasHoldEm
{
private $deck = array(); //array maken voor 52 speelkaarten
private $spelers = array();
private $TeDelen = 9; //aantal te delen kaarten (2 voor speler, 2 voor computer, 5 voor de tafel)
private $playerCards = array(); //array maken voor de kaarten van de speler
private $computerCards = array(); //array maken voor de kaarten van de computer
private $tableCards = array(); //array maken voor de kaarten die op tafel komen (flop, turn en river)
public function __construct()
{
$this->BijVullen();
}
public function BijVullen()
{
$this->deck = range(1,52); //plaats alle kaarten in het deck
}
public function schudden()
{
shuffle($this->deck); //schud het deck
}
public function delen()
{
for($i=0; $i < 2; $i++)
{
array_push($this->playerCards, array_shift($this->deck)); //geef eerst kaart aan speler
array_push($this->computerCards, array_shift($this->deck)); //geef daarna kaart aan computer
}
for($i=0; $i <5; $i++)
{
array_push($this->tableCards, array_shift($this->deck)); //5 kaarten die later op tafel verschijnen
}
}
}
?>
Jacco schreef op 25.06.2009 11:14:
Bedankt, dit zijn heel waarde volle tips :). Zeker omdat ik nog niet zo'n grote functie kennis heb.Regel 5 kan je beter range gebruiken
Jurgen schreef op 25.06.2009 11:01:
Idd, daarom wil ik er zeker van zijn dat mijn schudden en delen goed zit.Ik denk dat je hier echt stap voor stap moet gaan denken. Zeker als je het nog wil gaan leren. Begin eens makkelijk met een class Deck en een klas Cards.
Wat bedoel je met class Deck en class Cards? Kan je even uitleggen wat je denkwijze is voor deze 2 klassen en wat ze doen?
Zoals je ziet heeft een kaart meer eigenschappen dan enkel een nummer uit de reeks 1-52. Een kaart heeft een kleur en een waarde. Dat zou je heel mooi kunnen vastleggen in een object Card, een instantie van de klasse Card.
Vervolgens zou je kunnen kiezen om ook een Deck klasse te gebruiken. Een Deck object zou dan in eerste instantie 52 Card objecten bevatten. De method schudden() is dan een toepassing op een Deck en zou in die klasse thuis horen. Ook zou die klasse een method dealCard() kunnen hebben waarmee er 1 kaart uit het Deck gedeeld wordt. De delen() method uit je TexasHoldEm klasse roept dan een aantal keer die dealCard() method aan.
Een overzichtje:
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
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
<?php
class Card {
private $sSuit;
private $sValue;
public function __construct($sSuit, $sValue) {
}
// Aantal methods voor verkrijgen van de waarde en de kleur
}
class Deck {
private $aCards;
public function __construct() {
// Vul $this->aCards met 52 Card objecten
}
public function dealCard() {
return array_shift($this->aCards);
}
}
class TexasHoldEm {
// Hier de methods voor het spelen van het spel
}
?>
class Card {
private $sSuit;
private $sValue;
public function __construct($sSuit, $sValue) {
}
// Aantal methods voor verkrijgen van de waarde en de kleur
}
class Deck {
private $aCards;
public function __construct() {
// Vul $this->aCards met 52 Card objecten
}
public function dealCard() {
return array_shift($this->aCards);
}
}
class TexasHoldEm {
// Hier de methods voor het spelen van het spel
}
?>
Mogelijk wil je dit ook nog uitbreiden met bijvoorbeeld een Player object waar je tijdens het spel kaarten aan toe kun wijzen. Er zijn heel veel mogelijkheden, maar dit geeft wel een beetje de basis.
Blanche schreef op 25.06.2009 12:41:
Kaarten krijgen nu een waarde 1-52, maar hoe ga je later in het spel bepalen wat de eigenlijke waarde van die kaarten is? Met andere woorden, hoe ga je constateren dat iemand een flush of straight heeft of zelfs een paartje?
Mijn denkwijze was bijvoorbeeld:
klaveren [1-13] waarbij 1 ace, 11 jack, 12 queen en 13 king.
schoppen [14-26]
harten [27-39]
koeken [40-52]
dus, al je 1 en 14 vast hebt (2 aces dus) ... checken tussen welke waardes liggen. 14 ligt dus in de 2de categorie (schoppen) waardoor je 14-((2-1)*13) doet. (14=nummer-kaart; 2=2de categorie; 1=om de waarde te corrigeren. Zo wordt er geen verschil gemaakt van 26 wat resulteert in een negatief getal; 13=zoveel kaarten zijn er van 1 soort/zitten er in 1 range)
Wat dus waarde 1 terugstuurt. en als 2 waardes gelijk zijn aan elkaar. In dit geval heb je dus (1;1) vast wat dus een pair geeft :)
Inderdaad is dit niet de meest praktische methode, maar in andere poker-scripts(volgens een goede maat van mij) gebruikt men deze methode ook.
Edit:
Hoe kan ik ervoor zorgen dat $aCards in de class Deck niet dezelfde kaarten afhaalt bij de Card-classe?
Want als ik het goed begrijp moet ik 52 keer de Card-classe oproepen in de constructor van class Deck?
Want als ik het goed begrijp moet ik 52 keer de Card-classe oproepen in de constructor van class Deck?
Gewijzigd op 01/01/1970 01:00:00 door Dizzy
Code (php)
En datzelfde zou je voor de andere combinaties van kaarten kunnen doen. Tenslotte zou je al deze controles met 1 method toe kunnen passen op de kaarten in de hand en de gemeenschappelijke kaarten...
Gewijzigd op 01/01/1970 01:00:00 door Joren de Wit
Ik ben er namelijk ook mee bezig :P
Dit is momenteel mijn opzet voor de deck class.
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
36
37
38
39
40
41
42
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
36
37
38
39
40
41
42
<?php
/**
* @author Nico Kaag
* @copyright 2009
*/
error_reporting(E_ALL);
class card
{
public $color;
public $value;
function __construct($color, $value)
{
$this->color = $color;
$this->value = $value;
}
}
class deck
{
//Player Variables
public $deck;
private $aSuits = array('H', 'D', 'S', 'C');
private $aValues = array('2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A');
function __construct()
{
$this->deck = array();
foreach($this->aSuits as $sSuit)
{
foreach($this->aValues as $sValue)
{
array_push($this->deck, new card($sSuit, $sValue));
}
}
}
}
?>
/**
* @author Nico Kaag
* @copyright 2009
*/
error_reporting(E_ALL);
class card
{
public $color;
public $value;
function __construct($color, $value)
{
$this->color = $color;
$this->value = $value;
}
}
class deck
{
//Player Variables
public $deck;
private $aSuits = array('H', 'D', 'S', 'C');
private $aValues = array('2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A');
function __construct()
{
$this->deck = array();
foreach($this->aSuits as $sSuit)
{
foreach($this->aValues as $sValue)
{
array_push($this->deck, new card($sSuit, $sValue));
}
}
}
}
?>
en dit is mijn dealer class
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
36
37
38
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
36
37
38
<?php
/**
* @author Nico Kaag
* @copyright 2009
*/
error_reporting(E_ALL);
class dealer
{
public $deck;
public $playerCards;
private $shuffledDeck;
public function __construct()
{
$this->deck = new deck();
}
public function dealCards($nrOfPlayers, $nrOfCards)
{
$this->shuffleDeck();
for ($j = 0; $j < $nrOfCards; $j++)
{
for ($i = 0; $i < $nrOfPlayers; $i++)
{
$this->playerCards[$i][$j] = array_shift($this->shuffledDeck);
}
}
}
private function shuffleDeck()
{
$this->shuffledDeck = $this->deck->deck;
shuffle($this->shuffledDeck);
}
}
?>
/**
* @author Nico Kaag
* @copyright 2009
*/
error_reporting(E_ALL);
class dealer
{
public $deck;
public $playerCards;
private $shuffledDeck;
public function __construct()
{
$this->deck = new deck();
}
public function dealCards($nrOfPlayers, $nrOfCards)
{
$this->shuffleDeck();
for ($j = 0; $j < $nrOfCards; $j++)
{
for ($i = 0; $i < $nrOfPlayers; $i++)
{
$this->playerCards[$i][$j] = array_shift($this->shuffledDeck);
}
}
}
private function shuffleDeck()
{
$this->shuffledDeck = $this->deck->deck;
shuffle($this->shuffledDeck);
}
}
?>
zoals je wel ziet heb ik hier het schudden onder de dealer gezet.
Een deck schud zichzelf namelijk niet.
Dat word geschud door de dealer, dus dat is dan ook een functie die de dealer heeft.
Zo ook bij het delen.
De kaarten worden ook toegekend aan een object player/speler.
Dit gebeurt hier nog niet, omdat k nog niet zo ver ben :P
Gewijzigd op 01/01/1970 01:00:00 door Nicoow Unknown
Het delen in de dealer klasse gebeurt dus ook door aan je deck object om een kaart te vragen: $deck->dealCard() bijvoorbeeld. In die dealCard() method vind dan de array_shift() plaats.
Verder zou je ook nog een object Player kunnen introduceren. Op die manier ben je af van de array met playerCards in de dealer klasse. Daar heb je dan enkel nog een array met Player objecten die tijdens het delen elk weer kaarten toegewezen krijgen: $player_a->assign() bijvoorbeeld.
Kortom, de basis is goed, alleen zorg dat je de eigenschappen en bewerkingen bij de juiste klasses houdt.
Gewijzigd op 01/01/1970 01:00:00 door Joren de Wit
Dus eigenlijk krijg je in de deck class een functie die shufled, en dan in de dealer eentje die hem aanroept.
Voor de rest ben k niet bekend met referenties in PHP, in C# kan ik gewoon ref gebruiken.
voor de rest lees je in de laatste 2 regels dat ik dat ook van plan was/ben.
Voor de rest bestaat er nog een class table, waaraan het spel plaats vind.
en nog een class waarvoor ik eigenlijk niet echt een goede naam weet, maar die handelt alle kaarten af, en berekent het aantal punten.
nico schreef op 25.06.2009 13:56:
en nog een class waarvoor ik eigenlijk niet echt een goede naam weet, maar die handelt alle kaarten af, en berekent het aantal punten.
Validator misschien :)?
Dizzy schreef op 25.06.2009 13:59:
Validator misschien :)?
nico schreef op 25.06.2009 13:56:
en nog een class waarvoor ik eigenlijk niet echt een goede naam weet, maar die handelt alle kaarten af, en berekent het aantal punten.
Validator misschien :)?
Lijkt me niet. Een score berekenen is niet valideren. Voor de scores zou ik simple een klasse Score maken.
Alle 5 de kaarten gewoon in één array gooien? Dit in een aparte functie? (ik heb nu "dealCard" die kaarten deelt alleen aan de spelers). Of moet ik dit doormiddel van nog een FOR-lus bij de "dealCard" toevoegen?
Ik had in mijn gedachte om nog eens 3 aparte functies te maken (dealFlop, dealTurn, dealRiver), maar dit lijkt mij geen goed idee :).
Dit is een deel van mijn Deck-class:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?
public function schudden() //deck schudden
{
shuffle($this->deck);
$shuffledDeck = $this->deck;
return $shuffledDeck;
}
public function dealCard($aantalPlayers, $nrCards) //aantal spelers
{
$shuffledDeck = $this->schudden();
for ($p=1; $p<=$aantalPlayers; $p++) //delen aan de spelers
{
for ($c=1; $c<=$nrCards; $c++)
{
$playerCards[$p][$c] = array_shift($shuffledDeck);
}
}
}
?>
public function schudden() //deck schudden
{
shuffle($this->deck);
$shuffledDeck = $this->deck;
return $shuffledDeck;
}
public function dealCard($aantalPlayers, $nrCards) //aantal spelers
{
$shuffledDeck = $this->schudden();
for ($p=1; $p<=$aantalPlayers; $p++) //delen aan de spelers
{
for ($c=1; $c<=$nrCards; $c++)
{
$playerCards[$p][$c] = array_shift($shuffledDeck);
}
}
}
?>
PS: hoe kan ik de array $shuffledDeck na het uitvoeren van dealCard terug aanroepen? Ik heb al geprobeerd een functie dealFlop te maken, maar als ik $this->shuffledDeck probeer aan te roepen is dit een lege array. Dit omdat ik niet nogmaals mag schudden (wat dus een compleet nieuw deck oplevert).
Gewijzigd op 01/01/1970 01:00:00 door Dizzy
Code (php)
eigenlijk moet je tafel er zo iets uitzien:
(even snel uit de losse pols)
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class table
{
public $players; //een array met alle player objecten
public $deck; //de stapel met kaarten, ook weer een array met objecten dus
public $dealer; //de dealer, die het bovenstaande deck kan aanpassen, en kaarten kan delen aan de bovenstaande spelers.
//alle classes ook aanmaken
$dealer->dealCards(); // en dan moet de functie dealCards zo worden aangepast dat hij weet wat te doen.
Je kan hem ook een lijst met players laten returnen, en dan $players gewoon zo te declareren.
}
?>
class table
{
public $players; //een array met alle player objecten
public $deck; //de stapel met kaarten, ook weer een array met objecten dus
public $dealer; //de dealer, die het bovenstaande deck kan aanpassen, en kaarten kan delen aan de bovenstaande spelers.
//alle classes ook aanmaken
$dealer->dealCards(); // en dan moet de functie dealCards zo worden aangepast dat hij weet wat te doen.
Je kan hem ook een lijst met players laten returnen, en dan $players gewoon zo te declareren.
}
?>
Ik weet niet of je al een class diagram heb gemaakt, maar dat zou wel heel handig wezen, voornamelijk voor jezelf.
Je gaat gewoon je probleem opdelen in meerdere stukken.
je begint bij de essentie van poker,
Die ligt bij de tafel.
de tafel heeft verschillende dingen nodig om er een potje poker op te kunnen spelen.
dit zijn:
een dealer
een *x* aantal spelers
een stapel met kaarten
Ga nu gewoon een paar potjes spelen, en speel ieder onderdeel eens zelf, en schrijf dan op wat je allemaal moet doen.
Dat zijn dan de functies die ieder "ding" heeft.
Om dan nog even bij het schudden van de kaarten terug te komen,
Ik ben het niet helemaal eens met blanche dat schudden een onderdeel is van de kaarten, het is een bewerking die door de kaarten word gedaan, maar omdat je de standaard functie shufle al heb, kan je (vind ik) die functie direct op de kaarten uitvoeren, vanuit de dealer class.
Anders krijg je in de deck class een functie als deze:
public function shuflleCards()
{
shuffle($this->deck);
}
en dan heeft de dealer een functie die de functie shuflleCards() aanroept, en die dan weer op het deck aanpassen, beetje dubbel op vind ik.
voor de rest moet je wel een beetje consequent zijn in je taal gebruik,
of engels, of nederlands, niet alle 2.
Bij voorkeur zelfs engels.
Ik heb even een schematje gemaakt. Hopelijk bedoel je dit en heb ik het goed gedaan:
http://g.imagehost.org/download/0674/naamloos