Discussion :

[pagada23]

Cc a tous , j'aurai besoin d'aide 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

[bruno_nono]

peux - tu mettre le code de tes classes

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Class Carte{
 
  String nom;
  String couleur; 
  int id ;
}

???

[franck06]

Cc a tous , j'aurai besoin d'aide 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 ...

[herve91]

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

1. les valeurs des cartes :
   

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

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

2. les couleurs

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

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

3. les combinaisons possibles dans l'ordre :

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   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 :

   Sélectionner tout - Visualiser dans une fenêtre à part

   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;
      }

[bruno_nono]

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

[pagada23]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[herve91]

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

Il suffit de les cumuler

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
   }

[pagada23]

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?

[herve91]

Non une méthode dans la classe Main qui détermine la combinaison la plus forte (pour la main courante).

[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?

[herve91]

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

[pagada23]

oui effectivement pour determiner le gagnant seule la plus forte m'interesse.
merci de m'avoir aidé avec ton algorithme , 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?!

[franck06]

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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[bruno_nono]

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?

[herve91]

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...

[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)

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


}

[herve91]

Pour éviter les if... en POO, on décompose en objets... (ici les "reconnaisseurs" de combinaison)

[pagada23]

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

[herve91]

Voir

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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