# Pokersoftware: Karten 'mischen' zufällig?



## neonfly (20. Mai 2009)

Guten Morgen,

ist das Ermitteln der Karten in folgender Klasse wirklich zufällig?
Ich kenn es nämlich aus VB6, dass als Zufallszahl bei jedem Programmstart die Gleiche ausgegeben wird.


```
package org.pss.poker.cards;

import java.util.Arrays;
import java.util.List;

/**
 *
 * @author neonfly
 */
public class ShuffleCardDeck {

    private Integer gvNumPlayers = 0;
    private String gvGame = "none";
    private static String HOLDEM = "HOLDEM";
    private static String OMAHA = "OMAHA";
    private static String DETERMINEDEALER = "DEALER";
    private static final List<String> gvCardDeck
    = Arrays.asList("2c","3c","4c","5c","6c","7c","8c","9c","Tc","Jc","Qc","Kc","Ac",
                   "2d","3d","4d","5d","6d","7d","8d","9d","Td","Jd","Qd","Kd","Ad",
                   "2h","3h","4h","5h","6h","7h","8h","9h","Th","Jh","Qh","Kh","Ah",
                   "2s","3s","4s","5s","6s","7s","8s","9s","Ts","Js","Qs","Ks","As");
    

    public ShuffleCardDeck(Integer pvNumPlayers, String pvGame) {
        this.gvNumPlayers = pvNumPlayers;
        this.gvGame = pvGame;
    }

    public List<String> getCards() {
        List<String> lvCardList = null;

        if(gvGame.equals(HOLDEM)) {
            /**
             * Anzahl benoetigter Karten = 5 + (2 * gvNumPlayers)
             */
            Integer lvNumCards = 5 + (2 * gvNumPlayers);
            while(lvNumCards >= 0) {
                lvCardList = getCard(lvCardList);
                lvNumCards--;
            }
        } else if(gvGame.equals(OMAHA)) {
            /**
             * Anzahl benoetigter Karten = 5 + (4 * gvNumPlayers)
             */
            Integer lvNumCards = 5 + (4 * gvNumPlayers);
            while(lvNumCards >= 0) {
                lvCardList = getCard(lvCardList);
                lvNumCards--;
            }
        } else if(gvGame.equals(DETERMINEDEALER)) {
            /**
             * Anzahl benoetigter Karten = gvNumPlayers
             */
            while(gvNumPlayers >= 0) {
                lvCardList = getCard(lvCardList);
                gvNumPlayers--;
            }
        } else {
            return null;
        }

        return lvCardList;
    }

    private List<String> getCard(List<String> pvCardList) {

        Integer lvRandNumber = (Integer) randomNumber(gvCardDeck.size());
        pvCardList.add(gvCardDeck.get(lvRandNumber-1));
        gvCardDeck.remove(lvRandNumber-1);

        return pvCardList;
    }

    private int randomNumber(Integer n) {

        Double lvDouble = Math.random();
        int lvNumber = (int) Math.round(lvDouble * n );

        return lvNumber;
    }
}
```


----------



## SlaterB (20. Mai 2009)

das Random-Objekt von Math wird mit der Systemzeit seiner Initialisierung konfiguriert, das sollte also in normalen Ansprüchen zufällig sein,

wieso liest du eigentlich einen Double aus und keinen double? lieber nicht unnötig Objekte erstellen,

wenn du die Karten in einer neue Liste kopierst, könntest du Collections.shuffle(list) verwenden,
dein Algorithmus macht aber in etwa das gleiche


----------



## ARadauer (20. Mai 2009)

nur so nebenbei, schau dir das mal an... http://spaz.ca/poker/UofAHandEval.zip


----------



## Landei (20. Mai 2009)

Neonfly, ist das nicht etwas von hinten durch die Brust ins Auge? Reicht nicht einfach ein
Collections.shuffle(gvCardDeck);

[edit] Sehe gerade, das hatte SlaterB auch vorgeschlagen.[/edit]


----------



## neonfly (20. Mai 2009)

@Slater B && Landei: shuffle kannte ich noch nicht, hab meine Methode dementsprechend umgeschrieben. Danke!


```
package shuffle;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 *
 * @author neonfly 
 */
public class CardDeck {

    private int gvNumPlayers = 0;
    private int gvNumCards = 0;
    private String gvGame = "none";
    private static final String HOLDEM = "HOLDEM";
    private static final String OMAHA = "OMAHA";
    private static final String BURNCARDS = "#";
    private static List<String> gvCardDeck
    = Arrays.asList("2c","3c","4c","5c","6c","7c","8c","9c","Tc","Jc","Qc","Kc","Ac",
                   "2d","3d","4d","5d","6d","7d","8d","9d","Td","Jd","Qd","Kd","Ad",
                   "2h","3h","4h","5h","6h","7h","8h","9h","Th","Jh","Qh","Kh","Ah",
                   "2s","3s","4s","5s","6s","7s","8s","9s","Ts","Js","Qs","Ks","As");


    public CardDeck(int pvNumPlayers, String pvGame) {
        this.gvNumPlayers = pvNumPlayers;
        this.gvGame = pvGame;
    }

    public List<String> getShuffledCards() {

        if(gvGame.equals(HOLDEM))       gvNumCards = 8 + (2 * gvNumPlayers);
        else if(gvGame.equals(OMAHA))   gvNumCards = 8 + (4 * gvNumPlayers);
        else                              gvNumCards = gvNumPlayers;

        shuffleCardDeck();
        List<String> lvCardList = gvCardDeck.subList(0, gvNumCards);

        /**Groesse = x;
         * x-2
         * x-4 &
         * x-8 werden nicht ausgeteilt (Burncards),
         * Inhalt ist dann egal
         */
        int lvSize = lvCardList.size();
        if(lvCardList.size() >= 11) {
            lvCardList.set(lvSize-2, BURNCARDS);
            lvCardList.set(lvSize-4, BURNCARDS);
            lvCardList.set(lvSize-8, BURNCARDS);
        }

        return lvCardList;
    }

    private void shuffleCardDeck() {
        Collections.shuffle(gvCardDeck);
    }
}
```

Burncards: Rein technisch betrachtet kann ich mir Zeile 40-51 auch schenken; rechtlich betrachtet ist das die sinnvollere Vorgehensweise, dar es live genauso praktiziert wird.

@ARadauer: Zu spät, habe ich schon implementiert.


----------



## neonfly (21. Mai 2009)

Das Shuffeln scheint zu funktionieren.

Sicherheitshalber werde ich morgen 5 aus 52 ca. 20000mal darstellen und speichern + das Ergebnis mit regex überprüfen. Das Gleiche veranstalte ich mit den PocketCards.

Die "stärkste-Hand-Überprüfung" von Royal bis "hoechste Karte" funktioniert bisher tadellos.


----------

