Projet Backjack Java

Version imprimable

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:

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:

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:

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:

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

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:

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:

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:

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:

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.

10/12/2011, 18h49
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.
10/12/2011, 19h16
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.
10/12/2011, 19h24
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 :P
Je voulais aussi comprendre pourquoi le code que j'ai fais ne fonctionne pas correctement.
10/12/2011, 19h44
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:

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.
10/12/2011, 20h12
TheChicken

Oui, j'ai besoin de distribuer deux cartes par joueurs (sauf pour le croupier) au début de la partie, et je n'en ais pas deux mais plus.
Cependant, avant d'utiliser un tableau de joueurs pour faire ma table de jeu, (quand je n'avais qu'un seul joueur donc) ma fonction de distribution fonctionnait correctement.
10/12/2011, 21h27
thierryler

En fait c'est ta fonction de distribution qui manipule d tableaux et des index dans tous les sens alors quil n'y a pas besoin. Tu devrais simplement utiliser des listes. Oublies les tableaux.

Essaie de faire des méthodes plus simples, qui ne font qu'une seule chose. À mon sens tu devrais refaire tout le programme en tinspirant des codes que je t'ai proposés. Avec les tableaux, tu tembrouilles... Par exemple quand tu fais joueur.main.lenght, ça veut dire que ta boucle déconne déjà.
11/12/2011, 11h40
TheChicken
- Je me demandais, pourquoi utiliser des enum pour les cartes ? Quel est l'interet ? Pourquoi preferer les Listes au tableaux ? Est-ce simplement plus pratique a utilise ?
-Pour figureEnum, par exemple

Code:

AS("A",11)

cela veux dire que l'as a une valeur de 11 point pour le jeu ? Est-il possible alors de metre deux valeurs pour une carte ? (en effet, au blackjack l'as peu prendre la valeur 11 ou 1)
- J'ai une autre petite question, est-ce que je peu comparer deux Joueurs en utilisant "==" ? (pour savoir si ce sont les mêmes ou non)

Edit la fonction pour mélanger de la classe board ne fonctionne pas, en effet toute les cartes sont dans l'ordre (A,R,D,V,10,...,2) une petite boucle while m'a permis de m'en apercevoir .
Code:

1 2 3 4 5 6 7 int i = 0; while(i<board.cartes.size()){ CarteEnum carteTemp = board.cartes.get(i); System.out.println(carteTemp.getFigure().getLabel()); i++; }
J'ai essayer de séparer les étapes mais cela ne marche pas.

Après recherche, je ne passe jamais dans la boucle for de private List<CarteEnum> melangerCartes(List<CarteEnum> cartes).

J'ai du faire une petite modification pour que je puisse passe dans List<CarteEnum> melangerCartes(List<CarteEnum> cartes) tout court !
Code:

1 2 3 private List<CarteEnum> melangerCartes(CarteEnum[] cartes) { return melangerCartes(Arrays.asList(cartes)); }
De plus, une petite faute de frappe, ce n'est pas

Code:

for (int i = 52; i <= 0; i--)

mais

Code:

for (int i = 52; i >= 0; i--)

Cependant même au premier passage dans la boucle j'ai une erreur : java.lang.UnsupportedOperationException qui vient de cette ligne la : result.add(cartes.remove(position));
Je pense que la fonction

Code:

remove (int position)

est la source du problème (j'ai eu la même erreur dans une autre fonction) .
Une idée de comment la résoudre ?

Edit 2 Je pense que le problème viens de

Code:

Arrays.asList(cartes);

qui crée une liste non modifiable, la solution pourrait être d'utiliser une liste doublement chaînée en utilisant

Code:

LinkedList (Arrays.asList(cartes));

a la place.

effectivement l'erreur venait de la. Voici la modification
Code:

1 2 3 4 private List<CarteEnum> melangerCartes(CarteEnum[] cartes) { List <CarteEnum> liste = new LinkedList (Arrays.asList(cartes)); return liste; }
Cependant, le paquet n'est toujours pas mélanger .

Edit voila, j'ai enfin réussi a mélanger correctement le paquet de carte !
Code:

1 2 3 4 private List<CarteEnum> melangerCartes(CarteEnum[] cartes) { List <CarteEnum> liste = new LinkedList (Arrays.asList(cartes)); return melangerCartes(liste); }

Bah oui, je te donne les idées générale. Je ne vais pas faire tout ton projet d'étude non plus. Les indications que je t'ai données vont te permettre de produire un logiciel plus facilement et de meilleure qualité.

Je ne connaissais pas la règle pour l'As. Du coup, faudra peut-être faire un héritage (avec surcharge) interne à l'enum pour l'As ou alors une petite verrue dans la partie qui calcule les points. Ca devrait être gérable.

Pour trier, il ne faut pas oublier d'utiliser le random....

J'ai un peu vérifié le code (l'autre était écrit sur ipad) et ça marche... mais il n'est pas au top. C'est juste fait à la va vite.
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 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) { // Si on a defini les 52 cartes, on peut direct utiliser une constante final int nb_carte = cartes.size(); final List<CarteEnum> result = new ArrayList<CarteEnum>(nb_carte); final Random random = new Random(); // idem 52 est une constante for (int i = nb_carte; 0 < i; 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) { List<CarteEnum> liste = new ArrayList<CarteEnum>(); for (CarteEnum c : cartes) { liste.add(c); } return melangerCartes(liste); } public static void main(String[] args) { Board board = new Board(); CarteEnum[] cartesTriees = CarteEnum.values(); for (CarteEnum c : cartesTriees) { System.out.println(c.getFigure().getLabel() + " " + c.getCouleur()); } // Debut de partie, on melange board.cartes = board.melangerCartes(cartesTriees); System.out.println("************"); for (CarteEnum c : board.cartes) { System.out.println(c.getFigure().getLabel() + " " + c.getCouleur()); } } }
Sinon, on n'utilise plus les tableaux depuis java 5, sauf quand on ne peut pas faire autrement. Les listes typées sont plus souples.

Quant aux enum, bah dans la mesure où tes cartes sont des constantes...

11/12/2011, 21h34
TheChicken

J'ai réussi a complètement intégrer les modification a mon code et tout marche presque correctement, j'ai encore un petit bug due a une récursivité je pense, je vais chercher comment le résoudre.