Poker, deck, cards, evaluation

Door Rudie dirkx, 16 jaar geleden, 6.140x bekeken

Met de klassen Card en Deck kan je een deck maken van een x aantal kaarten/decks. Met alleen die twee klassen kan je natuurlijk weinig meer dan kaarten uitdelen, maar je kan er ook een spelletje mee maken.
De derde class (PokerTexasHoldem) is om adhv een aantal kaarten de beste hand te evalueren en een score terug te geven. Die score kan (terug) gedraaid worden naar een leesbare hand zoals "Flush of Diamonds - Queens high" of "Two Pairs - Queens and Eights".
De score bevat de 5 kaarten in de hand. De leesbare hand vertelt ze echter niet altijd allevijf.
De class PokerTexasHolden is statisch aan te roepen met een array met Cards als parameter, als resultaat volgt een string met een float value erin. In het geval van een flush staat er de suit/kleur achter. Als $score is wat je terugkrijgt van de statische functie, is (float)$score altijd een nette float die te vergelijken is met de rest van de spelers.

Ik heb een voorbeeld bijgevoegd, maar die is ook precies te vinden op: http://games.hotblocks.nl/131b.php

Het voorbeeld bevat: Y spelers die allemaal 2 kaarten krijgen, een flop+turn+river van 5 kaarten. Voor elke speler wordt vervolgens hun eigen set 7 Cards gemaakt en die wordt geevalueerd mbv PokerTexasHolden::score(). Alle scores hoger dan X zijn rood en vet aangegeven. Na het listen van alle spelers' scores, wordt het maximum berekend mbv de standaard PHP max() functie.

Het voorbeeld is misschien niet helemaal superduidelijk maar na bestuderen wel. De klassen zouden heel duidelijk moeten zijn.
Mocht je fouten zien, of kan het efficienter, of heb ik verkeerde spelregels toegepast, LET ME KNOW. Vragen: stel ze hier.

Je kan alle klassen in 1 bestand doen, maar ik zou vooral PokerTexasHolden scheiden vd andere 2, want de Card en Deck klassen kunnen voor praktisch elk kaartspel gebruikt worden.

Veel plezier ermee.
Uitwerkingen en toepassingen zie ik graag :)

Nog een voorbeeldje: http://games.hotblocks.nl/131.php
En een toepassing van Card en Deck (in de vorm van blackjack): http://games.hotblocks.nl/101c.php

Edit:
In het voorbeeld van het voorbeeld zijn maar 4 plaatjes. 1 voor elke suit/kleur. Als je 2 of 3 keer op Refresh klikt, kan je ze sowieso allevier downloaden. Ik heb er geen zipje ofzo van en ga ik ook niet maken. Is wel heel makkelijk dit. Je kan in de class het image path veranderen.

Voorbeeld: http://games.hotblocks.nl/131b.php

Gesponsorde koppelingen

PHP script bestanden

  1. poker-deck-cards-evaluation

 

Er zijn 14 reacties op 'Poker deck cards evaluation'

PHP hulp
PHP hulp
0 seconden vanaf nu
 

Gesponsorde koppelingen
- -
- -
16 jaar geleden
 
0 +1 -0 -1
Leuk! Ik was ook al een poosje van plan een class te schrijven waarmee je makkelijk kaartspelletjes kunt maken.
Jan geen
Jan geen
16 jaar geleden
 
0 +1 -0 -1
Ziet er leuk uit. Alleen nog even je klasse variabelen private maken..
M Ypma
M Ypma
16 jaar geleden
 
0 +1 -0 -1
Leuk, maar wel wat opmerkingen:

- klasse Card is beperkt tot het kaartspel van 52 kaarten. En elke instantie kent alle kaart soorten. Dat lijkt mij een misstap in je OO model. 1 kaart is maar van 1 soort en 1 waarde en heeft dus niks te maken met, en geen weet hebben van, de andere type/waarde combinaties.

- Je Deck klasse lijkt mij een klasse die prima de basis functionaliteiten van Array kan gebruiken of iig de interfaces Iterator, ArrayAccess kunnen implementeren.

- Ik mis een alternatief voor "readable_hand", deze geeft nu een string terug waar ik als gebruiker weinig meer mee kan. Biedt ook een functie die deze data onopgemaakt en bruikbaar terug geeft.

- Je opzet neigt naar mijn smaak nog iets teveel naar procedurele code die in een klasse is gefrommeld.

- Wees consistent met naamgevingen. Je klasse naam voor pokertexasholdem is in tegestelling met je andere 2 klassen volledig lowercase.
PHP erik
PHP erik
16 jaar geleden
 
0 +1 -0 -1
Ik mis vooral documentatie, het is nu een heel karwei om goed te zien hoe het script werkt om het bijvoorbeeld zelf aan te kunnen passen.
Robert Deiman
Robert Deiman
16 jaar geleden
 
0 +1 -0 -1
Er zit ook ergens een fout in.. De winnaar is een "Flush of Spades - Jacks high (5.1110050302spades)"

Volgens mij moet die spades er niet achteraan komen. Waar dat precies vandaan komt weet ik niet..

Verder is de functie flush al een bestaande, niet handig om die als functienaam te kiezen voor je eigen gemaakte functie.

Wat ook raar is is dat je wel alle spelers middels een for lusje moet aanmaken, buiten je class. Lijkt me handiger als je gewoon een functie "creategame" aan kan roepen, waarbij je het aantal spelers opgeeft.

Verder wel erg leuk gedaan vind ik.
Onbekend Onbekend
Onbekend Onbekend
16 jaar geleden
 
0 +1 -0 -1
Een cardgame-engine als ik het goed hoor? Leuk idee!
Rudie dirkx
rudie dirkx
16 jaar geleden
 
0 +1 -0 -1
Robert, wat is de fout? Het woordje "spades" achter de float score geeft aan wat voor flush het is. Zonder dat woordje weet je niet welke kleur de flush is. Niet altijd interessant, maar wel leuk om in de hand te zetten toch?
De flush functienaam: ach, ik heb er geen last van.
Het aanmaken van spelers gebeurt niet in een vd klassen, en hoort daar niet bij. Het aanmaken van spelers moet je zelf doen in jouw toepassing van deze klassen. In dit geval is het maar een makkelijke demo: Het delen van kaarten gebeurt op de verkeerde volgorde en er zijn geen burns.

Ypma:
Je hebt zeker gelijk over klasse Card, maar dit is de makkelijkste manier die ik ken. Ik moet ergens namen en waarden opslaan van alle kaarten, dus als het niet in de class is (niet eens in het object!), waar dan!?
Ik doe niet aan interfaces en implementaties. Zie het nut er niet van in, maar overtuig me please!
Het enige nut van readable_hand, is doen wat ie doet: in woord vertellen wat je 7 kaarten opgeleverd hebben. Een speler weet wel dat "Flush blabla" hoger is dan "Three of a kind bla bla". Alleen de score wordt gebruikt om scores te vergelijken en een winnaar te kiezen.
Hoe neigt het teveel naar procedural? Zou best kunnen hoor, ben niet zo'n enorme OOP fan. Het komt in PHP namelijk toch altijd uit op PP en PP is gewoon sneller.
De naamgeving: Ach boeie, kleine letters of hoofdletters interesseert me echt niet, als ik het snap is het goed toch!? Volgens mij is het best leesbaar.

Edit:
Hoe het er uit ziet en hoe het werkt en of het nette OOP is etc etc maakt mij allemaal niet uit. Het enige doel van mijn code: op een zo snel mogelijke manier doen wat er gedaan moet worden. En deze klassen zijn een supersnelle manier om pokerhanden te evalueren. Ik ben benieuwd naar een snellere net-zo-generieke manier.
M Ypma
M Ypma
16 jaar geleden
 
0 +1 -0 -1
Quote:
Hoe het er uit ziet en hoe het werkt en of het nette OOP is etc etc maakt mij allemaal niet uit. Het enige doel van mijn code: op een zo snel mogelijke manier doen wat er gedaan moet worden. En deze klassen zijn een supersnelle manier om pokerhanden te evalueren. Ik ben benieuwd naar een snellere net-zo-generieke manier.

Deze instelling lijkt me totaal niet van toepassing wanneer je je werk wilt delen in een script library (in dit geval van PHPHulp)... wil je het delen zul je er zorg voor moeten dragen dat de code overzichtelijk in elkaar steekt, goed gedocumenteerd is en doet wat de developer verwacht dat het doet.

Mijn kritiek was zonder negatieve lading opbouwend bedoeld. Als je deze met argumenten als "Ach boeie" naast je neer legt ben ik er wel klaar mee en wens ik je veel succes in je Procedural Code.
Thijs X
Thijs X
16 jaar geleden
 
0 +1 -0 -1
Leuk begin maar ik ben het eens met Ypma.

Een kaart hoort eigenlijk niet meer te weten dan de kleur en waarde.
Jan geen
Jan geen
16 jaar geleden
 
0 +1 -0 -1
Quote:
Ik doe niet aan interfaces en implementaties. Zie het nut er niet van in, maar overtuig me please!


Niet heel gemakkelijk uit te leggen, maar het feit dat je het nut er niet van in ziet zegt genoeg. Het is juist heel handig omdat wanneer een klasse een interface implementeert je ook de bijbehorende methoden moet implementeren. Op die manier kan je dus afdwingen en weet je zeker dat een bepaalde klasse die het interface implementeert ook de methoden heeft.

Had nog een Kaart klasse liggen in java, even snel omgebouwd. Bedoeld als opzetje...

Code (php)
PHP script in nieuw venster Selecteer het PHP script
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
<?php
/**
  * Kaart
  * Representatie van een speelkaart
  */

class Kaart {
    
    # RANGEN
    const AAS = "A";
    const HEER = "H";
    const VROUW = "V";
    const BOER = "B";
    const TIEN = "T";
    
    # KLEUR
    const HARTEN = "H";
    const RUITEN = "R";
    const SCHOPPEN = "S";
    const KLAVEREN = "K";
    
    private $kleur;
    private $rang;

    /*---------- Constructor -----------------------------------------------------------------------------------*/
    public function __construct($kleur, $rang) {
        $this->kleur = $kleurl
        $this
->rang = $rang;
    }



    /*---------- Queries -----------------------------------------------------------------------------------*/
    /** getKleur
      * Geeft de kleur van deze kaart terug
      * @return char de kleur van deze kaart
      */

    public function getKleur() {
        return $this->kleur;
    }

    
    /** getRang
      * Geeft de rang van deze kaart terug
      * @return char de rang van deze kaart
      */

    public function getRang() {
        return $this->rang;
    }

    
    /** isGeldigeRang
      * Controleert of de opgegeven rang
      * een geldige rang is
      * @param De rang van de kaart
      * @return boolean true als het een geldige rang betreft
      */

    static public function isGeldigeRang($rang) {
        return ($rang == self::AAS     || $rang == self::HEER     || $rang == self::VROUW ||
                $rang == self::BOER    || $rang == self::TIEN    || ($rang < 10 && $rang > 0));                        
    }


    /** isGeldigeKleur
      * Controleert of de opgegeven kleur
      * een geldige kleur is
      * @param De kleur van de kaart
      * @return boolean true als het een geldige kleur betreft
      */

    static public function isGeldigeKleur($kleur) {
        return ($kleur == self::HARTEN || $kleur == self::RUITEN || $kleur == self::KLAVEREN || $kleur == self::SCHOPPEN);
    }

    
    /** rangKleinerDan
      * Test of de ene rang kleiner is dan de andere volgens
      * '2' - '3' - ... - TIEN - BOER - VROUW - HEER - AAS
      * @param Rang van kaart 1
      * @param Rang van kaart 2
      * @return boolean true als rang1 kleiner is
      */

    static public function rangKleinerDan($rang1, $rang2) {
    }

    
    /** kdRang
      * Test of deze Kaart kleiner in rang is dan een andere.
      * @param Kaart kaart de te vergelijken kaart
      * @return boolean true als deze kaart kleiner is in rang
      */

    public function kdRang(Kaart $kaart) {
        return $this->rang < $kaart->getRang();
    }

    
    public function __toString() {
        return $this->kleur . $this->rang;
    }


    /*---------- Commando's -----------------------------------------------------------------------------------*/
    /** setKleur
      * Set de kleur van deze kaart
      * @param Kleur van de kaart
      */

    public function setKleur($kleur) {
        $this->kleur = $kleur;
    }

    
    /** setRang
      * Set de rang van de kaart
      * @param Rang van de kaart
      */

    public function setRang($rang) {
        $this->rang = $rang;
    }
}

?>
Manaus
Manaus
16 jaar geleden
 
0 +1 -0 -1
wat doet dit precies:
$iCard = (int)$f_iCard%52;
$iSuit = floor($iCard/13);
$iName = $iCard%13;
Manaus
Manaus
16 jaar geleden
 
0 +1 -0 -1
zou het niet mogelijk zijn om eeen beetje commentaar erbij te zetten? zou voor mij toch wel zeer handig zijn! want sommige deeltjes snap ik niet...
Thijs X
Thijs X
16 jaar geleden
 
0 +1 -0 -1
@ Manaus,

Dat stukje rekend een aantal dingen uit van de kaart:

$iCard = (int)$f_iCard%52;
Omdat er 52 kaarten in het spel zitten word het kaart nummer hierdoor tussen de 1 en 52 gehaald.

$iSuit = floor($iCard/13);
Dit rekend de kleur ( harten, schoppen etc ) van de kaart uit, elke kleur heeft 13 kaarten vandaar dat het doord 13 word gedeeld.

$iName = $iCard%13;
Hier word de waarde van de kaart uitegerekend.

Al die uitkomsten zijn de keys van de array's en daardoor onstaat er een kaart met de juiste waardes.
PHP hulp
PHP hulp
0 seconden vanaf nu
 

Gesponsorde koppelingen
Manaus
Manaus
16 jaar geleden
 
0 +1 -0 -1
ok bedankt ik snap het volledig:D
Nog 1 dingetje:
wat doet hetvolgende?

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
public function add_deck(Deck $objDeck) {
        $this->cards = array_merge($this->cards, $objDeck->cards);
        return $this;
    }
    public function add_card(Card $objCard) {
        array_push($this->cards, $objCard);
        return $this;
    }

Om te reageren heb je een account nodig en je moet ingelogd zijn.

Inhoudsopgave

  1. poker-deck-cards-evaluation

Labels

  • Geen tags toegevoegd.

Navigatie

 
 

Om de gebruiksvriendelijkheid van onze website en diensten te optimaliseren maken wij gebruik van cookies. Deze cookies gebruiken wij voor functionaliteiten, analytische gegevens en marketing doeleinden. U vindt meer informatie in onze privacy statement.