pseudo code java combinaison poker

Version imprimable

05/11/2010, 06h34
pagada23

pseudo code java combinaison poker

Cc a tous , j'aurai besoin d'aide:roll: sur un exo, alors on me demande de pouvoir realiser un jeu de poker ou j'ai 3 joueurs, j'ai une mise de depart de 5 jetons, et ensuite les joueurs recoivent aleatoirement 5 cartes, les cartes sont révélees et le joueur qui a la meilleure combinaison gagne les mises des 2 autres joueurs,
je dispose deja de certains classes comme valeurs et suite qui contiennent chacune les valeurs des cartes(1,2,3,4,5,..,As) et les la suite(COEUR, TREFLE,CARREAU.PIQUE) jai aussi la fonction RANDOM pour me generer les cartes aleatoirement et d'une fonction triée pour trier la suite de cartes saisies.

j'ai une liste de combinaisons qui m'ai donné mais je ne sais pas comment l'utiliser, les combinaisons sont de la plus faible a la plus forte, elle s'enonce comme suit:
- paire forte : une paire de valet, de dames de roi ou d'as
- deux paires : deux paires de cartes, peu importe les valeurs
-Brelan : trois cartes de mem valeur
-quinte : cinq cartes dont les valeurs se suivent, en cas d'egalité la suite la plus haute gagne
- carré : quatre cartes de mem valeurs, en cas dégalité le carré le plus fort gagne
et une quinte flush : une quinte dont les cartes sont de la mem sorte, encas dégalité la flush la plus haute gagne.

pourrais-je avoir un exemple de pseudo sur les trois premieres pour m'aider a mieux comprendre et faire les autres cas. merci :(:?
05/11/2010, 13h21
bruno_nono
peux - tu mettre le code de tes classes

Du genre tu as un objet qui modélise une carte
Code:

1 2 3 4 5 6 7 Class Carte{ String nom; String couleur; int id ; }
???
05/11/2010, 13h29
franck06

Citation:

Envoyé par pagada23

Cc a tous , j'aurai besoin d'aide:roll: sur un exo, alors on me demande de pouvoir realiser un jeu de poker ou j'ai 3 joueurs, j'ai une mise de depart de 5 jetons, et ensuite les joueurs recoivent aleatoirement 5 cartes, les cartes sont révélees et le joueur qui a la meilleure combinaison gagne les mises des 2 autres joueurs,
je dispose deja de certains classes comme valeurs et suite qui contiennent chacune les valeurs des cartes(1,2,3,4,5,..,As) et les la suite(COEUR, TREFLE,CARREAU.PIQUE) jai aussi la fonction RANDOM pour me generer les cartes aleatoirement et d'une fonction triée pour trier la suite de cartes saisies.

j'ai une liste de combinaisons qui m'ai donné mais je ne sais pas comment l'utiliser, les combinaisons sont de la plus faible a la plus forte, elle s'enonce comme suit:
- paire forte : une paire de valet, de dames de roi ou d'as
- deux paires : deux paires de cartes, peu importe les valeurs
-Brelan : trois cartes de mem valeur
-quinte : cinq cartes dont les valeurs se suivent, en cas d'egalité la suite la plus haute gagne
- carré : quatre cartes de mem valeurs, en cas dégalité le carré le plus fort gagne
et une quinte flush : une quinte dont les cartes sont de la mem sorte, encas dégalité la flush la plus haute gagne.

pourrais-je avoir un exemple de pseudo sur les trois premieres pour m'aider a mieux comprendre et faire les autres cas. merci :(:?

si j'étais toi, je ferais une classe Joueur ou t'as le nom du joueur, un tableau de 5 cartes, et son nombre de jetons, ainsi que son status (a 0 jeton, le joueur a perdu ...) et sa main en cours

ensuite une classe, DetermineMain qui contient une methode statique qui te retourne la main du joueur (pour les mains tu peux mettre un enum genre Main avec comme valeur PAIRE, DOUBLE_PAIRE, BRELAN, QUINTE, FULL ....)
et une autre qui prend une liste de joueurs et te renvoie celui avec la main la plus forte

et enfin une classe Play qui contient une méthode jouer ...
et dans jouer :
- mettre les mises des joueurs
- distribuer les cartes
- determiner les mains de chaque joueur
- determiner la plus forte
- redistribuer les gains et mettre a jour le status des joueurs

pour ta question sur que faire avec paire, double paire ...
faut que dans la methode qui determine la main du joueur, tu partes de la main la plus faible (la paire dans ton cas) en allant vers la plus forte
- est-ce qu'il a une paire
- 2 paires = 1 paire + 1 autre paire
- brelan = paire + 1 carte correspondante a la paire
- couleur = 5 cartes de meme couleur
- suite = 5 cartes qui se suivent
- full = brelan + 2 autres cartes qui forment une paire
- carré = 2 paires avec la meme hauteur de carte
- quinte flush = suite + couleur ...

Tu peux déjà faire apparaître des types énumérés pour :

les valeurs des cartes :

Code:

1
2
3
enum EnumValeurCarte {
   UN, DEUX, TROIS, ..., AS;
}

les couleurs

Code:

1
2
3
enum EnumCouleurCarte {
   TREFLE, CARREAU, COEUR, PIQUE;
}

les combinaisons possibles dans l'ordre :

Code:

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
enum EnumCombinaison {
   RIEN(new RecognizerRien()), UNE_PAIRE(new RecognizerUnePaire()), DEUX_PAIRES(new RecognizerDeuxPaires()), BRELAN(new RecognizerBrelan()), ...;
 
   public Recognizer recognizer;
   private EnumCombinaison(Recognizer recognizer) {
      this.recognizer = recognizer;
   }
}
 
// Reconnait une combinaison donnée
interface Recognizer {
 
   boolean match(Main main);
}
 
class RecognizerRien implements Recognizer {
 
      public boolean match(Main main) {
         return true;
      }
 
}
 
// Un exemple (améliorable) pour RecognizerUnePaire :
class RecognizerUnePaire implements Recognizer {
 
      public boolean match(Main main) {
         int nbCartes = main.getNbCartes() ;
 
         for (i = 0; i < nbCartes - 1; i++) {
            EnumValeurCarte valeurCarteI = main.getCarte(i).getValeurCarte() ;
 
           for (j = i + 1; j < nbCartes; j++) {
               if (main.getCarte(j).getValeurCarte() == valeurCarteI) {
                  return true;
               }
            }
         }
         return false;
      }
 
}

dans la classe Main (comme une main et non comme "main" en anglais) :

Code:

1
2
3
4
5
6
7
8
9
10
 
   public EnumCombinaison evaluer() {
      for (EnumCombinaison combinaison : Collections.reverseOrder(EnumCombinaison.values)) {
         if (combinaison.recognizer.match(this)) {
            return combinaison;
         }
      }
      // On ne doit pas arriver ici
      return RIEN;
   }

05/11/2010, 14h52
bruno_nono

je pense qu'il faut faire attention car le joueur peut avoir plusieurs combinaison

combinaison poker java

merci!!!
le prof pour nous aidé nous a fourni ces classes :
la classe carte

Code:

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
public class Carte {
    /**
     * Valeur de la carte (2,3,4,5,6,7,8,9,10,V,Q,K,A)
     */
    private Valeur valeur;
    /**
     * Suite (carreau, coeur, pique, trèfle)
     */
    private Suite suite;
 
    /**
     * @param valeur La valeur de la carte.
     * @param suite La suite de la carte.
     */
    public Carte(final Valeur valeur, final Suite suite) {
        this.valeur = valeur;
        this.suite = suite;
    }
 
    public Valeur obtenirValeur() {
        return valeur;
    }
 
    public Suite obtenirSuite() {
        return suite;
    }
 
    @Override
    public String toString() {
        return this.valeur.toString() + " de " + this.suite.toString();
    }
}

la classe suite

Code:

1
2
3
4
5
6
7
8
9
10
11
public enum Suite {
    CARREAU,
    COEUR,
    PIQUE,
    TREFLE;
 
    @Override
    public String toString() {
        return this.name().charAt(0) + this.name().substring(1).toLowerCase().replace("ef","èf");
    }
}

et paquetCartes

Code:

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
public class PaquetCartes {
    /**
     * Générateur de nombres aléatoires.
     */
    private static Random generateur = new Random();
    /**
     * Paquet de cartes.
     */
    private static ArrayList<Carte> paquet = new ArrayList<Carte>();
 
    /**
     * Remet les cartes dans le paquet.
     */
    public static void brasser() {
        PaquetCartes.paquet.clear();
        for (Suite suite : Suite.values()) {
            for (Valeur valeur : Valeur.values()) {
                PaquetCartes.paquet.add(new Carte(valeur, suite));
            }
        }
    }
 
    /**
     * Pige une carte au hasard et l'enlève du paquet.
     *
     * @return La carte pigée.
     */
    public static Carte piger() {
        if (PaquetCartes.paquet.isEmpty()) {
            PaquetCartes.brasser();
        }
        return PaquetCartes.paquet.remove(generateur.nextInt(PaquetCartes.paquet.size()));
    }
 
    /**
     * Trie la main de carte.
     *
     * @param main La main de cartes à trier. Le tableau peut avoir n'importe quelle taille mais doit être rempli. Ce tableau sera modifié lors de l'exécution de la méthode
     */
    public static void trierMain(Carte[] main) {
        Arrays.sort(main);
    }
 
    /**
     * Exemple d'utilisation
     * *
     */
    public static void main(String[] args) {
        int nombreDeDeux = 0;
        int nombreDeTrefles = 0;
 
        PaquetCartes.brasser();
 
        for (int i = 1; i <= 52; i++) {
            Carte carte = PaquetCartes.piger();
            System.out.println(carte);
            // Vérifier la valeur d'une carte
            if (carte.obtenirValeur() == Valeur.DEUX) {
                nombreDeDeux++;
            }
            // Vérifier la suite d'une carte
            if (carte.obtenirSuite() == Suite.TREFLE) {
                nombreDeTrefles++;
            }
        }
        System.out.println("Nombre de 2 : " + nombreDeDeux);
        System.out.println("Nombre de trèfles : " + nombreDeTrefles);
 
        // Vérifier si une carte est plus forte qu'une autre en comparant leurs valeurs.
        PaquetCartes.brasser();
        Carte c1 = PaquetCartes.piger();
        Carte c2 = PaquetCartes.piger();
        if (c1.obtenirValeur().compareTo(c2.obtenirValeur()) < 0) {
            System.out.println("Un " + c1 + " est plus faible qu'un " + c2);
        } else if (c1.obtenirValeur().compareTo(c2.obtenirValeur()) == 0) {
            System.out.println("Un " + c1 + " est de même force qu'un " + c2);
        } else {
            System.out.println("Un " + c1 + " est plus fort qu'un " + c2);
        }
 
            //Trier une main de 5 cartes
        PaquetCartes.brasser();
        Carte[] main = {PaquetCartes.piger(), PaquetCartes.piger(), PaquetCartes.piger(), PaquetCartes.piger(), PaquetCartes.piger()};
        System.out.println("Cartes en main:");
        for (Carte carte : main) {
            System.out.println(carte);
        }
 
        System.out.println("Cartes en main, triées");
        PaquetCartes.trierMain(main);
        for (Carte carte : main) {
            System.out.println(carte);
        }
    }
}

Est ce que les combinaisons serait plus facile a faire en me servant de la classe paquetCarte et comment pourrais je m'en servir ?

Citation:

Envoyé par bruno_nono

je pense qu'il faut faire attention car le joueur peut avoir plusieurs combinaison

Il suffit de les cumuler

Code:

1
2
3
4
5
6
7
8
9
10
11
   public List<EnumCombinaison> evaluerAll() {
      List<EnumCombinaison> listeCombinaisons = new ArrayList<EnumCombinaison>();
 
      for (EnumCombinaison combinaison : EnumCombinaison.values) {
         if (combinaison.recognizer.match(this)) {
            listeCombinaisons.add(combinaison);
         }
      }
      listeCombinaisons.remove(RIEN);
      return listeCombinaisons;
   }

05/11/2010, 16h03
pagada23

combinaison poker java

excuse moi, juste pour mieux comprendre tu me propose de faire une classe qui me permettrait de déterminer en fonction de la main du joueur la combinaison gagnante?
05/11/2010, 16h06
herve91

Non une méthode dans la classe Main qui détermine la combinaison la plus forte (pour la main courante).
05/11/2010, 16h13
pagada23

ok:) donc ta methode evaluerAll() evalue toutes les combinaisons possibles si combinaison il ya, que j'aurai défini dans la classe enum combinaisons?
05/11/2010, 16h27
herve91

Oui, c'est ça. Maintenant as-tu réellement besoin de toutes les combinaisons possibles, seule la plus forte t'intéresse ?
05/11/2010, 16h44
pagada23

oui effectivement pour determiner le gagnant seule la plus forte m'interesse.
merci de m'avoir aidé avec ton algorithme :D, je voudrais avoir ton point de vue en fait moi j'ai essayé de me faire une méthode COMPARERCARTE() qui prend en paramètre un tableau de cartes, disons que dans mon MAIN je considere le premier joueur et avec ma methode

public static boolean COMPARERCARTE(tableau des 5 cartes ) en question,

je veux comparer chacune des cartes du joueur concernée avec les differentes combinaisons et si la combinaison est trouvée je retourne un boolean (VRAI) dans le cas ou la combinaison de carte de mon joueur correspond avec une des combinaisons gagnante sinon (FAUX) et ensuite me faire une autre methode qui me determinerai les combinaisons forte de tous les joueurs pourrais je avoir ton avis?!
05/11/2010, 16h50
franck06

Citation:

Envoyé par herve91

Oui, c'est ça. Maintenant as-tu réellement besoin de toutes les combinaisons possibles, seule la plus forte t'intéresse ?

au poker c'est la combinaison la plus forte qui l'emporte
par contre, t'as beaucoup beaucoup plus de chance d'avoir une paire, qu'une quinte flush ...

moi je partirais de la plus basse vers la plus haute, en gardant la liste des combinaisons trouvées, et la meilleure:
- genre, je verifie si une paire => si une paire, c'est la meilleure combinaison courante
- si une paire et une seule, je verifie si 2 paires => SI 2 paires meilleure combinaison courante
- si une paire au moins, je verifie si brelan => ....
- je verifie quinte => ...
- je verifie couleur => ...
- si on a deux paire, je verifie FULL = 2 paires et une carte de valeur = à une des 2 paires
- je verifie carré = 2 paires de meme valeur
- je verifie quinte flush = couleur + quinte
- je verifie quinte flush royale = couleur + quinte + un as
05/11/2010, 16h55
herve91
En fait, on peut dire qu'on peut comparer deux instances de Main : une main est < à une autre si sa combinaison la plus forte est < la combinaison la plus forte de l'autre, donc :
Code:

1 2 3 4 5 6 public Main implements Comparable<Main> { public int compareTo(Main autreMain) { return main.evaluer().compareTo(autreMain.evaluer()); } }
Ensuite reste à définir la méthode evaluer() comme précédemment qui sait faire deux choses : elle évalue les combinaisons possibles et retourne tout de suite la plus forte, sans évaluer les autres puisqu'on est sûr qu'elles sont plus basses, car on parcourt selon l'ordre inverse des énumérés EnumCombinaison... ou alors tu ordonnes EnumCombinaison en mettant d'abord la combinaison la plus forte ;)
05/11/2010, 16h56
bruno_nono

Citation:

Envoyé par franck06

au poker c'est la combinaison la plus forte qui l'emporte
par contre, t'as beaucoup beaucoup plus de chance d'avoir une paire, qu'une quinte flush ...

oui en terme de probabilité, cependant je pense que ce ne sont pas des gros calculs... donc pour moi il vaut mieux regarder d'abord les plus fortes => cela évitera de regarder si quelqu'un à une paire puis un brelan... au moins
si quelqu'un à carré d'as , on compare à la plus forte de l'autre puis basta... nan?
05/11/2010, 16h57
herve91

Citation:

Envoyé par franck06

au poker c'est la combinaison la plus forte qui l'emporte
par contre, t'as beaucoup beaucoup plus de chance d'avoir une paire, qu'une quinte flush ...

moi je partirais de la plus basse vers la plus haute, en gardant la liste des combinaisons trouvées, et la meilleure:
- genre, je verifie si une paire => si une paire, c'est la meilleure combinaison courante
- si une paire et une seule, je verifie si 2 paires => SI 2 paires meilleure combinaison courante
- si une paire au moins, je verifie si brelan => ....
- je verifie quinte => ...
- je verifie couleur => ...
- si on a deux paire, je verifie FULL = 2 paires et une carte de valeur = à une des 2 paires
- je verifie carré = 2 paires de meme valeur
- je verifie quinte flush = couleur + quinte
- je verifie quinte flush royale = couleur + quinte + un as

Il suffit de parcourir les combinaisons de la plus forte vers la plus faible, au moins tu t'arrêtes au plus tôt...
05/11/2010, 17h05
pagada23

merci franck06 je pense com toi mais mon souci, c'est le code avec les if parce-que ce a quoi je penses c vraiment prendre chacunes des cartes de mon joueur que je comparerais avec chacune des cartes de ma combinaison gagnante du genre(mais je sais vraiment pas comment m'y prendre:oops::roll:)

voila ce a quoi jai penser:
public static boolean COMPARERCARTE(Carte carteC1, Carte carteC2, ..., Carte carteC5){

// avec les methodes obtenirValeur() et obtenirSuite() deja defnies

Si carteC1.obtenirSuite() est égale à TREFLE
Si carteC1.obtenirValeur() est égale à DEUX, Alors
DEUX <- DEUX + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à TROIS,Alors
TROIS <- TROIS + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à QUATRE,Alors
QUATRE <- QUATRE + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à CINQ,Alors
CINQ <- CINQ + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à SIX,Alors
SIX <- SIX + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à SEPT,Alors
SEPT <- SEPT + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à HUIT,Alors
HUIT <- HUIT+ 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à NEUF,Alors
NEUF <- NEUF + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à DIX,Alors
DIX <- DIX + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à VALET,Alors
VALET <- VALET + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à DAME,Alors
DAME <- DAME + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à ROI,Alors
ROI<- ROI + 1
TREFLE <- TREFLE + 1
Finsi
Si carteC1.obtenirValeur() est égale à AS,Alors
AS <- AS + 1
TREFLE <- TREFLE + 1
Finsi
}
je fais la meme chose avec carteC2, carteC3, carteC4 et carteC5

}
05/11/2010, 17h08
herve91

Pour éviter les if... en POO, on décompose en objets... (ici les "reconnaisseurs" de combinaison)
05/11/2010, 17h16
pagada23

herve91 quand tu parles de reconnaisseur de combinaisons c'est la methode evaluerAll()? :roll:

Voir

Code:

1
2
3
4
interface Recognizer {
 
   boolean match(Main main);
}

05/11/2010, 17h28
pagada23

MERCI!!!!:D:D
05/11/2010, 17h40
franck06

ben si tu commences par la plus forte, tu regardes si y'a une quinte flush

- quinte flush = couleur + quinte, tu fais tous les calculs pour savoir si c'est c'est une couleur et une quinte
- carré = tu fais le calcul de savoir si ya 4 cartes de meme valeur parmis les 5
- Full = tu essaies de trouver 3 cartes de meme valeur parmis les 5 et check que les deux autres ont meme valeur
......

en allant de la plus faible combinaison a la plus forte
- trouver une paire c'est assez simple, tu l'as ecrit
- trouver deux paire aussi
- trouver un brelan c'est avoir 1 paire au moins + 1 autre carte parmi les 2 qui restent de meme valeur => facile
- avoir une quinte c'est 5 cartes qui se suivent
- avoir une couleur c'est definir si toutes les cartes sont de meme ordre
- avoir un full = avoir un brelan + 1 paire => calcul immédiat
- avoir un carré = avoir 2 paires de meme valeur => immediat
- avoir une quinte flush, c'est couleur + quinte => immediat
- avoir une quinte flush royale, c'est couleur + quinte + 1 as=> immediat

je trouve que ca peut eviter pas mal de recalcul