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?