Discussion :

[TheChicken]

Bonjours a tous,
Je suis étudiant en deuxième année d'informatique et j'ai pour projet de fin de semestre un jeu de blackjack a réaliser.
J'ai déja bien avancé mon projet cependant je me retrouve devant un bug dont je ne connais pas la source et qui empêche le bon déroulement de la partie.

Pour ceux qui ne connaîtrais pas le déroulement de la partie, on distribue 2 cartes a chaque joueurs puis deux au croupier, puis les joueurs choisissent de retirer des cartes ou non en fonction de leurs main.
Mon problème ce situe ici, en effet, le nombre de carte distribuer au joueurs et proportionnel au nombre de joueurs dans la partie (entre 1 et 7 + le croupier (ordinateur). Cependant, je ne trouve pas dans mon code l'erreur qui implique cela.
Mon code n'est pas complet (toutes les "fonctions" du jeu ne sont pas présente) mais tout ce qui est codé est fonctionnel.

Je vous joins l'intégralité de mon code (avec le maximum de commentaire) ainsi que le liens wikipédia du blackjack pour ceux que ça intéresserait : http://fr.wikipedia.org/wiki/Blackjack_(jeu)
Merci d'avance.
Ps : les partie du code en commentaire sont soit des anciennes versions de celui-ci ou simplement des test.

Classe PaquetCartes (classe qui gere le paquet de carte, le mélange, ainsi que la valeur de chaque cartes)

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
package BlackJack;
import java.util.Random ;
 
class PaquetCartes {
 
  public static void remplissagePaquet (int [] paquetPartie){
    for (int i = 0; i<52 ; i++){
      paquetPartie[i] = i+1;
    }
  }
 
  public static void melangerPaquet (int [] paquetPartie){
    Random rgen = new Random();
    for (int i=0; i<paquetPartie.length; i++) {
      int randomPosition = rgen.nextInt(paquetPartie.length);
      int temp = paquetPartie[i];
      paquetPartie[i] = paquetPartie[randomPosition];
      paquetPartie[randomPosition] = temp;
    }
  }
 
  public static void carte (int carte){
    String couleur = new String ();
    String valeur = new String ();
    if (carte <= 13 && carte > 0){
      couleur = "Carreau";
      valeur = ""+carte;
      if(carte == 11){
        valeur = "valet";
      }
      if(carte == 12){
        valeur = "Dame";
      }
      if(carte == 13){
        valeur = "Roi";
      }
      if(carte == 1){
        valeur = "As";
      }
      System.out.println(valeur+" de "+couleur);
    }
    if (carte <= 26 && carte >13){
      couleur = "Pique";
      valeur = ""+(carte-13);
      if(carte == 24){
        valeur = "valet";
      }
      if(carte == 25){
        valeur = "Dame";
      }
      if(carte == 26){
        valeur = "Roi";
      }
      if(carte == 14){
        valeur = "As";
      }
      System.out.println(valeur+" de "+couleur);
    }
    if (carte <= 39 && carte > 26){
      couleur = "Trefle";
      valeur = ""+(carte - 26);
      if(carte == 37){
        valeur = "valet";
      }
      if(carte == 38){
        valeur = "Dame";
      }
      if(carte == 39){
        valeur = "Roi";
      }
      if(carte == 27){
        valeur = "As";
      }
      System.out.println(valeur+" de "+couleur);
    }
    if (carte <= 52 && carte > 39){
      couleur = "Coeur";
      valeur = ""+(carte-39);
      if(carte == 50){
        valeur = "valet";
      }
      if(carte == 51){
        valeur = "Dame";
      }
      if(carte == 52){
        valeur = "Roi";
      }
      if(carte == 40){
        valeur = "As";
      }
      System.out.println(valeur+" de "+couleur);
    }
  }
 
  public static int valeurCarte (int carte){
    int point = 0;
    if (carte <= 13 && carte > 0){
      point = carte;
      if(carte == 11){
        point = 10;
      }
      if(carte == 12){
        point = 10;
      }
      if(carte == 13){
        point = 10;
      }
      if(carte == 1){
        point = 11;
      }
    }
    if (carte <= 26 && carte >13){
      point = carte - 13;
      if(carte == 24){
        point = 10;
      }
      if(carte == 25){
        point = 10;
      }
      if(carte == 26){
        point = 10;
      }
      if(carte == 14){
        point = 11;
      }
    }
    if (carte <= 39 && carte > 26){
      point = carte - 26;
      if(carte == 37){
        point = 10;
      }
      if(carte == 38){
        point = 10;
      }
      if(carte == 39){
        point = 10;
      }
      if(carte == 27)
      {
        point = 11;
      }
    }
    if (carte <= 52 && carte > 39){
      point = carte - 39;
      if(carte == 50){
        point = 10;
      }
      if(carte == 51){
        point = 10;
      }
      if(carte == 52){
        point = 10;
      }
      if(carte == 40){
        point = 11;
      }
    }
    return point;
  }
 
  public static void affichePaquet (int [] paquetPartie){
    for (int i = 0 ; i<52; i++){
      System.out.println(valeurCarte(paquetPartie[i]));
    }
  }
 
}

classe du joueur et ses paramètres ainsi que diverse fonction relative au jeu du joueur

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
 
package BlackJack;
 
class Joueur {
  String nom;
  int argent;
  int [] main = new int [5];
  int mise;
  boolean continuer;
  boolean perdu;
 
  Joueur (String nom, int argentDepart, int [] main){
    this.nom = nom;
    argent = argentDepart;
    this.main = main;
    mise = 0;
    continuer = true;
    perdu = false;
  }
 
  public static int pointsMain(Joueur joueur){
    int somme = 0;
    for (int i = 0; i<5;i++){
      somme += BlackJack.PaquetCartes.valeurCarte(joueur.main[i]);   
    }
    if(somme > 21){
      int nbAs = 0;
      for (int i = 0;i<5;i++){
        if(BlackJack.PaquetCartes.valeurCarte(joueur.main[i])==11){
          nbAs ++;
        }
      }
      if(nbAs != 0){
        somme -=10*nbAs;
      }
    }
    return somme;
  }
 
  public static void afficherMain(Joueur joueur){
    for (int i = 0; i<5;i++){
      BlackJack.PaquetCartes.carte(joueur.main[i]);
    }
  }
 
  public static void toPrint(Joueur joueur){
    System.out.println(joueur.nom+" "+joueur.argent);
  }
 
  public static void reset (Joueur joueur){
    joueur.perdu = false;
    joueur.continuer = true;
    for(int i = 0;i<5;i++){
      joueur.main[i] = 0;
    }
  }
 
}

classe du jeu proprement dit

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
package BlackJack;
import javax.swing.JOptionPane;
import javax.swing.JFrame;
 
class jeu {
 
  public static int distribuerCarte (Joueur joueur,int[] paquet,int currentCard ){
    System.out.println(currentCard);
    int newCard = currentCard ;
    for(int i = 0; i < joueur.main.length;i++){
      if (joueur.main[i] == 0){
        joueur.main[i]=paquet[newCard];
        System.out.println(joueur.main[i]);     
        newCard ++;
        break;
      }
    }
    return newCard;
  }
 
  public static void mise (Joueur joueur){
    String tempMise = JOptionPane.showInputDialog("Combien le joueueur "+joueur.nom+" veut-il miser ?");
    int mise = Integer.parseInt(tempMise);
    joueur.argent -= mise;
    joueur.mise = mise;
    System.out.println("Vous avez misé "+mise);
  }
 
  public static void menu (Joueur joueur,Joueur croupier,int[] paquet, int currentCard){
    Object[] selectionValues = { "Tirer une carte", "Rester", "Doubler la mise","Partager","S'assurer","Voir les cartes du croupier" };
    String initialSelection = "Tirer une carte";
    Object selection = JOptionPane.showInputDialog(null, "Que desirez-vous faire ?",
        "", JOptionPane.QUESTION_MESSAGE, null, selectionValues, initialSelection);
    if(selection == "Tirer une carte"){
      currentCard = autreCarte(joueur,paquet,currentCard);
    }
    if(selection == "Rester"){
      joueur.continuer=false;
    }
    if(selection == "Doubler la mise"){
      JFrame parent = new JFrame();
      int nbCartes = 0;
      for(int i = 0; i<5;i++){
        if(joueur.main[i] !=0 ){
          nbCartes ++;
        }
      }
      if(nbCartes==2){
        joueur.mise *= 2;
        JOptionPane.showMessageDialog(parent, "Votre mise est maintenant de "+joueur.mise);
        currentCard=autreCarte(joueur,paquet,currentCard);
      }
      if(nbCartes>2){
        JOptionPane.showMessageDialog(parent, "Vous ne pouvez pas doubler votre mise");
        menu(joueur,croupier,paquet,currentCard);
      }
    }
    if(selection == "Partager"){
      // split la main
    }
    if(selection == "S'assurer"){
      int nbCartes = 0;
      for(int i = 0; i<5;i++){ // on compte le nombre de carte du croupier
        if(joueur.main[i] !=0 ){
          nbCartes ++;
        }
      }
      if(BlackJack.PaquetCartes.valeurCarte(croupier.main[0]) == 11 && nbCartes == 1){
        /*joueur.mise /= 2;*/ //faire l'assurance
      }
    }
    if(selection == "Voir les cartes du croupier"){
      System.out.println("Cartes du croupier : ");
      BlackJack.Joueur.afficherMain(croupier);
      System.out.println("Valeur des cartes du croupier : " + BlackJack.Joueur.pointsMain(croupier));
    }
  }
 
  public static int autreCarte(Joueur joueur,int[] paquet,int currentCard){
    int carte = currentCard;
      carte = distribuerCarte(joueur,paquet,carte);
      System.out.println("Vous avez pioché ");
      BlackJack.PaquetCartes.carte(paquet[carte-1]);
      System.out.println("Votre main vaux : "+BlackJack.Joueur.pointsMain(joueur));
      /*if(BlackJack.Joueur.pointsMain(joueur) > 21 ){
        joueur.perdu = true ;
        return carte ;
      }*/
      return carte;
    }
 
    public static int suitePartie(Joueur croupier,int[] paquet, int currentCard){ // la suite du jeu pour le croupier
    int carte = currentCard;
    while(BlackJack.Joueur.pointsMain(croupier) <17){ // le croupier tire des cartes tant qu'il ne dépasse pas 16
      carte = BlackJack.jeu.distribuerCarte(croupier,paquet,carte);
      System.out.println("le croupier a tiré  ");
      BlackJack.PaquetCartes.carte(paquet[carte-1]);
      System.out.println("Sa main vaux : "+BlackJack.Joueur.pointsMain(croupier));
      if(BlackJack.Joueur.pointsMain(croupier)>21){ // le croupier a dépassé 21, il a donc perdu
        croupier.perdu = true;
        return carte;
      }
    }
    croupier.continuer = false; // le croupier ne peu peut piocher de carte (il a dépassé 16)
    return carte;
    }
 
  public static void gagnant(Joueur joueur, Joueur croupier){
    JFrame parent = new JFrame();
 
    if(joueur.continuer == true && joueur.perdu == false){ // le joueur n'a pas perdu et veux continuer
      if(BlackJack.Joueur.pointsMain(joueur) > 21){ // on verifie si il a perdu
        joueur.perdu = true;
        joueur.continuer = false;
        JOptionPane.showMessageDialog(parent, "Vous avez perdus");
        joueur.argent -= joueur.mise;
        JOptionPane.showMessageDialog(parent, "Votre perte est de "+joueur.mise+" et vous possedez "+joueur.argent);
      }
      if(BlackJack.Joueur.pointsMain(joueur)<=21){
        // on ne fait rien, le joueur a le droit et l'envie de continuer a piocher
      }
    }
    if(croupier.perdu == true && joueur.perdu == false){ // le joueur n'a pas perdu mais le croupier oui
      JOptionPane.showMessageDialog(parent, "Vous avez gagner");
      joueur.argent += (joueur.mise*2);
      JOptionPane.showMessageDialog(parent, "Votre gain est de "+(joueur.mise*2)+" et vous possedez "+joueur.argent);
    }
    if(joueur.continuer == false && joueur.perdu == false){ // le joueur n'a pas encore perdu mais a décidé de s'arreter 
 
      if(BlackJack.Joueur.pointsMain(joueur) <= 21 && BlackJack.Joueur.pointsMain(joueur) < BlackJack.Joueur.pointsMain(croupier)){ // le joueur a une main plus faible que le coupier il a donc perdu
        joueur.perdu = true;
        joueur.continuer = false;
        JOptionPane.showMessageDialog(parent, "Vous avez perdus");
        joueur.argent -= joueur.mise;
        JOptionPane.showMessageDialog(parent, "Votre perte est de "+joueur.mise+" et vous possedez "+joueur.argent);
      }
 
      if(BlackJack.Joueur.pointsMain(joueur) <= 21 && BlackJack.Joueur.pointsMain(joueur) == BlackJack.Joueur.pointsMain(croupier)){ // le joueur et le croupier ont la même main (en terme de points)
        joueur.perdu = true;
        joueur.continuer = false;
        JOptionPane.showMessageDialog(parent, "Vous avez égalisé avec le croupier");
        joueur.argent += joueur.mise;
        JOptionPane.showMessageDialog(parent, "Votre gain est de "+joueur.mise+" et vous possedez "+joueur.argent);
      }
      if(BlackJack.Joueur.pointsMain(joueur) <= 21 && BlackJack.Joueur.pointsMain(joueur) > BlackJack.Joueur.pointsMain(croupier)){ // le joueur a battu le croupier
        JOptionPane.showMessageDialog(parent, "Vous avez gagner");
        joueur.argent += (joueur.mise*2);
        JOptionPane.showMessageDialog(parent, "Votre gain est de "+(joueur.mise*2)+" et vous possedez "+joueur.argent);
      }
    }    
  }
 
}

et enfin le main qui forme le jeu proprement dit

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
96
97
98
99
100
 
package BlackJack;
import javax.swing.JOptionPane;
import javax.swing.JFrame;
 
class Main {
 
  public static int lireEntier(String message, int min, int max){ // fonction pour le nombre de joueurs 
    while (true){
      String str = JOptionPane.showInputDialog(message+" (entre "+min+" et "+max+")");
      try{
        int n = Integer.parseInt(str);
        if (n>=min && n<=max){
          return n;
        }else{
          JOptionPane.showMessageDialog(null, "La valeur doit être entre "+min+" et "+max, "LireEntier", JOptionPane.ERROR_MESSAGE);
 
        }
      }
      catch (NumberFormatException e){
        JOptionPane.showMessageDialog(null, "Entrer un nombre entre "+min+" et "+max, "LireEntier", JOptionPane.ERROR_MESSAGE);
      }
    }
  }
 
  public static Joueur [] initPartie(){
    Joueur [] joueurs ;
    int argent = 900;
    int [] main = {0,0,0,0,0};
    int nombreJoueurs =lireEntier("Quel est le nombre de joueurs ?",1,7);
    joueurs = new Joueur [nombreJoueurs+1]; // on rajoute un joueurs, qui est le croupier
    for(int i = 0; i<joueurs.length-1;i++){
      String nomJoueur = JOptionPane.showInputDialog("Quel est le nom du joueurs "+(i+1)+ "?");
      joueurs[i]= new Joueur (nomJoueur,argent,main);
    }
    joueurs[nombreJoueurs] = new Joueur ("Croupier",argent,main); // on rajoute le croupier a la fin du tableau de joueurs 
 
  return joueurs;
}
 
  public static void partie (Joueur [] joueurs, int [] paquet, int carte){
    JFrame parent = new JFrame();
    System.out.println(joueurs.length);
 
    for(int i =0; i<joueurs.length-1;i++){ // On distribue deux cartes a tous les joueurs (je pense que mon problème ce situe ici 
      BlackJack.jeu.mise(joueurs[i]);
      System.out.println(carte);
      carte = BlackJack.jeu.distribuerCarte(joueurs[i],paquet,carte);
      System.out.println(carte);
      carte = BlackJack.jeu.distribuerCarte(joueurs[i],paquet,carte);
      System.out.println(carte);
 
    }
    carte = BlackJack.jeu.distribuerCarte(joueurs[joueurs.length-1],paquet,carte); // on distribue une carte au croupier
 
    for(int i =0; i<joueurs.length-1;i++){ // chaque joueurs joue sont tours
 
      JOptionPane.showMessageDialog(parent, "C'est au tour de "+joueurs[i].nom);
      System.out.println("Cartes de "+joueurs[i].nom+" : ");
      BlackJack.Joueur.afficherMain(joueurs[i]);
      System.out.println("Valeur des cartes de "+joueurs[i].nom+": "+ BlackJack.Joueur.pointsMain(joueurs[i]));
 
      BlackJack.jeu.gagnant(joueurs[i],joueurs[joueurs.length-1]); // on vérifie que le joueur n'a pas perdu avant qu'il puisse tirer d'autre cartes
 
      while(joueurs[i].continuer == true && joueurs[i].perdu == false){
        BlackJack.jeu.menu(joueurs[i],joueurs[joueurs.length-1],paquet,carte); // le choix pour le joueur 
        BlackJack.jeu.gagnant(joueurs[i],joueurs[joueurs.length-1]); // on verifie qu'il n'a pas perdu 
      }    
    }
 
 
    while(joueurs[joueurs.length-1].continuer == true && joueurs[joueurs.length-1].perdu == false){ // on fait jouer le croupier
      carte = BlackJack.jeu.suitePartie(joueurs[joueurs.length-1],paquet,carte);
    }
 
    for(int i =0; i<joueurs.length-1;i++){ // les joueurs n'ayant pas perdu (i.e n'ayant pas dépassé 21) ce confronte au croupier pour savoir si ils ont gagné
      BlackJack.jeu.gagnant(joueurs[i],joueurs[joueurs.length-1]);
      BlackJack.Joueur.reset(joueurs[i]); // on remet a 0 le jeu des joueurs
    }
    BlackJack.Joueur.reset(joueurs[joueurs.length-1]); // on remet a 0 le jeu du croupier
    System.out.println("");
    BlackJack.Main.partie(joueurs,paquet,carte); // on relance une nouvelle partie
  }
 
  public static void main(String [] args) {
    int [] paquet = new int [52];
    BlackJack.PaquetCartes.remplissagePaquet(paquet);
    BlackJack.PaquetCartes.melangerPaquet(paquet);
    int carte = 0;
    Joueur [] joueurs;
    joueurs=initPartie();
    /*for(int i = 0;i<joueurs.length;i++){
      System.out.println(joueurs[i].nom);
      //System.out.print("jepassedansbouce");
    }*/
    System.out.println(joueurs.length);
    partie(joueurs,paquet,carte);
  }
 
}

[thierryler]

Bonjour,

Je n'ai pas compris ce qui te fait penser que ça ne marche pas. Tu peux préciser un peu plus le bug que tu rencontres ?

Sinon quelques remarques à corriger asap :

1) Utilise des enum pour les couleurs, pour les valeurs as, roi, dame, etc. et pour les cartes utilisant ces deux enum ;
2) un nom de package est de la forme "com.masociete.monprojet.machin" et ne doit pas avoir de majuscule
3) ne pas appeler une classe "Main", ça fait trio scolaire.
4) ne nomme pas ta variable "main" mais plutôt "hand" ou "cartesEnMain" car ça fait trop bizare.
5) banni les tableaux au profit des list
6) les noms de classes commencent par des majuscules

Voici des classes toutes prêtes (exemple).

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
 
public enum FigureEnum {
 
    AS("A", 11),
    ROI("K", 10),
    // ...
    SEPT("7", 7);
 
    private final String label;
 
    private final int value;
 
    private FigureEnum(String label, int value) {
	this.label = label;
	this.value = value;
    }
 
    public String getLabel() {
	return label;
    }
 
    public int getValue() {
	return value;
    }
}

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
 
public enum CouleurEnum {
 
    COEUR("Coeur", "Rouge"), 
    PIQUE("Pique", "Rouge"), 
    CARREAU("Carreau", "Noir"), 
    TREFFLE("Treffle", "Noir");
 
    private final String label;
    private final String couleur;
 
    private CouleurEnum(String label, String couleur) {
	this.label = label;
	this.couleur = couleur;
    }
 
    public String getLabel() {
	return label;
    }
 
    public String getCouleur() {
	return couleur;
    }
}

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
 
package com.thi.black;
 
import static com.thi.black.CouleurEnum.COEUR;
import static com.thi.black.CouleurEnum.PIQUE;
import static com.thi.black.FigureEnum.AS;
import static com.thi.black.FigureEnum.ROI;
import static com.thi.black.FigureEnum.SEPT;
//...
 
public enum CarteEnum {
 
    AS_DE_COEUR(COEUR, AS),
    ROI_DE_COEUR(COEUR, ROI),
 
    //...
    SEPT_DE_PIQUE(PIQUE, SEPT);
 
    private final CouleurEnum couleur;
 
    private final FigureEnum figure;
 
    private CarteEnum(CouleurEnum couleur, FigureEnum figure) {
	this.couleur = couleur;
	this.figure = figure;
    }
 
    public CouleurEnum getCouleur() {
	return couleur;
    }
 
    public FigureEnum getFigure() {
	return figure;
    }
}

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
 
package com.thi.black;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
 
public class Board {
 
    private List<CarteEnum> cartes;
 
    private List<CarteEnum> melangerCartes(List<CarteEnum> cartes) {
 
	// On pourrait faire aussi cartes.size() mais ca sera toujours 52
	final List<CarteEnum> result = new ArrayList<CarteEnum>(52);
 
	final Random random = new Random();
 
	// idem 52 est une constante
	for (int i = 52; i <= 0; i--) {
	    final int position = random.nextInt(i);
	    // remove et ajoute en meme temps
	    result.add(cartes.remove(position));
	}
 
	return result;
    }
 
    private List<CarteEnum> melangerCartes(CarteEnum[] cartes) {
	return Arrays.asList(cartes);
    }
 
    public static void main(String[] args) {
 
	Board board = new Board();
 
	// Debut de partie, on melange
	board.cartes = board.melangerCartes(CarteEnum.values());
    }
 
}

Je te laisse écrire le reste avec ton algo.

[TheChicken]

Mon problème est que je n'ai pas 2 cartes distribuée pour chaque joueurs en début de partie.
Par exemple, pour une partie a un seul joueur, ce joueur aura 3 cartes en main en début de partie au lieu de deux, si j'ai 2 joueurs, chaque joueur a 5 cartes en main en début de partie, ce qui ne convient pas pour le bon déroulement du jeu.

[thierryler]

Je ne vois pas en quoi c'est incompatible avec les classes que je t'ai proposées.

Globalement, tu as une liste de joueurs. Tu passes cette liste à une méthode qui distribue les cartes initiales à chacun. En fonction du nombre de joueurs, tu changés le nombre de cartes à donner. Pour cela, il suffit d'utiliser la liste de cartes mélangées et de prendre la première à chaque fois.

[TheChicken]

Je n'ai pas eu encore le temps d'intégrer tes classes a mon code, j'ai juste précisé le problème que j'avais avec mon code actuel
Je voulais aussi comprendre pourquoi le code que j'ai fais ne fonctionne pas correctement.

[thierryler]

Tu veux deux carte par joueur ? C'est bien ça ? Mais en fait ton algo t'en donne plus ?

Je pense que c'est ta fonction de distribution des cartes qui déconne car elle ne ressemble à rien de précis.

J'aurais fais un truc du genre (non testé)

Code :

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

1
2
3
4
5
6
7
 
Private void distribuer(List<Joueur> joueurs) {
for(Joueur joueur : joueurs) {
joueur.donneCarte(cartes.remove(0));
Joueur.donneCarte(cartes.remove(0));
}
}

Ça va donner deux cartes à chacun de tes joueurs.