Déplacer un pion en java

**peggy67** · 17/05/2017, 16h05

Bonjour,

Mon poste n'est peut être pas dans la bonne catégorie, je tiens à m'en excuser d'avance.

Dans le cadre des mes études en école d'ingénieurs, on doit réaliser un jeu. Avec mon équipe, nous avons décidé de réaliser un jeu des incollables. Pour ceux qui ne connaissent pas, le principe est simple : on a un plateau de jeu, un dé et des questions. Lorsque l'on a juste on peu rejouer.
J'ai réussi à afficher mon plateau de jeu, mais j'arrive pas à faire avancer mon pion comme je le veux. Voici mon programme :

ma première classe :

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
package test;
 
 
import javax.swing.JFrame;
 
public class Fenetre extends JFrame{
  private Panneau pan = new Panneau();
 
  public Fenetre(int size1, int size2){        
    this.setTitle("Animation");
    this.setSize(size1, size2);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
    this.setContentPane(pan);
    this.setVisible(true);
 
  }
 
 
}

Ma deuxième classe :

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
package test;
 
 
 
public class Main {
	public static void main(String[] args){
		Fenetre test = new Fenetre(900,700);
 
 
		Panneau joueur1 = new Panneau();
		Panneau joueur2 = new Panneau();
		int posX1 = 90;
		int posY1 = 70;
		int posX2 = 90;
		int posY2 = 70;
		int de = 0;
	    de = 1 + (int)(Math.random() * 6 ); 
	    joueur1.avancement(posX1, posY1, de);
		joueur2.avancement(posX2, posY2, de);
 
	}
 
}

Ma dernière classe :

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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
package test;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.io.File;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
  public int posX1 = 90;
  public int posY1 = 70;
  public int posX2 = 90;
  public int posY2 = 70;
 
  public void paintComponent(Graphics g){
 
	//On choisit une couleur de fond pour le rectangle
	    g.setColor(Color.white);
	    //On le dessine de sorte qu'il occupe toute la surface
	    try {
	        Image img = ImageIO.read(new File("Plateau-jeu.PNG"));
	        //g.drawImage(img, 0, 0, this);
	        //Pour une image de fond
	        g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
	      } catch (IOException e) {
	        e.printStackTrace();
	      }
	    //On redéfinit une couleur pour le rond
	    //g.setColor(Color.red);
	    //On le dessine aux coordonnées souhaitées
	    //g.fillOval(posX, posY, 50, 50);
	    g.setColor(Color.blue);	    
	    g.fillOval(posX1, posY1, 50, 50);
	    //g.setColor(Color.red);
	    //g.fillOval(posX2, posY2, 50, 50);
 
 
	    int de = 0;
	    de = 1 + (int)(Math.random() * 6 ); 
	    g.setColor(Color.green);
	    g.fillOval(90+70*de, 70, 50, 50);
 
	       g.setColor(Color.red); 
		   g.drawString("Résultat du dé",620,50);
	 	   if (de == 1 ){ 
		     System.out.println( "vous avez obtenu un 1"); 
		     try {
		         Image img = ImageIO.read(new File("dé1.PNG"));
		         g.drawImage(img, 650, 0, this);
		         //Pour une image de fond
		         //g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
		       } catch (IOException e) {
		         e.printStackTrace();
		       }}
		    if (de == 2 ){ 
			     System.out.println( "vous avez obtenu un 2"); 
			     try {
			         Image img = ImageIO.read(new File("dé2.PNG"));
			         g.drawImage(img, 650, 0, this);
			         //Pour une image de fond
			         //g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
			       } catch (IOException e) {
			         e.printStackTrace();
			       }}
		    if (de == 3 ){ 
			     System.out.println( "vous avez obtenu un 3"); 
			     try {
			         Image img = ImageIO.read(new File("dé3.PNG"));
			         g.drawImage(img, 650, 0, this);
			         //Pour une image de fond
			         //g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
			       } catch (IOException e) {
			         e.printStackTrace();
			       }}
		    if (de == 4 ){ 
			     System.out.println( "vous avez obtenu un 4"); 
			     try {
			         Image img = ImageIO.read(new File("dé4.PNG"));
			         g.drawImage(img, 650, 0, this);
			         //Pour une image de fond
			         //g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
			       } catch (IOException e) {
			         e.printStackTrace();
			       }}
		    if (de == 5 ){ 
			     System.out.println( "vous avez obtenu un 5"); 
			     try {
			         Image img = ImageIO.read(new File("dé5.PNG"));
			         g.drawImage(img, 650, 0, this);
			         //Pour une image de fond
			         //g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
			       } catch (IOException e) {
			         e.printStackTrace();
			       }}
		    if (de == 6 ){ 
			     System.out.println( "vous avez obtenu un 6"); 
			     try {
			         Image img = ImageIO.read(new File("dé6.PNG"));
			         g.drawImage(img, 650, 0, this);
			         //Pour une image de fond
			         //g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
			       } catch (IOException e) {
			         e.printStackTrace();
			       }}
 
 
  }
 
  public int getPosX1() {
    return posX1;
 
  }
 
  public void setPosX1(int posX1) {
    this.posX1 = posX1;
  }
 
  public int getPosY1() {
    return posY1;
  }
 
  public void setPosY1(int posY1) {
    this.posY1 = posY1;
  }  
  public int getPosX2() {
	    return posX2;
 
	  }
 
	  public void setPosX2(int posX2) {
	    this.posX2 = posX2;
	  }
 
	  public int getPosY2() {
	    return posY2;
	  }
 
	  public void setPosY2(int posY2) {
	    this.posY2 = posY2;
	  }  
 
  public void avancement1 (int x, int y, int de){
 
 
	  while (de>0){
	  if (x==160 && y==520){
		  de = 0;
	  }
	  if (y==520){
		  x=x-70;
	  }
	  if (x==720 && y==445 || x==720 && y==370){
		  y=y+75;
	  }
	  if (y==370){
		  x=x+70;
	  }
	  if (x==90 && y==295 || x==90 && y==220){
		  y=y+75;
	  }
	  if (y==220){
		  x=x-70;
	  }
	  if (x==720 && y==145 || x==720 && y==70){
		  y=y+75;
	  }
	  if (y==70){
		  x=x+70;
	  }
	  // case Oups
	  if (x==440 && y==520 || x==230 && y==70){
		  x=x+70;
	  }
	  if (x==440 && y==370 ||x==650 && y==220){
		x=x-70;  
	  }
	  //case Stop
	  if (x==440 && y==520 || x==230 && y==70 || x==440 && y==520 || x==230 && y==70){
		  de=0;
	  }
	  de=de-1;
	  }
 
	  setPosX1(x);
      setPosY1(y);
      repaint();
 
      }
}

Merci pour votre attention et bonne fin de journée à vous !

**joel.drigo** · 17/05/2017, 18h40

Salut,

Déjà il faudrait que tu nous dises comment tu voudrais qu'il se déplace ce pion ? Progressivement de pixels en pixels, case par case, tout d'un coup, (peu importe qu'il se déplace de une ou 10 cases).

Ensuite, il y a plusieurs soucis dans ton programme :

Il y a un tirage de dé dans la méthode de redessin du composant. A chaque fois qu'on redessine, on tire un nouveau dé et on l'affiche. Or tu ne contrôies pas quand le composant va se redessiner et même si c'était le cas, ce sera gênant après un tirage d'afficher ce tirage. En plus la variable "de" est locale à paintComponent, donc inutilisable en dehors, donc inutilsable pour faire bouger un pion
secondement, dans ton code, dans la méthode main tu fais un tirage de dé, et tu appelles une méthode qui fait un déplacement de pion par rapport à la valeur de ce dé (à priori, parce que je n'ai pas décodé tous tes tests pour voir si ça faisait quelque chose). Et, ensuite plus rien. Je suppose que lorsqu'on joue, on ne fait pas qu'un seul tirage, n'est-ce-pas ?

Il faut tout d'abord que tu sépares la notion de tirage de dés du rendu lui-même. Voici un 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
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
 
public class DicePanel extends JPanel {
 
	private int dice=0; // 0 signifie aucun dé tiré
 
	public void rollDice() {
		dice=ThreadLocalRandom.current().nextInt(1, 6); // on tire un dé
		repaint(); // on rafraichît l'affichage
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		int ddice = dice;
		if ( ddice>0 ) {
			g.setColor(Color.ORANGE);
			int width = getWidth()/3; // on dessine le dé sur le tiers de la fenêtre
			int height = getHeight()/3;
			if ( width>height ) {
				width = height;
			}
			else {
				height = width;
			}
			// on dessine le dé centré
			int x = (getWidth()-width)/2;
			int y = (getHeight()-height)/2;
			g.fillRoundRect(x, y, width, height, width/10, width/10);
 
			// dessin des points
			int ray = width/10;
			g.setColor(Color.BLACK);
			if ( ddice==1 || ddice==5 || ddice==3 ) {
				// point au centre
				g.fillOval(getWidth()/2 - ray, getHeight()/2 - ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à gauche
				g.fillOval(x+ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à droite
				g.fillOval(x+width-3*ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à gauche
				g.fillOval(x+ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à droite
				g.fillOval(x+width-3*ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==6 ) {
				// point à gauche et à droite
				g.fillOval(x+ray, getHeight()/2 - ray, ray*2, ray*2);
				g.fillOval(x+width-3*ray, getHeight()/2 - ray, ray*2, ray*2);
			}
		}
	}
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DicePanel dicePanel = new DicePanel();
		frame.add(dicePanel);
 
 
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
		frame.add(buttonPanel, BorderLayout.SOUTH);
		JButton button = new JButton("Tirer un dé");
		buttonPanel.add(button);
		button.addActionListener(e-> dicePanel.rollDice());
 
 
		frame.setSize(300, 300);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
 
	}
 
}

A chaque fois qu'on appuis sur le bouton on tire un nouveau dé et on rafraichit l'affichage. Mais on peut redessiner le composant autant de fois qu'on veut, ça ne change pas la valeur du tirage ni rien d'autre qui ne soit directement lié à l'affichage (ça peut changer la taille du composant affiché par exemple si on change la taille de la fenêtre).

Maintenant pour faire un déplacement, on va enchainer sur la modification des x et y du pions.

Ici dans cet exemple, je fais juste un déplacement unique d'un coup (j'ai simplifié en faisant un chemin de cases qui tourne autour du panel). Pour éviter d'avoir des tests comme toi dans tous les sens et en dur, j'ai préféré gérer un mouvement sur un plateau qui ne soit pas dépendant de l'aspect graphique. J'ai simplifié en disant que je n'avais qu'un chemin possible infini qui se répète toutes les 12 cases. Et j'ai géré l'aspect dessin à part, en disant que ce chemin tournait (en carré, sur les cases bordures d'une grille 4x4) autour de mon panel.

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
public class DicePanel extends JPanel {
 
	private int dice=0; // 0 signifie aucun dé tiré 
	private int pionpos = 0;
	private int pionx = 0;
	private int piony = 0;
 
	public void rollDice() {
		dice=ThreadLocalRandom.current().nextInt(1, 6); // on tire un dé
		movePiece();
		repaint(); // on rafraichît l'affichage
	}
 
	private void movePiece() {
		pionpos += dice;
		// on convertit la position du pion en coordonnée de cases, parce que c'est bien plus simple à gérer que des coordonnées en pixels
 
               // la grille 4x4 de cases est comme cela
 
               // 0 11 10 9
               // 1 x x 8
               // 2 x x 7
               // 3 4 5 6
 
               // les x sont des cases de la grille où le chemin ne passe pas
               // le chemin va de 0 à 11 = 12 cases,
 
		int xpion = pionpos%12; // permet de ramener un chemin infini à un chemin de 12 cases
 
                // on convertit le xpion (coordonnée linéaire sur un chemin de 12 cases) vers pionx et piony, coordonnées cartésiennes dans la grille 4x4 si dessus
		if ( xpion>=0 && xpion<4 ) {
			pionx = 0;
		}
		else if ( xpion<7 ) {
			pionx = xpion-3;
		}
		else if ( xpion<10 ) {
			pionx = 3;
		}
		else {
			pionx = 12-xpion;
		}
		if ( xpion>=0 && xpion<4 ) {
			piony=xpion;
		}
		else if ( xpion<7 ) {
			piony= 3;
		}
		else if ( xpion<10 ) {
			piony=9-xpion;
		}
		else {
			piony = 0;
		}
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
 
		int width = getWidth()/4; // on dessine le dé et le pion sur le quart de la fenêtre (grille 4x4 d'où le "quart"
		int height = getHeight()/4;
		if ( width>height ) {
			width = height;
		}
		else {
			height = width;
		}
 
		// dessin des cases (chemin de 12 cases tournant autour de la grille 4x4
		g.setColor(Color.YELLOW);
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				if ( i>0 && i<3 && j>0 && j<3 ) {
					continue; // on dessine un chemin que sur les bords
				}
				g.fillRect(i*getWidth()/4 + 4 , j*getHeight()/4 + 4, getWidth()/4 - 8 , getHeight()/4 - 8);
			}
		}
 
		// dessin du pion (en faisant la conversion des x,y de cases en x,y de pixels ici
		g.setColor(Color.BLUE);
		g.fillOval(pionx*getWidth()/4 + (getWidth()/4-width)/2 , piony*getHeight()/4 + (getHeight()/4-height)/2, width, height);  
 
		int ddice = dice;
		if ( ddice>0 ) { // s'il y a un dé tiré on le dessine
			g.setColor(Color.ORANGE);
 
			// on dessine le dé centré
			int x = (getWidth()-width)/2;
			int y = (getHeight()-height)/2;
			g.fillRoundRect(x, y, width, height, width/10, width/10);
 
			// dessin des points
			int ray = width/10;
			g.setColor(Color.BLACK);
			if ( ddice==1 || ddice==5 || ddice==3 ) {
				// point au centre
				g.fillOval(getWidth()/2 - ray, getHeight()/2 - ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à gauche
				g.fillOval(x+ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à droite
				g.fillOval(x+width-3*ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à gauche
				g.fillOval(x+ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à droite
				g.fillOval(x+width-3*ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==6 ) {
				// point à gauche et à droite
				g.fillOval(x+ray, getHeight()/2 - ray, ray*2, ray*2);
				g.fillOval(x+width-3*ray, getHeight()/2 - ray, ray*2, ray*2);
			}
		}
	}
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DicePanel dicePanel = new DicePanel();
		frame.add(dicePanel);
 
 
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
		frame.add(buttonPanel, BorderLayout.SOUTH);
		JButton button = new JButton("Tirer un dé");
		buttonPanel.add(button);
		button.addActionListener(e-> dicePanel.rollDice());
 
 
		frame.setSize(300, 300);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
 
	}
 
}

Tu vois que paintComponent ne fait que toujours que le rendu. On fait varier la valeur du dé et la position dans le jeu par ailleurs, et on rafraichit. Je fais juste une conversion x de cases linéraires en x,y de cases plateau pour éviter d'avoir à gérer un déplacement directement dans les cases plateau (ça allait plus vite pour faire l'exemple).

Mais ici le déplacement est direct et instantané. Si on veut faire un déplacement case par case, il va falloit utiliser un timer pour éviter de figer l'UI. Par 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
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
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ThreadLocalRandom;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel; 
 
public class DicePanel extends JPanel {
 
	private int dice=0; // 0 signifie aucun dé tiré 
	private volatile int move=0;
	private int pionpos = 0;
	private int pionx = 0;
	private int piony = 0;
	private Timer timer;  
 
	public DicePanel() {
		timer = new Timer(); // j'utilise un timer util mais j'aurais pu utiliser un timer swing (chacun a ses avantages et inconvénient, ici j'ai choisi la simplicité, mais un timer swing aurait eu l'avantage de pouvoir être démarré et arrêté au besoin
		timer.schedule(new TimerTask() {
 
			@Override
			public void run() { 
				if ( move>0 ) { // s'il reste des déplacements à faire
					move--; // on consomme le prochain déplacement
					movePiece(); // on le fait
					repaint(); // on rafraichit l'affichage
				}
			}
 
		}, 500,500); // on se déplace d'une case toute les 1/2 secondes (500ms donc) 
	}
 
	public void rollDice() {
		dice=ThreadLocalRandom.current().nextInt(1, 6); // on tire un dé
		repaint(); // on rafraichît l'affichage (pour voir le nouveau tirage)
		move+=dice; // on utilise la variable move pour comptabiliser le nombre de cases qu'on doit parcourir
 
	} 
 
	private void movePiece() {
		pionpos ++; // on ne se déplace plus que d'une case à la fois (la méthode movePiece va être appelée par le timer autant de fois que nécessaire (la valeur de la variable move)
		// on convertit la position du pion en coordonnée de cases, parce que c'est bien plus simple à gérer que des coordonnées en pixels
		int xpion = pionpos%12;
		if ( xpion>=0 && xpion<4 ) {
			pionx = 0;
		}
		else if ( xpion<7 ) {
			pionx = xpion-3;
		}
		else if ( xpion<10 ) {
			pionx = 3;
		}
		else {
			pionx = 12-xpion;
		}
		if ( xpion>=0 && xpion<4 ) {
			piony=xpion;
		}
		else if ( xpion<7 ) {
			piony= 3;
		}
		else if ( xpion<10 ) {
			piony=9-xpion;
		}
		else {
			piony = 0;
		}
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
 
		int width = getWidth()/4; // on dessine le dé et le pion sur le quart de la fenêtre
		int height = getHeight()/4;
		if ( width>height ) {
			width = height;
		}
		else {
			height = width;
		}
 
		// dessin des cases
		g.setColor(Color.YELLOW);
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				if ( i>0 && i<3 && j>0 && j<3 ) {
					continue; // on dessine un chemin que à l'extérieur
				}
				g.fillRect(i*getWidth()/4 + 4 , j*getHeight()/4 + 4, getWidth()/4 - 8 , getHeight()/4 - 8);
			}
		}
 
		// dessin du pion (en faisant la conversion des x,y de cases en x,y de pixels ici
		g.setColor(Color.BLUE);
		g.fillOval(pionx*getWidth()/4 + (getWidth()/4-width)/2 , piony*getHeight()/4 + (getHeight()/4-height)/2, width, height);  
 
		int ddice = dice;
		if ( ddice>0 ) {
			g.setColor(Color.ORANGE);
 
			// on dessine le dé centré
			int x = (getWidth()-width)/2;
			int y = (getHeight()-height)/2;
			g.fillRoundRect(x, y, width, height, width/10, width/10);
 
			// dessin des points
			int ray = width/10;
			g.setColor(Color.BLACK);
			if ( ddice==1 || ddice==5 || ddice==3 ) {
				// point au centre
				g.fillOval(getWidth()/2 - ray, getHeight()/2 - ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à gauche
				g.fillOval(x+ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à droite
				g.fillOval(x+width-3*ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à gauche
				g.fillOval(x+ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à droite
				g.fillOval(x+width-3*ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==6 ) {
				// point à gauche et à droite
				g.fillOval(x+ray, getHeight()/2 - ray, ray*2, ray*2);
				g.fillOval(x+width-3*ray, getHeight()/2 - ray, ray*2, ray*2);
			}
		}
	}
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DicePanel dicePanel = new DicePanel();
		frame.add(dicePanel);
 
 
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
		frame.add(buttonPanel, BorderLayout.SOUTH);
		JButton button = new JButton("Tirer un dé");
		buttonPanel.add(button);
		button.addActionListener(e-> dicePanel.rollDice());
 
 
		frame.setSize(300, 300);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
 
	}
 
}

Tu peux voir que je n'ai rien changé dans paintComponent : je n'ai modifié que le déplacement et pas le rendu, donc pas de changement dans paintComponent.
Ensuite on pourrait faire un déplacement par pixels, animé donc, en interpolant les positions en pixels entre cases par rapport au temps, et en adaptant le timer pour. C'est nettement plus compliqué.

**peggy67** · 17/05/2017, 19h36

Merci beaucoup pour la réponse aussi rapide.

Ca m'aide beaucoup.
Je vais essayer d'adapter ca dans mon cas.
Je reviendrai surement en cas de besoins si vous le permettez

Encore merci

**joel.drigo** · 17/05/2017, 20h48

N'hésite pas si tu as besoins d'éclaircissements. J'ai ajouté par ailleurs des commentaires de précision dans mon post.

**peggy67** · 21/05/2017, 15h15

Rebonjour,

Navrée de vous déranger le weekend mais j'ai de nouveau un soucis. Je voudrai mettre en place un système pour deux joueurs. Pour que deux joueurs puissent jouer l'un après l'autre en utilisant la méthode que vous m'aviez donné pour déplacer les pions.
Le principe est simple, j'ai créé deux boutons faisant déplacer chacun deux pions différents. Cela marche. Cependant j'aimerai à présent que le bouton de déplacement s'affiche que lorsque c'est au tour du joueur en question de jouer.
J'ai essayé de mettre en place une méthode if mais en faisant les tests je remarque que la valeur boolean implémentée n'est pas prise en compte. Du coup mon programme ne marche pas. Je me demandais si vous pouviez m'aider sur ce point.

Voilà le programme :

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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
package developpez.net2.copy.copy;
 
 
import java.awt.Color;
 
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;
import java.io.File;
import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ThreadLocalRandom;
 
import javax.imageio.ImageIO;
 
import javax.swing.JPanel; 
 
public class DicePanel extends JPanel {
 
	private int dice=0; // 0 no dice has been rolled 
	private volatile int move1=0;
	private volatile int move2=0;
	private int pionpos1 = 0;
	private int pionx1 = 0;
	private int piony1 = 0;
	private int pionpos2 = 0;
	private int pionx2 = 0;
	private int piony2 = 0;
	private Timer timer;  
 
	public DicePanel() {
		timer = new Timer();
		timer.schedule(new TimerTask() {
 
			@Override
			public void run() { 
				if ( move1>0 ) { // if there still some movements to do 
					move1--;
					movePiecePlayer1(); // we do it
					repaint(); // we refresh the display
				}
				if ( move2>0 ) { // if there still some movements to do
					move2--;
					movePiecePlayer2(); // we do it
					repaint(); // we refresh the display
			}
 
		}}, 500,500); // we get forward every 1/2 seconds 
	}
 
	public void rollDice1() {
		dice=ThreadLocalRandom.current().nextInt(1, 6); //we roll the dice1
		repaint(); // we refresh the display
		move1+=dice; 
 
	} 
 
	public void rollDice2() {
		dice=ThreadLocalRandom.current().nextInt(1, 6); // we roll the dice2
		repaint(); // we refresh the display
		move2+=dice; 
	}
 
	private void movePiecePlayer1() {
		pionpos1 ++; // we get from one box to another (1 by 1)
		// we convert the position of the pawn in box coordinates (easer than pixels coordinates)
		int xpion1 = pionpos1%1000;
		if ( xpion1>=0 && xpion1<10) { // positionX for the first line
			pionx1 = xpion1+1;
		}
		else if ( xpion1<12 ) { // positionX for the first column 
			pionx1 = 10;
		}
		else if ( xpion1<21 ) { // positionX for the second line
			pionx1 = 21-xpion1;
		}
		else if (xpion1<23){ // positionX for the second column
			pionx1=1;
		}
		else if (xpion1<32){ // positionX for the third line
			pionx1=xpion1-21;
		}
		else if (xpion1<34){ // positionX for the third column
			pionx1=10;
		}
		else if (xpion1<41) { // positionX for the last line
			pionx1 = 43-xpion1;
		}
		else {
			pionx1 =1; // last box 
		}
		if ( xpion1>=0 && xpion1<10 ) { // positionY for the first line
			piony1=1;
		}
		else if ( xpion1<12 ) { // positionY for the first column
			piony1= xpion1-8;
		}
		else if ( xpion1<21 ) { // positionY for the second line
			piony1=3;
		}
		else if (xpion1<23){ // positionY for the second column
			piony1=xpion1-17;
		}
		else if (xpion1<32){ // positionY for the third line
			piony1=5;
		}
		else if (xpion1<34){ // positionY for the third column
			piony1=xpion1-26;
		}
		else if (xpion1<41){ // positionY for the last line
			piony1 = 7;
		}
		else {   // last box 
			piony1=7;
		}
	}
 
	private void movePiecePlayer2() { // same as for the player 1 but for the player2
		pionpos2 ++; 
		int xpion2 = pionpos2%1000;
		if ( xpion2>=0 && xpion2<10) {
			pionx2 = xpion2+1;
		}
		else if ( xpion2<12 ) {
			pionx2 = 10;
		}
		else if ( xpion2<21 ) {
			pionx2 = 21-xpion2;
		}
		else if (xpion2<23){
			pionx2=1;
		}
		else if (xpion2<32){
			pionx2=xpion2-21;
		}
		else if (xpion2<34){
			pionx2=10;
		}
		else if (xpion2<41) {
			pionx2 = 43-xpion2;
		}
		else {
			pionx2 =1;
		}
		if ( xpion2>=0 && xpion2<10 ) {
			piony2=1;
		}
		else if ( xpion2<12 ) {
			piony2= xpion2-8;
		}
		else if ( xpion2<21 ) {
			piony2=3;
		}
		else if (xpion2<23){
			piony2=xpion2-17;
		}
		else if (xpion2<32){
			piony2=5;
		}
		else if (xpion2<34){
			piony2=xpion2-26;
		}
		else if (xpion2<41){
			piony2 = 7;
		}
		else {
			piony2=7;
		}
	}
	@Override
	protected void paintComponent(Graphics g) {
 
		super.paintComponent(g);
 
		int width = getWidth()/4; // we draw the dice on the 1/4 of the window
		int height = getHeight()/4;
		if ( width>height ) {
			width = height;
		}
		else {
			height = width;
		}
 
		// draw the game board
		try {
	        Image img = ImageIO.read(new File("Plateau-de-jeu.PNG"));
 
	        g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
	      } catch (IOException e) {
	        e.printStackTrace();
	      }
		// draw of the pawns
		g.setColor(Color.BLUE);
		g.fillOval(pionx1*((getWidth())/12), piony1*(getHeight()/9), width/2, height/2); 
 
		g.setColor(Color.RED);
		g.fillOval(pionx2*((getWidth())/12), piony2*(getHeight()/9), width/2, height/2); 
 
		// message for the winner
		if (pionx1==1 && piony1==7 || pionx2==1 && piony2==7){
			Font font1 = new Font("Courier", Font.BOLD, 50);
		    g.setFont(font1);           
		    g.setColor(Color.white); 
			g.drawString("The party is over",150,180);
			if (pionx1==1 && piony1==7){
				Font font2 = new Font("Courier", Font.BOLD, 50);
				g.setFont(font2);           
			    g.setColor(Color.white); 
				g.drawString("The player 1 is the winner",30,450);
			}
			if (pionx2==1 && piony2==7){
				Font font2 = new Font("Courier", Font.BOLD, 50);
			    g.setFont(font2);           
			    g.setColor(Color.white); 
				g.drawString("The player 2 is the winner",30,450);
			}
 
		}
 
		// display of the dice
		int ddice = dice;
		if ( ddice>0 ) {
			g.setColor(Color.WHITE);
 
			// on dessine le dé centré
			int x = (getWidth()-width)/2;
			int y = (getHeight()-height)/2;
			g.fillRoundRect(x, y, width, height, width/10, width/10);
 
			// dessin des points
			int ray = width/10;
			g.setColor(Color.BLACK);
			if ( ddice==1 || ddice==5 || ddice==3 ) {
				// point au centre
				g.fillOval(getWidth()/2 - ray, getHeight()/2 - ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à gauche
				g.fillOval(x+ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à droite
				g.fillOval(x+width-3*ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à gauche
				g.fillOval(x+ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à droite
				g.fillOval(x+width-3*ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==6 ) {
				// point à gauche et à droite
				g.fillOval(x+ray, getHeight()/2 - ray, ray*2, ray*2);
				g.fillOval(x+width-3*ray, getHeight()/2 - ray, ray*2, ray*2);
			}
		}
 
	}
 
 
 
}

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
package developpez.net2.copy.copy;
 
import java.awt.BorderLayout;
import java.awt.FlowLayout;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class Game {
 
	public static void main(String[] args){
		JFrame frame = new JFrame("GAME OF UNBEATABLE");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DicePanel dicePanel = new DicePanel();
		frame.add(dicePanel);	
 
 
		//dimension of the window
		frame.setSize(900, 700);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
		boolean TourPlayer1=true;
		if (TourPlayer1=true){
			//button for the dice of the player1
			JPanel button1Panel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
			frame.add(button1Panel, BorderLayout.SOUTH);
			JButton button1 = new JButton("Player 1, Roll the dice"); 
			button1Panel.add(button1);
			button1.addActionListener(e-> dicePanel.rollDice1());
		}
		else {
			//button for the dice of the player2
			JPanel button2Panel = new JPanel(new FlowLayout(FlowLayout.LEFT));
			frame.add(button2Panel, BorderLayout.NORTH);
			JButton button2 = new JButton("Player 2, Roll the dice"); 
			button2Panel.add(button2);
			button2.addActionListener(e-> dicePanel.rollDice2());
		}
 
 
	}
 
 
 
 
 
 
}

Merci pour votre attention

**joel.drigo** · 21/05/2017, 19h02

Tu ne peux pas procéder comme suit, parce que ce code s'exécute une seule fois, au démarrage du programme.

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
boolean TourPlayer1=true;
		if (TourPlayer1=true){
			//button for the dice of the player1
			JPanel button1Panel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
			frame.add(button1Panel, BorderLayout.SOUTH);
			JButton button1 = new JButton("Player 1, Roll the dice"); 
			button1Panel.add(button1);
			button1.addActionListener(e-> dicePanel.rollDice1());
		}
		else {
			//button for the dice of the player2
			JPanel button2Panel = new JPanel(new FlowLayout(FlowLayout.LEFT));
			frame.add(button2Panel, BorderLayout.NORTH);
			JButton button2 = new JButton("Player 2, Roll the dice"); 
			button2Panel.add(button2);
			button2.addActionListener(e-> dicePanel.rollDice2());
		}

Tu as 2 solutions (entre autres). Un seul bouton. Ou deux boutons, et utiliser setEnabled() pour activer l'un ou l'autre bouton. Pour gérer plus facilement plusieurs pions, il vaudrait mieux descendre les coordonnées d'un pion dans une classe dédiée.

Voici un exemple. J'ai mis tous les pions dans un tableau, donc il suffit de parcourir le tableau pour dessiner tous les pions. Un tableau me permet de gérer autant de joueurs que je veux, plutôt que de gérer le cas particulier de 2 joueurs.
J'ai mis 2 boutons : un bouton pour lancer le dé et faire avancer le joueur courant en conséquence. Un autre pour changer de joueur (il n'est pas obligatoire si on ne veut pas permettre aux joueurs de passer leur tour).
Bien sûr on peut automatiser le changement de joueur. Dans le bouton de tirage de dé, j'ai mis un code qui passe au joueur suivant si le tirage n'est pas 6. On peut adapter à n'importe quelle règle de jeu facilement.

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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
public class DicePanel extends JPanel {
 
	private static final Color[] PIECE_COLORS = {Color.BLUE, Color.BLACK, Color.RED, Color.GREEN};
 
	private int dice=0; // 0 signifie aucun dé tiré 
	private Piece[] players; // pions
	private int player = 0; // le joueur 1 commence
 
	public DicePanel(int nbPlayers) {
		if (nbPlayers<=0 ) {
			throw new IllegalArgumentException("Le ombre de joueurs doit être au moins 1");
		}
		if (nbPlayers>PIECE_COLORS.length ) {
			throw new IllegalArgumentException("Le nombre de maximum de joueurs est "+PIECE_COLORS.length);
		}
		players=new Piece[nbPlayers];
		for(int i=0; i<players.length; i++) {
			players[i]=new Piece();;
		}
	}
 
	public void rollDice() {
		dice=ThreadLocalRandom.current().nextInt(1, 7); // on tire un dé entre 1 et 6
		players[player].movePiece(dice);
		repaint(); // on rafraichît l'affichage
	}
 
	public int getDice() {
		return dice;
	}
 
	public void nextPlayer() {
		player++;
		if  (player>=players.length ) {
			player=0;
		}
	}
 
	public int getCurrentPlayer() {
		return player;
	}
 
	public Color getCurrentPlayerColor() {
		return PIECE_COLORS[player];
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
 
		int width = getWidth()/4; // on dessine le dé et le pion sur le quart de la fenêtre (grille 4x4 d'où le "quart"
		int height = getHeight()/4;
		if ( width>height ) {
			width = height;
		}
		else {
			height = width;
		}
 
		// dessin des cases (chemin de 12 cases tournant autour de la grille 4x4
		g.setColor(Color.YELLOW);
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				if ( i>0 && i<3 && j>0 && j<3 ) {
					continue; // on dessine un chemin que sur les bords
				}
				g.fillRect(i*getWidth()/4 + 4 , j*getHeight()/4 + 4, getWidth()/4 - 8 , getHeight()/4 - 8);
			}
		}
 
		// dessin des pions (en faisant la conversion des x,y de cases en x,y de pixels ici
		for(int i=0; i<players.length; i++) {
			Piece player = players[i];
			g.setColor(PIECE_COLORS[i]);
			g.fillOval(player.pionx*getWidth()/4 + (getWidth()/4-width)/2 , player.piony*getHeight()/4 + (getHeight()/4-height)/2, width, height);  
		}
 
		int ddice = dice;
		if ( ddice>0 ) { // s'il y a un dé tiré on le dessine
			g.setColor(Color.ORANGE);
 
			// on dessine le dé centré
			int x = (getWidth()-width)/2;
			int y = (getHeight()-height)/2;
			g.fillRoundRect(x, y, width, height, width/10, width/10);
 
			// dessin des points
			int ray = width/10;
			g.setColor(Color.BLACK);
			if ( ddice==1 || ddice==5 || ddice==3 ) {
				// point au centre
				g.fillOval(getWidth()/2 - ray, getHeight()/2 - ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à gauche
				g.fillOval(x+ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à droite
				g.fillOval(x+width-3*ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à gauche
				g.fillOval(x+ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à droite
				g.fillOval(x+width-3*ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==6 ) {
				// point à gauche et à droite
				g.fillOval(x+ray, getHeight()/2 - ray, ray*2, ray*2);
				g.fillOval(x+width-3*ray, getHeight()/2 - ray, ray*2, ray*2);
			}
		}
	}
 
	private static class Piece {
		public int pionpos = 0;
		public int pionx = 0;
		public int piony = 0;
 
		private void movePiece(int dice) {
			pionpos += dice;
			// on convertit la position du pion en coordonnée de cases, parce que c'est bien plus simple à gérer que des coordonnées en pixels
 
	               // la grille 4x4 de cases est comme cela
 
	               // 0 11 10 9
	               // 1 x x 8
	               // 2 x x 7
	               // 3 4 5 6
 
	               // les x sont des cases de la grille où le chemin ne passe pas
	               // le chemin va de 0 à 11 = 12 cases,
 
			int xpion = pionpos%12; // permet de ramener un chemin infini à un chemin de 12 cases
 
	                // on convertit le xpion (coordonnée linéaire sur un chemin de 12 cases) vers pionx et piony, coordonnées cartésiennes dans la grille 4x4 si dessus
			if ( xpion>=0 && xpion<4 ) {
				pionx = 0;
			}
			else if ( xpion<7 ) {
				pionx = xpion-3;
			}
			else if ( xpion<10 ) {
				pionx = 3;
			}
			else {
				pionx = 12-xpion;
			}
			if ( xpion>=0 && xpion<4 ) {
				piony=xpion;
			}
			else if ( xpion<7 ) {
				piony= 3;
			}
			else if ( xpion<10 ) {
				piony=9-xpion;
			}
			else {
				piony = 0;
			}
		}
 
	}
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DicePanel dicePanel = new DicePanel(2);
		frame.add(dicePanel);
 
 
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
		frame.add(buttonPanel, BorderLayout.SOUTH);
		JLabel playerLabel = new JLabel();
		playerLabel.setOpaque(true); // pour que le label ait un fond
		playerLabel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
		playerLabel.setForeground(buttonPanel.getBackground());
		updatePlayerLabel(playerLabel, dicePanel);
		buttonPanel.add(playerLabel);
		JButton diceButton = new JButton("Tirer un dé");
		buttonPanel.add(diceButton);
		JButton playerButton = new JButton("Joueur suivant");
		buttonPanel.add(playerButton);
		diceButton.addActionListener(e-> {
			dicePanel.rollDice();
			if ( dicePanel.getDice()!=6 ) {
				playerButton.doClick();
			}
		});
		playerButton.addActionListener(e-> {
			dicePanel.nextPlayer();
			updatePlayerLabel(playerLabel,dicePanel);
		});
 
 
		frame.setSize(400, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
 
	}
 
	private static void updatePlayerLabel(JLabel playerLabel, DicePanel dicePanel) {
		playerLabel.setText("Joueur "+(dicePanel.getCurrentPlayer()+1)+" joue");
		playerLabel.setBackground(dicePanel.getCurrentPlayerColor());
	}
 
}

Cependant, tu pourras voir qu'il y un souci lorsque plusieurs pions sont sur la même case. Il faut éventuellement adapter le code. Il y a plein de solutions.

Les règles peuvent faire qu'on ne peut pas avoir 2 pions sur la même case. Dans ce cas, c'est au niveau du déplacement qu'il faut modifier le code pour que la case d'arrivée soit traitée en fonction.
On peut s'arranger pour que le joueur courant soit toujours affiché au-dessus des autres, mais ça ne permet pas de connaitre la position d'un autre joueurs sur la case.

On peut afficher plusieurs pions sur une même case. Le plus simple sera de modifier le code pour qu'on affiche plus les pions, mais les cases.

Par exemple, en faisant que chaque case est une petite grille, par 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
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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
public class DicePanel extends JPanel {
 
	private static final Color[] PIECE_COLORS = {Color.BLUE, Color.BLACK, Color.RED, Color.GREEN.darker()};
 
	private int dice=0; // 0 signifie aucun dé tiré 
	private Piece[] players; // pions
	private int player = 0; // le joueur 1 commence
 
	public DicePanel(int nbPlayers) {
		if (nbPlayers<=0 ) {
			throw new IllegalArgumentException("Le ombre de joueurs doit être au moins 1");
		}
		if (nbPlayers>PIECE_COLORS.length ) {
			throw new IllegalArgumentException("Le nombre de maximum de joueurs est "+PIECE_COLORS.length);
		}
		players=new Piece[nbPlayers];
		for(int i=0; i<players.length; i++) {
			players[i]=new Piece();;
		}
	}
 
	public static int getMaxPlayers() {
		return PIECE_COLORS.length;
	}
 
	public void rollDice() {
		dice=ThreadLocalRandom.current().nextInt(1, 7); // on tire un dé
		players[player].movePiece(dice);
		// on détermine l'ordre des joueurs
		Piece[] order = Arrays.stream(players).sorted(Comparator.comparing(Piece::getPosition).reversed()).toArray(Piece[]::new);
		int playerorder=1;
		for(int pieceOrder=0; pieceOrder<order.length; pieceOrder++) {
			if ( pieceOrder>0 && order[pieceOrder-1].pionpos!=order[pieceOrder].pionpos ) {
				playerorder++;
			}
			order[pieceOrder].order=playerorder;
		}
		repaint(); // on rafraichît l'affichage
	}
 
	public int getDice() {
		return dice;
	}
 
	public void nextPlayer() {
		player++;
		if  (player>=players.length ) {
			player=0;
		}
	}
 
	public int getCurrentPlayer() {
		return player;
	}
 
	public Color getCurrentPlayerColor() {
		return PIECE_COLORS[player];
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
 
		int width = getWidth()/4; // on dessine le dé et le pion sur le quart de la fenêtre (grille 4x4 d'où le "quart"
		int height = getHeight()/4;
		if ( width>height ) {
			width = height;
		}
		else {
			height = width;
		}
 
		// dessin des cases (chemin de 12 cases tournant autour de la grille 4x4
		g.setColor(Color.YELLOW);
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				if ( i>0 && i<3 && j>0 && j<3 ) {
					continue; // on dessine un chemin que sur les bords
				}
				g.fillRect(i*getWidth()/4 + 4 , j*getHeight()/4 + 4, getWidth()/4 - 8 , getHeight()/4 - 8);
			}
		}
 
		// dessin des pions (en faisant la conversion des x,y de cases en x,y de pixels ici
 
		// on détermine comment on va disposer les pions
		int squaregridx=(int)Math.ceil(Math.sqrt(players.length));
		int squaregridy=players.length/squaregridx;
 
		// on détermine la position de tous les pions
		if ( players.length==1 ) {
			g.setColor(PIECE_COLORS[0]);
			int x=players[0].pionx*getWidth()/4 + (getWidth()/4-width)/2;
			int y=players[0].piony*getHeight()/4 + (getHeight()/4-height)/2;
			g.fillOval( x, y, width, height);  
		}
		else {
			FontMetrics fm = g.getFontMetrics();
			int[] cases = new int[12]; // 12 cases
			for(int i=0; i<players.length; i++) {
				Piece player = players[i];
				int pionpos=player.pionpos%12; // case du pion
				int squarepos=cases[pionpos]; // la prochaine place disponible dans la case
				cases[pionpos]++; // on ajoute le pion dans la case
				// coordonnée du pion dans la case
				int squarewidth = width/squaregridx; // largeur disponible pour un pion dans la case
				int squareheight = height/squaregridy; // hauteur disponible pour un pion dans la case
				int squaresize = Math.min(squarewidth,squareheight); // on s'arrange pour que le pion ne soit pas oval
				// coordonee de la case
				int xp = (squarepos%squaregridx)*squaresize; // x du pion dans la case
				int yp = (squarepos/squaregridx)*squaresize;
				// ici, comme on tourne autour du panel, les cases changent d'orientation (elles pivotent sur la gauche de 90° à chaque angle)
				if ( pionpos>8 ) {
					int swap = xp;
					xp=squaresize-yp;
					yp=squaresize-swap;
				} else if ( pionpos>5 ) {
					yp=squaresize-yp;
				} else if ( pionpos>2 ) {
					int swap = xp;
					xp=yp;
					yp=squaresize-swap;
				}
				int x=player.pionx*getWidth()/4 + (getWidth()/4-width)/2;
				x+=xp; // on convertit squarepos en coordonnée x (modulo le nombre de colonnes)
				int y=player.piony*getHeight()/4 + (getHeight()/4-height)/2;
				y+=yp;
				g.setColor(PIECE_COLORS[i]);
				g.fillOval( x, y, squaresize, squaresize);  
				g.setColor(Color.WHITE);
				String playerPosition = String.valueOf(player.order);
				g.drawString(playerPosition, x+(int)(squaresize-fm.getStringBounds(playerPosition, g).getWidth())/2, y+(squaresize+fm.getAscent())/2);
			}
		}
 
		int ddice = dice;
		if ( ddice>0 ) { // s'il y a un dé tiré on le dessine
			g.setColor(Color.ORANGE);
 
			// on dessine le dé centré
			int x = (getWidth()-width)/2;
			int y = (getHeight()-height)/2;
			g.fillRoundRect(x, y, width, height, width/10, width/10);
 
			// dessin des points
			int ray = width/10;
			g.setColor(Color.BLACK);
			if ( ddice==1 || ddice==5 || ddice==3 ) {
				// point au centre
				g.fillOval(getWidth()/2 - ray, getHeight()/2 - ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à gauche
				g.fillOval(x+ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à droite
				g.fillOval(x+width-3*ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à gauche
				g.fillOval(x+ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à droite
				g.fillOval(x+width-3*ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==6 ) {
				// point à gauche et à droite
				g.fillOval(x+ray, getHeight()/2 - ray, ray*2, ray*2);
				g.fillOval(x+width-3*ray, getHeight()/2 - ray, ray*2, ray*2);
			}
		}
	}
 
	private static class Piece {
		public int order=1;
		public int pionpos = 0;
		public int pionx = 0;
		public int piony = 0;
 
		public int getPosition() {
			return pionpos;
		}
 
		private void movePiece(int dice) {
			pionpos += dice;
			// on convertit la position du pion en coordonnée de cases, parce que c'est bien plus simple à gérer que des coordonnées en pixels
 
	               // la grille 4x4 de cases est comme cela
 
	               // 0 11 10 9
	               // 1 x x 8
	               // 2 x x 7
	               // 3 4 5 6
 
	               // les x sont des cases de la grille où le chemin ne passe pas
	               // le chemin va de 0 à 11 = 12 cases,
 
			int xpion = pionpos%12; // permet de ramener un chemin infini à un chemin de 12 cases
 
	                // on convertit le xpion (coordonnée linéaire sur un chemin de 12 cases) vers pionx et piony, coordonnées cartésiennes dans la grille 4x4 si dessus
			if ( xpion>=0 && xpion<4 ) {
				pionx = 0;
			}
			else if ( xpion<7 ) {
				pionx = xpion-3;
			}
			else if ( xpion<10 ) {
				pionx = 3;
			}
			else {
				pionx = 12-xpion;
			}
			if ( xpion>=0 && xpion<4 ) {
				piony=xpion;
			}
			else if ( xpion<7 ) {
				piony= 3;
			}
			else if ( xpion<10 ) {
				piony=9-xpion;
			}
			else {
				piony = 0;
			}
		}
 
	}
 
	public static void main(String[] args) {
 
		String title="Entrez le nombre de joueur(s)";
		int nbPlayers;
		do {
			String response = JOptionPane.showInputDialog(null, "Nombre de joueur(s) (entre 1 et "+DicePanel.getMaxPlayers()+")", title, JOptionPane.QUESTION_MESSAGE);
			if ( response==null) System.exit(0);
			try {
				nbPlayers = Integer.parseInt(response);
			}
			catch(NumberFormatException e) {
				nbPlayers=0;
			}
			title="Réentrez le nombre de joueur(s)";
		}
		while(!(nbPlayers >0 && nbPlayers<=DicePanel.getMaxPlayers()));
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DicePanel dicePanel = new DicePanel(nbPlayers);
		frame.add(dicePanel);
 
 
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
		frame.add(buttonPanel, BorderLayout.SOUTH);
		JLabel playerLabel = new JLabel();
		playerLabel.setOpaque(true); // pour que le label ait un fond
		playerLabel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
		playerLabel.setForeground(buttonPanel.getBackground());
		updatePlayerLabel(playerLabel, dicePanel);
		buttonPanel.add(playerLabel);
		JButton diceButton = new JButton("Tirer un dé");
		buttonPanel.add(diceButton);
		JButton playerButton = new JButton("Joueur suivant");
		buttonPanel.add(playerButton);
		diceButton.addActionListener(e-> {
			dicePanel.rollDice();
			if ( dicePanel.getDice()!=6 ) {
				playerButton.doClick();
			}
		});
		playerButton.addActionListener(e-> {
			dicePanel.nextPlayer();
			updatePlayerLabel(playerLabel,dicePanel);
		});
 
 
		frame.setSize(400, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
 
	}
 
	private static void updatePlayerLabel(JLabel playerLabel, DicePanel dicePanel) {
		playerLabel.setText("Joueur "+(dicePanel.getCurrentPlayer()+1)+" joue");
		playerLabel.setBackground(dicePanel.getCurrentPlayerColor());
	}
 
}

PS. Il y avait une erreur dans mes codes précédents : le tirage du dé se faisait entre 1 et 5 et pas 1 et 6

**peggy67** · 21/05/2017, 23h11

Bonsoir,
J'ai bien pris en note de ce que vous m'avez dit et je vous remercie . J'ai utilisé ce que vous avez pour le cas avec deux pions pour l'instant. Je voulais assimiler le programme à un autre (une autre classe : Quiz_Window) de sorte à ce que lorsqu'on tombe sur une case, on pose une question (ce que j'ai réussi à faire). Une fois la question posée, deux possibilité : la réponse est juste (et on rejoue) ou la réponse est fausse et alors on passe à l'autre joueur.
Mon programme marche dans le cas où il répond faux (à savoir que l'autre peut jouer) mais dans le cas où le joueur a juste, j'arrive pas à relancer la méthode qui permet de refaire lancer le dé et avancer le pion. Il me met un message d'erreur.
(La partie qui propose problème est dans la partie QUiz_Window, que j'ai signalé par des " /////ICI/// /////Jusque ici/////)

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
169
170
171
172
173
174
package developpez.net2.copy.copy.copy;
 
 
 
import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
 
// Creation of the class Quiz_Window
public class Quiz_Window extends JFrame implements ActionListener {
 
	private static final long serialVersionUID = 1L;
	//Screen size is read out
	//Creating variables
	Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
	private JLabel question2;
	//Setting the number of buttons
	private JButton ant[] = new JButton[4];
 
	Questions question;
	JFrame w1;
	question_change change;
	//Button to change question
	Object[] options = { "OK, Next Turn"};	
	int solution;
	int True;
 
 
	public Quiz_Window(){
		// Window is created
		w1 = new JFrame();
		// Parameters of the window of the quizz
		w1.setSize(600,500);
		w1.setLocation((int)(dim.getWidth()-600)/2,(int)(dim.getHeight()-(1250)/2));
		w1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		w1.setVisible(true);
		// Layout = NULL means we fix x, y itself
		w1.setLayout(null);
		// The first button, and the ActionListener is registered so that it can react to button printing
	    // Parameters of each button(size, position...)
	       ant[0] = new JButton(" - ");
		   ant[0].setBounds(25,170,250,60);
		   ant[0].addActionListener(this);
		 	w1.add(ant[0]);
 
	        ant[1] = new JButton(" - ");
			ant[1].setBounds(25,250,250,60);
			ant[1].addActionListener(this);
			w1.add(ant[1]);
 
			ant[2] = new JButton(" - ");
			ant[2].setBounds(300,170,250,60);
			ant[2].addActionListener(this);
			w1.add(ant[2]);
 
			ant[3] = new JButton(" - ");
			ant[3].setBounds(300,250,250,60);
			ant[3].addActionListener(this);
			w1.add(ant[3]);
 
			// Creation of the position of the  question and the length of it 
			question2 = new JLabel("Here, there is the question ");
			question2.setBounds(40,10,2000,40);
			w1.add(question2); 
 
	}
 
 
 
	public void actionPerformed(ActionEvent e){
 
		//e.getSource is the cause of the click, the solution is the right answer to the question
		// If button 1 is correct
		if(e.getSource()== ant[0]){
			if (solution == 1){
				// Message when the answer is right
				Message("Right"," Next...");
				w1.setVisible(false);
				//////////////////////
				///////ICI////////////
				//////////////////////
				DicePanel lancer = new DicePanel(True);
				lancer.rollDice();
				////////JUSQUE ICI////////
 
 
			}else{
				// Else, if is false, display this message and change question
				Message("False"," You lose...");
				w1.setVisible(false);
 
			}
			}
		//e.getSource is the cause of the click, the solution is the right answer to the question
		// If button 2 is correct
 
 
		if(e.getSource()== ant[1]){
			if (solution  == 2){
				// Message when the answer is right
				Message("Right","Go on...");
				w1.setVisible(false);
 
 
			}else{
				// Else, if is false, display this message and change question
				Message("      False","You need to do better...");
				w1.setVisible(false);
			}
		}
 
		//e.getSource is the cause of the click, the solution is the right answer to the question
		// If button 3 is correct
		if(e.getSource() == ant[2]){
 
			if (solution == 3){
				// Message when the answer is right
				Message("Right","Next...");
				w1.setVisible(false);
 
 
			}else{
				// Else, if is false, display this message and change question
				Message("        False","Try again after...");
				w1.setVisible(false);
			}
		}
 
		//e.getSource is the cause of the click, the solution is the right answer to the question
		// If button 4 is correct
		if(e.getSource() == ant[3]){
			if (solution == 4){
				// Message when the answer is right
				Message ("True","Next...");
				w1.setVisible(false);
 
 
			}else{
				// Else, if is false, display this message and change question
				Message("      False"," You will do better later...");
				w1.setVisible(false);
			}
		}
 
 
			}
 
 
 
	// Change button text
	public void ChangeTextButton(int button,String text){
 
		ant[button-1].setText(text);
 
	}
	// Change the label text
	public void ChangeTextLabel(String text){
		question2.setText(text);
	}
 
 
	//Give the message if it's true or false (it's a window)
	public void Message(String Statement,String info){
		JOptionPane.showOptionDialog(null, Statement, info,
 
		        JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE,
 
		        null, options, options[0]);
 
 
		}
	}

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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
package developpez.net2.copy.copy.copy;
 
import java.awt.BorderLayout;
import java.awt.Color;
 
import java.awt.Graphics;
import java.awt.Image;
import java.io.File;
import java.io.IOException;
 
import java.util.concurrent.ThreadLocalRandom;
 
import javax.imageio.ImageIO;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
 
 
public class DicePanel extends JPanel {
 
	private static final Color[] PIECE_COLORS = {Color.BLUE, Color.BLACK, Color.RED, Color.GREEN};
	private int dice=0; // 0 no dice has been rolled 
	private Piece[] players; // pions
	private int player = 0; // le joueur 1 commence
 
 
 
 
 
	public DicePanel(int nbPlayers) {
		if (nbPlayers<=0 ) {
			throw new IllegalArgumentException("Le ombre de joueurs doit être au moins 1");
		}
		if (nbPlayers>PIECE_COLORS.length ) {
			throw new IllegalArgumentException("Le nombre de maximum de joueurs est "+PIECE_COLORS.length);
		}
		players=new Piece[nbPlayers];
		for(int i=0; i<players.length; i++) {
			players[i]=new Piece();;
		}
	}
 
 
	public void rollDice() {
		dice=ThreadLocalRandom.current().nextInt(1, 7); // on tire un dé entre 1 et 6
		players[player].movePiece(dice);
		repaint(); // on rafraichît l'affichage
 
 
	} 
	public int getDice() {
		return dice;
	}
 
	public void nextPlayer() {
		player++;
		if  (player>=players.length ) {
			player=0;
		}
	}
 
	public int getCurrentPlayer() {
		return player;
	}
 
	public Color getCurrentPlayerColor() {
		return PIECE_COLORS[player];
	}
 
	private static class Piece {
		public int pionpos = 0;
		public int pionx = 0;
		public int piony = 0;	
 
	private void movePiece(int dice) {
		pionpos +=dice; // we get from one box to another (1 by 1)
		// we convert the position of the pawn in box coordinates (easer than pixels coordinates)
		int xpion1 = pionpos%1000;
		if ( xpion1>=0 && xpion1<10) { // positionX for the first line
			pionx = xpion1+1;
		}
		else if ( xpion1<12 ) { // positionX for the first column 
			pionx = 10;
		}
		else if ( xpion1<21 ) { // positionX for the second line
			pionx = 21-xpion1;
		}
		else if (xpion1<23){ // positionX for the second column
			pionx=1;
		}
		else if (xpion1<32){ // positionX for the third line
			pionx=xpion1-21;
		}
		else if (xpion1<34){ // positionX for the third column
			pionx=10;
		}
		else if (xpion1<41) { // positionX for the last line
			pionx = 43-xpion1;
		}
		else {
			pionx =1; // last box 
		}
		if ( xpion1>=0 && xpion1<10 ) { // positionY for the first line
			piony=1;
		}
		else if ( xpion1<12 ) { // positionY for the first column
			piony= xpion1-8;
		}
		else if ( xpion1<21 ) { // positionY for the second line
			piony=3;
		}
		else if (xpion1<23){ // positionY for the second column
			piony=xpion1-17;
		}
		else if (xpion1<32){ // positionY for the third line
			piony=5;
		}
		else if (xpion1<34){ // positionY for the third column
			piony=xpion1-26;
		}
		else if (xpion1<41){ // positionY for the last line
			piony = 7;
		}
		else {   // last box 
			piony=7;
		}
		if (pionx!=1 &&piony!=7){
			new question_change();
		}
	}
 
	}
 
	@Override
	protected void paintComponent(Graphics g) {
 
		super.paintComponent(g);
 
		int width = getWidth()/4; // we draw the dice on the 1/4 of the window
		int height = getHeight()/4;
		if ( width>height ) {
			width = height;
		}
		else {
			height = width;
		}
 
 
		// draw the game board
		try {
	        Image img = ImageIO.read(new File("Plateau-de-jeu.PNG"));
 
	        g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
	      } catch (IOException e) {
	        e.printStackTrace();
	      }
		for(int i=0; i<players.length; i++) {
			Piece player = players[i];
			g.setColor(PIECE_COLORS[i]);
			g.fillOval(player.pionx*getWidth()/12 , player.piony*getHeight()/9, width/2, height/2);  
		}
 
 
 
 
		// display of the dice
		int ddice = dice;
		if ( ddice>0 ) {
			g.setColor(Color.WHITE);
 
			// on dessine le dé centré
			int x = (getWidth()-width)/2;
			int y = (getHeight()-height)/2;
			g.fillRoundRect(x, y, width, height, width/10, width/10);
 
			// dessin des points
			int ray = width/10;
			g.setColor(Color.BLACK);
			if ( ddice==1 || ddice==5 || ddice==3 ) {
				// point au centre
				g.fillOval(getWidth()/2 - ray, getHeight()/2 - ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à gauche
				g.fillOval(x+ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à droite
				g.fillOval(x+width-3*ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à gauche
				g.fillOval(x+ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à droite
				g.fillOval(x+width-3*ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==6 ) {
				// point à gauche et à droite
				g.fillOval(x+ray, getHeight()/2 - ray, ray*2, ray*2);
				g.fillOval(x+width-3*ray, getHeight()/2 - ray, ray*2, ray*2);
			}
		}
 
 
	}
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("GAME OF UNBEATABLE");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DicePanel dicePanel = new DicePanel(2);
		frame.add(dicePanel);
 
		JPanel buttonPanel = new JPanel();
		frame.add(buttonPanel, BorderLayout.SOUTH);
		JLabel playerLabel = new JLabel();
		playerLabel.setOpaque(true); // pour que le label ait un fond
		playerLabel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
		playerLabel.setForeground(buttonPanel.getBackground());
		updatePlayerLabel(playerLabel, dicePanel);
		buttonPanel.add(playerLabel);
		JButton diceButton = new JButton("Tirer un dé");
		buttonPanel.add(diceButton);
		JButton playerButton = new JButton("Joueur suivant");
		buttonPanel.add(playerButton);
		diceButton.addActionListener(e-> {
			dicePanel.rollDice();
			if ( dicePanel.getDice()!=7 ) {
				playerButton.doClick();
			}
		});
		playerButton.addActionListener(e-> {
			dicePanel.nextPlayer();
			updatePlayerLabel(playerLabel,dicePanel);
		});
 
		//dimension of the window
		frame.setSize(900, 700);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
 
	}
	private static void updatePlayerLabel(JLabel playerLabel, DicePanel dicePanel) {
		playerLabel.setText("Joueur "+(dicePanel.getCurrentPlayer()+1)+" joue");
		playerLabel.setBackground(dicePanel.getCurrentPlayerColor());
	}
 
}

et les deux autres classes qui sont appelées (si vous voulez le tester) :

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
package developpez.net2.copy.copy.copy;
 
//Creation of class questions ( allows to create a sort of list 
public class Questions {
 
	//Creation of a variable which allows to select the question by a number called coincidence
	int coincidence;
 
	//Creation of the number of question defined by a String 
	String questions[] = new String[102];
	static String question;
 
		public Questions(){
	// Writing of all questions 
			//Structure of the question -Question-Split($)-Answer1-$-Answer2-$-Answer3-$-Answer4-$-Number of the split which is correct(the position)
		questions[0] = "Entomology is the science that studies $Behavior of human beings $Insects $The origin and history $The formation of rocks $2";
		questions[1] = "What has studied Ghandi ?$Medicin$Jurism$Litterature$Nothing$2";
		questions[2] = "How many years has the sun ?$One week$3 Billion$3.141 Days$5 Mrd$4";
		questions[3] = "In the Middle Ages, how were the fortified villages named ? $Tours  $Bastide $Chateau Fort  $Rempart $2";
		questions[4] = "In which movie will a couple on a cruise get a shipwrecked that will terrify them ? $Titanic$Robinson Cruso� $ Calme Blanc $ Inception $3";
		questions[5] = "What French actor had the lead in the film Luchino Visconti 'Le Gu�pard' ?$ Jean-Paul Belmondo $ Claude Brasseur $ Jean Gabin $Alain Delon $4";
		questions[6] = "Which succed movie has brought Sean Connery and Chritsophe Lambert in it? $Highlander$Greystoke$Subway$MadMax$1";
		questions[7] = "What is the nome of the fruts of plaqueminier?$Kakou$Kacha$Kaki$Kali$3";
		questions[8] = "Who was the compagnon of Paun Saint ?$Saint-Matthieu $Saint-Jean$Saint-Luc$Saint-Marc$3";
		questions[9] = "In which movie John Travolta is an angle followed from the sky?$Michael$Johny$Jerry$Jean$1";
		questions[10] = "What title of nobility is immediately inferior to that of count?$Archiduc$Marquis$Vicomte$Duc$3";
		questions[11] = "Of what series of six films is a boxing champion the star?$Ritchie$Rocky$Rambo$Randy$2";
		questions[12] = "What is the capital of New Zealand?$Dublin$Auckland$Weloington$Sydney$3";
		questions[13] = "To which French director is the film 'Banza�'?$Claude Lelouche$ClaudeZidi$Claude Chabrol$Claude Sautet$2";
		questions[14] = "Which movie was shown on the screens Isabelle Adjani and Sharon Stone?$Diabolique $Ange et D�mon $ Les sorci�res $ Les ensorceleuses$1";
		questions[15] = "What is also called 'Transat Jacques Vabre'?$Route du Rhum$Vend�e Globe $ Route du caf� $ Troph�e du Rhum $3";
		questions[16] = "What is the name of the word processing software developed by Microsoft?$Access$Word$Excel$PowerPoint $2";
		questions[17] = "What is the capital of Kathmandu?$ N�pal $ Tibet $ South Corean $ Pakistan $1";
		questions[18] = "Which animal class does the scorpion belong to?$Mammals$Reptile$Arachnids$Insects$3";
		questions[19] = "Eritrea, which became the 182nd member of the UN in 1993, is in the continent of $Asia $ Africa $Europe $Australia $2";
		questions[20] = "Grand Central Terminal, Park Avenue, New York is the world's... railway station $largest $highest $longest $Nothing$1";
		questions[21] = "Garampani sanctuary is located at$Junagarh$Diphu$Kohima$Gangtok $2";
		questions[22] = "For which of the following disciplines is Nobel Prize awarded?$Physics and Chemistry $Physiology or Medicine $ Literature, Peace and Economics$All of the above $4";
		questions[23] = "Hitler party which came into power in 1933 is known as $Labour Party$Nazy Party$Ku-Klux-Klan$Democratic Party$2";
		questions[24] = "FFC stands for $Foreign Finance Corporation$Film Finance Corporation $Federation of Football Council$ None of the above$2";
		questions[25] = "Epsom (England) is the place associated with $ Horse racing$Polo$Shooting$Snooker$1";
		questions[26] = "First human heart transplant operation conducted by Dr. Christiaan Barnard on Louis Washkansky, was conducted in$1967$1968$1958$1922$1";
		questions[27] ="Galileo was an Italian astronomer who$developed the telescope$discovered four satellites of Jupiter$discovered that the movement of pendulum produces a regular time measurement$All of the above$4";
		questions[28] ="First Afghan War took place in$1839$1843$1833$1848$1";
		questions[29] ="First China War was fought between China and ... $Britain$France$Egypt$Greek$1";
		questions[30] ="For the Olympics and World Tournaments, the dimensions of basketball court are$26x14m$28x15m$27x16m$28x16m$2";
		questions[31] ="Friction can be reduced by changing from$sliding to rolling$rolling to sliding$ potential energy to kinetic energy$dynamic to static$1";
		questions[32] ="During eleventh Antarctic Expedition in Nov. 1991/March 1992 ____ was installed.$SODAR$Second Permanent Station$First permanent station$None of the above$1";
		questions[33] ="Fire temple is the place of worship of which of the following religion?$Taoism$Judaism$Zoroastrianism$Shintoism$3";
		questions[34] ="Georgia, Uzbekistan and Turkmenistan became the members of UNO in$1991$1992$1993$1994$2";
		questions[35] ="Germany signed the Armistice Treaty on ____ and World War I ended$January 19, 1918$May 30, 1918$November 11, 1918$February 15, 1918$3";
		questions[36] ="During World War II, when did Germany attack France?$1940$1941$1942$1943$1";
		questions[37] ="The ozone layer restricts$Visible light$ Infrared radiation$ X-rays and gamma rays$ Ultraviolet radiation$2";
		questions[38] ="Euclid was$Greek mathematician$Architect$Propounded the geometrical theorems$All of the above$4";
		questions[38] ="Ecology deals with$Birds$Cell formation$ Relation organisms/environments$Tissues$3";
		questions[39] ="Filaria is caused by$Bacteria$Mosquito$Protozoa$Virus$2";
		questions[40] ="During World War I Germany was defeated in the Battle of Verdun on the western front and \n Romania declared war on the eastern front in the year$1914$1915$1916$1917$3";
		questions[41] ="Durand Cup is associated with the game of$Cricket$Football$Hockey$Volleyball$2";
		questions[42] ="Headquarters of UNO are situated at$New-York$Hague$Geneva$Paris$1";
		questions[43] ="First International Peace Congress was held in London in$1564$1789$1843$1901$3";
		questions[44] ="For seeing objects at the surface of water from a submarine under water, the instrument used is$kaleidoscope$periscope$spectroscope$telescope$2";
		questions[45] ="G-15 is an economic grouping of$First World Nations$ Second World Nations$Third World Nations$Fourth World Nations$3";
		questions[46] ="Fathometer is used to measure$Earthquakes$Rainfall$Ocean Depth$Sound Intensity$3";
		questions[47] ="For galvanizing iron which of the following metals is used?$Aluminium$Copper$Lead$Zinc$4";
		questions[48] ="For purifying drinking water alum is used$for coagulation of mud particle$to kill bacteria$to remove salts$to remove gases$1";
		questions[49] ="Hockey was introduced in the Asian Games in$1958 in Tokyo$1962 in Jakarta$1966 in Bangkok$1970 in Bangkok$1";
		questions[50] ="Firdausi was$ a poet$ well known for his epic 'Shanhnama'$Both option A and B $ None of the above$3";
		questions[51]="Gabriel Daniel Fahrenheit was$a German Physicist$developed the mercury thermometer in 1714$devised temperature scale$ all of the above$4";
		questions[52]="During the first crusade, crusaders reached Jerusalem and captured it in $1000$1099$1200$1515$2";
		questions[53]="East Timor, which became the 191st member of the UN, is in the continent of$Asia$Africa$Europe$South America$1";
		questions[54]="Track and field star Carl Lewis won how many gold medals at the 1984 Olympic games?$2$3$4$8$3";
		questions[55]="Which is the biggest country in the world?$China$Canada$Russia$USA$3";
		questions[56]="Which country is the smallest country in the World ?$Singapor$Brunei$Cambodia$Vatican$4";
		questions[57]="What is the capital city of Australia?$Canberra$Melbourne$Syndney$Newcastle$1";
		questions[58]="Where is the Eiffeil Tower ? $Germany/Berlin $Italy/Rome $England/London$France/Paris$4";
		questions[59]="What color do you add to blue in order to make purple?$Red$Yellow $Black$Orange$1";
		questions[60]="Which country has the most population in the world ?$India$USA$Russia$China$4";
		questions[61]="What is the boiling point of water ? $90 Centigrade $100�$110�$120�$2";
		questions[62]="Who is the author of Romeo and Juliet?$Mark Twain$William Shakespeare$Charles Dickens$Edgar Allan Poe$2";
		questions[63]="Where is the pizza originally from ?$Italy$USA$France$Mexico$1";
		questions[64]="What does your heart pump? $Blood $Water$Mud$Salt Water$1";
		questions[65]="Which is heavier ? $Gold$Silver$Platine$ Steel $1";
		questions[66]="What is H2O ? $Water$Salt$Sugar$Oxygen$1";
		questions[67]="How many legs does a butterfly have ? $2 $4$6$8$3";
		questions[68]="Which is bigger ? $lake$ocean$sea$puddle$2";
		questions[69]="What is the capital of Norway ? $Oslo$Talin$Stalingrad$Telin$1";
		questions[70]="What is the biggest state in USA ? $New-York $ Alaska $ California$ Texas$2";
		questions[71]="In which ocean is Hawaii? $Pacific$Mediteranean$Atlantic$Indian$1";
		questions[72]="What sport is played at Wimbledon$Football$Handball$Rugby$Tennis$4";
		questions[73]="In which country were the 2008 Olympic Games held? $USA $Brasil $China $Japan$3";
		questions[74]="What country does the football player Romario come from?$France$Argentina$England$Brazil$4";
		questions[75]="What is the most popular indoor sport in the USA ?$Baseball$Basketball$Rugby$Criket$2";
		questions[76]="In which sport was Muhammad Ali the world champion?$Boxing$Dance$Athletism$Karate$1";
		questions[77]="Which famous golf player's mother comes from Thailand? $Tiger Woods$Alan Dassoi$Ly Rich$Rick Ross$1";
		questions[78]="How many strings does a violin have ? $2$4$6$5$2";
		questions[79]="Which vitamin is abundant in citrus fruits?Vitamin ... $A $B $C $D$3";
		questions[80]="Triton is a moon of which planet ? $Jupiter$Earth$MarsNeptune$4";
		questions[81]="In which organ of the body is the cerebrum found ?$Brain$Stomac$Feet$Heart$1";
		questions[82]="In which country is the world's highest waterfall? $Canada $USA $China $Venezuela$4";
		questions[83]="Golf was first played in which country ? $France$England$USA$Scotland$4";
		questions[84]="In which sport are a bow and arrow used? $Archery$Basketball$Handball$Baseball$1";
		questions[85]="What does a third place getter at the Olympic Games win ? $ Gold Medal$Silver Medal$Bronze Medal $Nothing $3";
		questions[86]="In boxing, what do the letters K.O stand for ? $ Kick out$Knock out$ Kaka out$Knocking on$2";
		questions[87]="Baseball originated in the USA in which century$18th century$19 century $20 century $21 century$2";
		questions[88]="How many rings are there in the Olympic Games symbol ? $4$5$6$7$2";
		questions[89]="Which country won the 1998 FIFA World Cup football tournament?$Germany$France$Spain$England$2";
		questions[90]="Who won the 2003 Wimbeldon women's tennis championship?$Morresmo$Williams$Sharapova$Poulain$2";
		questions[91]="What pop groupe was Michael Jackson a member of when he was young?$Jackson five $ One direction $Belibers$Jackson six$1";
		questions[92]="What type of music did Louis Armstrong play ? $Jazz$Pop$Soul$Rock$1";
		questions[93]="What nationality was Mozart ? $Austrian $German $ Italia $ French$1";
		questions[94]="On which continent is Sierra Leone? $America$Europe$African$Asian$3";
		questions[95]="In what country did reggae music originate ? $Jamaican$Brazil$Maroco$USA$1";
		questions[96]="Which team won the 2003 Formula One car racing championship$MacLarren$Ferrari$AstonMartin$Buggati$2";
		questions[97]="What is longest running race in the Olympic Games called ? $ Marathon $ Triathlon $5000m Sprin $None of the above$1";
		questions[98]="Which ocean is to the east of Africa?$ Indian Ocean $Atlantic Ocean $ Balkan Ocean $ Mediteranean Sea $1";
		questions[99]="One the most longest river in the world is..? $Niles$Rhin$Danube$MancheSea$1";
		questions[100]="Which travel faster ? $Light waves$Sound waves$Sea Waves$None of the above$1";
		questions[101]="Which planet is the fifth from the sun ?$ The Earth$ Mars $ Jupiter $ Saturne $3";
 
		//Variable which define the questions selection with the number of it define by the running program to call "coincidence"
		question= questions[coincidence(0,102)];
 
	}
		//Definition of the coincidence variable chose by a random way containing in the entire list of questions)
	public int coincidence(int min,int max){
 
		coincidence =  (int) ((max - min) * Math.random() );
		/*
		if(coincidence == 0){
			coincidence =  (int) ((max - min) * Math.random() );
		}
		*/
 
		// Allows to watch which question is done
		System.out.print(coincidence+"\n");
		return coincidence;
 
 
 
	}
}

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
package developpez.net2.copy.copy.copy;
 
 
//Creation of the class which allows to change question and to split the different answer in the window
public class question_change{
 
	static String ri_question = null;
	static String op1 = null;
	static String op2 = null;
	static String op3 = null;
	static String op4 = null;
	static int solution = 0 ;
	static Quiz_Window quiz;
	static Questions question_classe;
	static String act_Question;
 
	// Changing the question in the defined label
	public question_change(){
		quiz = new Quiz_Window();
		newQuestion();
	}
 
	public static void newQuestion(){
		question_classe = new Questions();
		act_Question = question_classe.question;
		parser();
		otherText();
	}
 
	public static void otherText(){
		// The button texts are changed
		quiz.ChangeTextLabel(ri_question);
		quiz.solution = solution;
		quiz.ChangeTextButton(1,op1);
		quiz.ChangeTextButton(2,op2);
		quiz.ChangeTextButton(3,op3);
		quiz.ChangeTextButton(4,op4);
	}
 
 
public static void parser(){ 
 
//Definition of how to read the question in the list thanks to the split.
	String[] question= act_Question.split("\\$");
	// How answers are distributed in different cases  
	 for (int x=0; x<question.length; x++){
		 switch(x) {
 
		 	case 0:
			 ri_question = question[x];
			 break;
 
		 	case 1:
		 	op1 = question[x];
		 	break;
 
		 	case 2:
		 	op2 = question[x];
		 	break;
 
		 	case 3:
		 	op3 = question[x];
		 	break;
 
		 	case 4:
		 	op4 = question[x];
		 	break;
 
		 	case 5:
		 	solution = Integer.parseInt(question[x]);
		 	break;
 
		 } }
 
 
	 }
	}

Merci pour votre interet

**joel.drigo** · 22/05/2017, 00h55

Plusieurs choses :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
DicePanel lancer = new DicePanel(True);
				lancer.rollDice();
```
C'est censé créer un panel, un composant d'affichage, puis de lancer un dé, qui modifie cet affichage. Mais le panel est mis dans aucune fenêtre. C'est donc totalement inutile. On peut faire ce genre de truc et lancer un autre machin, comme ici :
[code]if (pionx!=1 &&piony!=7){
new question_change();
}[/c]
Mais c'est tordu. Si on veut lancer le dé et faire new question_change(), on lance le dé et on fait new question_change(), pas un panel et tout un tas de trucs qui au bout du compte fait autre chose.
DicePanel lancer = new DicePanel(True);Le paramètre est de type int, pas boolean, donc ça ne risque pas de compiler.

Code :

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

1
2
3
4
5
6
7
8
public class Quiz_Window extends JFrame implements ActionListener {
 
/*...*/ 
 
 
	public Quiz_Window(){
		// Window is created
		w1 = new JFrame();

Pourquoi une frame créée par une frame ? Si Quiz_window est affichée, alors l'autre frame ne sert à rien : Quiz_window est une frame et suffit à faire l'affichage. Si Quiz_vindow n'est pas affichée, alors ça ne sert à rien que ça soit une JFrame. Si w1 est là juste pour afficher les questions, il vaudrait mieux que ça soit un dialogue modal (soit JOptionPane, soit JDialog), sinon ça fait 2 JFrame indépendantes

Dans l'exemple que j'ai donné, on utilise un bouton pour lancer le dé. Mais on peut très bien ne pas mettre de bouton et appeler rollDice() ailleurs. Par exemple, l'appeler dans une boucle, mais attention, cette boucle ne doit pas être faite dans le thread de Swing, sinon on bloque Swing, affichage et interaction, parce qu'un thread ne peut faire qu'une seule chose à la fois.
Mais on peut faire un bouton qui fait jouer le prochain joueur, comme j'ai fait dans le dernier exemple que je t'ai montré. Dans cet exemple, le même joueur continuait à être le joeur par défaut tant que le tirage était 6, mais je t'ai dit qu'on pouvait mettre n'importe quelle condition. Comme celle de répondre correctement à une question.

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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
public class DicePanel extends JPanel {
 
	private static final Color[] PIECE_COLORS = {Color.BLUE, Color.BLACK, Color.RED, Color.GREEN.darker()};
 
	private int dice=0; // 0 signifie aucun dé tiré 
	private Piece[] players; // pions
	private int player = 0; // le joueur 1 commence
 
	public DicePanel(int nbPlayers) {
		if (nbPlayers<=0 ) {
			throw new IllegalArgumentException("Le ombre de joueurs doit être au moins 1");
		}
		if (nbPlayers>PIECE_COLORS.length ) {
			throw new IllegalArgumentException("Le nombre de maximum de joueurs est "+PIECE_COLORS.length);
		}
		players=new Piece[nbPlayers];
		for(int i=0; i<players.length; i++) {
			players[i]=new Piece();;
		}
	}
 
	public static int getMaxPlayers() {
		return PIECE_COLORS.length;
	}
 
	public void rollDice() {
		dice=ThreadLocalRandom.current().nextInt(1, 7); // on tire un dé
		players[player].movePiece(dice);
		// on détermine l'ordre des joueurs
		Piece[] order = Arrays.stream(players).sorted(Comparator.comparing(Piece::getPosition).reversed()).toArray(Piece[]::new);
		int playerorder=1;
		for(int pieceOrder=0; pieceOrder<order.length; pieceOrder++) {
			if ( pieceOrder>0 && order[pieceOrder-1].pionpos!=order[pieceOrder].pionpos ) {
				playerorder++;
			}
			order[pieceOrder].order=playerorder;
		}
		repaint(); // on rafraichît l'affichage
	}
 
	public int getDice() {
		return dice;
	}
 
	public void nextPlayer() {
		player++;
		if  (player>=players.length ) {
			player=0;
		}
	}
 
	public int getCurrentPlayer() {
		return player;
	}
 
	public Color getCurrentPlayerColor() {
		return PIECE_COLORS[player];
	}
 
	private int getCurrentPlayerPosition() {
		return players[player].pionpos;
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
 
		int width = getWidth()/4; // on dessine le dé et le pion sur le quart de la fenêtre (grille 4x4 d'où le "quart"
		int height = getHeight()/4;
		if ( width>height ) {
			width = height;
		}
		else {
			height = width;
		}
 
		// dessin des cases (chemin de 12 cases tournant autour de la grille 4x4
		g.setColor(Color.YELLOW);
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				if ( i>0 && i<3 && j>0 && j<3 ) {
					continue; // on dessine un chemin que sur les bords
				}
				g.fillRect(i*getWidth()/4 + 4 , j*getHeight()/4 + 4, getWidth()/4 - 8 , getHeight()/4 - 8);
			}
		}
 
		// dessin des pions (en faisant la conversion des x,y de cases en x,y de pixels ici
 
		// on détermine comment on va disposer les pions
		int squaregridx=(int)Math.ceil(Math.sqrt(players.length));
		int squaregridy=players.length/squaregridx;
 
		// on détermine la position de tous les pions
		if ( players.length==1 ) {
			g.setColor(PIECE_COLORS[0]);
			int x=players[0].pionx*getWidth()/4 + (getWidth()/4-width)/2;
			int y=players[0].piony*getHeight()/4 + (getHeight()/4-height)/2;
			g.fillOval( x, y, width, height);  
		}
		else {
			FontMetrics fm = g.getFontMetrics();
			int[] cases = new int[12]; // 12 cases
			for(int i=0; i<players.length; i++) {
				Piece player = players[i];
				int pionpos=player.pionpos%12; // case du pion
				int squarepos=cases[pionpos]; // la prochaine place disponible dans la case
				cases[pionpos]++; // on ajoute le pion dans la case
				// coordonnée du pion dans la case
				int squarewidth = width/squaregridx; // largeur disponible pour un pion dans la case
				int squareheight = height/squaregridy; // hauteur disponible pour un pion dans la case
				int squaresize = Math.min(squarewidth,squareheight); // on s'arrange pour que le pion ne soit pas oval
				// coordonee de la case
				int xp = (squarepos%squaregridx)*squaresize; // x du pion dans la case
				int yp = (squarepos/squaregridx)*squaresize;
				// ici, comme on tourne autour du panel, les cases changent d'orientation (elles pivotent sur la gauche de 90° à chaque angle)
				if ( pionpos>8 ) {
					int swap = xp;
					xp=squaresize-yp;
					yp=squaresize-swap;
				} else if ( pionpos>5 ) {
					yp=squaresize-yp;
				} else if ( pionpos>2 ) {
					int swap = xp;
					xp=yp;
					yp=squaresize-swap;
				}
				int x=player.pionx*getWidth()/4 + (getWidth()/4-width)/2;
				x+=xp; // on convertit squarepos en coordonnée x (modulo le nombre de colonnes)
				int y=player.piony*getHeight()/4 + (getHeight()/4-height)/2;
				y+=yp;
				g.setColor(PIECE_COLORS[i]);
				g.fillOval( x, y, squaresize, squaresize);  
				g.setColor(Color.WHITE);
				String playerPosition = String.valueOf(player.order);
				g.drawString(playerPosition, x+(int)(squaresize-fm.getStringBounds(playerPosition, g).getWidth())/2, y+(squaresize+fm.getAscent())/2);
			}
		}
 
		int ddice = dice;
		if ( ddice>0 ) { // s'il y a un dé tiré on le dessine
			g.setColor(Color.ORANGE);
 
			// on dessine le dé centré
			int x = (getWidth()-width)/2;
			int y = (getHeight()-height)/2;
			g.fillRoundRect(x, y, width, height, width/10, width/10);
 
			// dessin des points
			int ray = width/10;
			g.setColor(Color.BLACK);
			if ( ddice==1 || ddice==5 || ddice==3 ) {
				// point au centre
				g.fillOval(getWidth()/2 - ray, getHeight()/2 - ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à gauche
				g.fillOval(x+ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à droite
				g.fillOval(x+width-3*ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à gauche
				g.fillOval(x+ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à droite
				g.fillOval(x+width-3*ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==6 ) {
				// point à gauche et à droite
				g.fillOval(x+ray, getHeight()/2 - ray, ray*2, ray*2);
				g.fillOval(x+width-3*ray, getHeight()/2 - ray, ray*2, ray*2);
			}
		}
	}
 
	private static class Piece {
		public int order=1;
		public int pionpos = 0;
		public int pionx = 0;
		public int piony = 0;
 
		public int getPosition() {
			return pionpos;
		}
 
		private void movePiece(int dice) {
			pionpos += dice;
			// on convertit la position du pion en coordonnée de cases, parce que c'est bien plus simple à gérer que des coordonnées en pixels
 
	               // la grille 4x4 de cases est comme cela
 
	               // 0 11 10 9
	               // 1 x x 8
	               // 2 x x 7
	               // 3 4 5 6
 
	               // les x sont des cases de la grille où le chemin ne passe pas
	               // le chemin va de 0 à 11 = 12 cases,
 
			int xpion = pionpos%12; // permet de ramener un chemin infini à un chemin de 12 cases
 
	                // on convertit le xpion (coordonnée linéaire sur un chemin de 12 cases) vers pionx et piony, coordonnées cartésiennes dans la grille 4x4 si dessus
			if ( xpion>=0 && xpion<4 ) {
				pionx = 0;
			}
			else if ( xpion<7 ) {
				pionx = xpion-3;
			}
			else if ( xpion<10 ) {
				pionx = 3;
			}
			else {
				pionx = 12-xpion;
			}
			if ( xpion>=0 && xpion<4 ) {
				piony=xpion;
			}
			else if ( xpion<7 ) {
				piony= 3;
			}
			else if ( xpion<10 ) {
				piony=9-xpion;
			}
			else {
				piony = 0;
			}
		}
 
	}
 
	public static void main(String[] args) {
 
		String title="Entrez le nombre de joueur(s)";
		int nbPlayers;
		do {
			String response = JOptionPane.showInputDialog(null, "Nombre de joueur(s) (entre 1 et "+DicePanel.getMaxPlayers()+")", title, JOptionPane.QUESTION_MESSAGE);
			if ( response==null) System.exit(0);
			try {
				nbPlayers = Integer.parseInt(response);
			}
			catch(NumberFormatException e) {
				nbPlayers=0;
			}
			title="Réentrez le nombre de joueur(s)";
		}
		while(!(nbPlayers >0 && nbPlayers<=DicePanel.getMaxPlayers()));
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DicePanel dicePanel = new DicePanel(nbPlayers);
		frame.add(dicePanel);
 
 
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
		frame.add(buttonPanel, BorderLayout.SOUTH);
		JButton diceButton = new JButton("Joueur "+(dicePanel.getCurrentPlayer()+1)+ " joue...");
		buttonPanel.add(diceButton);
		diceButton.addActionListener(e-> {
			if ( askQuestion(frame, dicePanel.getCurrentPlayer()) ) { // si le joueur répond bien à la question, on lance le dé et on avance
				dicePanel.rollDice();
				if ( dicePanel.getCurrentPlayerPosition()>=24 ) {
					JOptionPane.showMessageDialog(frame, "Joueur " + (dicePanel.getCurrentPlayer()+1) + " a gagné" );
					System.exit(0);
				}
			}
			else { // sinon on passe au joueur suivant
				dicePanel.nextPlayer();
				diceButton.setText("Joueur "+(dicePanel.getCurrentPlayer()+1)+ " joue...");
			}
		});
 
 
		frame.setSize(400, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	private static boolean askQuestion(JFrame frame, int currentPlayer) {
		// tirer une question au hasard...
		// ici je met une question en dur juste pour l'exemple
		String question = "Une question...";
		String[] reponses = {
				"Reponse 1",
				"Reponse 2",
				"Reponse 3",
				"Reponse 4"
				};
 
		JQuestionDialog questions = new JQuestionDialog(frame, currentPlayer, question, 1, reponses);
 
		questions.setVisible(true);
 
		return questions.isOk();
 
	}
 
	private static class JQuestionDialog extends JDialog {
 
		private boolean ok;
 
		public JQuestionDialog(JFrame frame, int player, String question, int bonneReponse, String[] responses) {
			super(frame, true); // le true fait que le dialog bloque la jframe et tout ce qui se trouve dedans tant que le dialogue est visible
			setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
			setLayout(new BorderLayout());
			JTextArea questionText = new JTextArea(question);
			questionText.setEditable(false);
			questionText.setLineWrap(true);
			questionText.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
			questionText.setOpaque(false);
			add(questionText, BorderLayout.NORTH);
 
			JPanel responsePanel = new JPanel(new GridLayout(0, 1));
			ButtonGroup buttonGroup = new ButtonGroup();
			for(int i=0; i<responses.length; i++) {
				String response = responses[i];
				JRadioButton responseButton = new JRadioButton(response);
				responsePanel.add(responseButton);
				buttonGroup.add(responseButton);
				responseButton.addActionListener(e-> setResponse(response.equals(responses[bonneReponse])));
			}
			add(responsePanel);
 
			pack(); // dimensionnement automatique
			if ( getWidth()<frame.getWidth() ) {
				setSize(new Dimension(frame.getWidth(), getHeight())); //on garde la hauteur calculée automatiquement, mais on froce la largeur à au moins la largeur de la frame principal
			}
			setLocationRelativeTo(frame); // on force le centrage
			setLocation(getX(),frame.getY()+frame.getHeight()); // on repositionne la fenêtre de question pour qu'elle ne soit pas au-dessus de l'autre
		}
 
 
		public void setResponse(boolean ok) {
			this.ok = ok;
			if ( ok ) {
				JOptionPane.showMessageDialog(this, "Bravo, bonne réponse");
			}
			else {
				JOptionPane.showMessageDialog(this, "Et non, mauvaise réponse");			
			}
			dispose(); // on ferme la fenêtre
		}
 
		public boolean isOk() {
			return ok;
		}
 
	}
 
}

Ici, le joeur doit recliquer sur le bouton pour rejouer. Mais on peut se servir du thread Swing comme boucle (parce qu'en fait il fait une boucle), plutôt que de faire soi-même la boucle, ce qui est beaucoup plus compliqué (parce qu'il faut faire une boucle dans un thread à part, synchronisée avec celle de Swing, et en particulier qui est capable de se mettre en pause pour se redébloquer lorsque Swing envoie certains évenements).

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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
public class DicePanel extends JPanel {
 
	private static final Color[] PIECE_COLORS = {Color.BLUE, Color.BLACK, Color.RED, Color.GREEN.darker()};
 
	private int dice=0; // 0 signifie aucun dé tiré 
	private Piece[] players; // pions
	private int player = 0; // le joueur 1 commence
 
	public DicePanel(int nbPlayers) {
		if (nbPlayers<=0 ) {
			throw new IllegalArgumentException("Le ombre de joueurs doit être au moins 1");
		}
		if (nbPlayers>PIECE_COLORS.length ) {
			throw new IllegalArgumentException("Le nombre de maximum de joueurs est "+PIECE_COLORS.length);
		}
		players=new Piece[nbPlayers];
		for(int i=0; i<players.length; i++) {
			players[i]=new Piece();;
		}
	}
 
	public static int getMaxPlayers() {
		return PIECE_COLORS.length;
	}
 
	public void rollDice() {
		dice=ThreadLocalRandom.current().nextInt(1, 7); // on tire un dé
		players[player].movePiece(dice);
		// on détermine l'ordre des joueurs
		Piece[] order = Arrays.stream(players).sorted(Comparator.comparing(Piece::getPosition).reversed()).toArray(Piece[]::new);
		int playerorder=1;
		for(int pieceOrder=0; pieceOrder<order.length; pieceOrder++) {
			if ( pieceOrder>0 && order[pieceOrder-1].pionpos!=order[pieceOrder].pionpos ) {
				playerorder++;
			}
			order[pieceOrder].order=playerorder;
		}
		repaint(); // on rafraichît l'affichage
	}
 
	public int getDice() {
		return dice;
	}
 
	public void nextPlayer() {
		player++;
		if  (player>=players.length ) {
			player=0;
		}
	}
 
	public int getCurrentPlayer() {
		return player;
	}
 
	public Color getCurrentPlayerColor() {
		return PIECE_COLORS[player];
	}
 
	private int getCurrentPlayerPosition() {
		return players[player].pionpos;
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
 
		int width = getWidth()/4; // on dessine le dé et le pion sur le quart de la fenêtre (grille 4x4 d'où le "quart"
		int height = getHeight()/4;
		if ( width>height ) {
			width = height;
		}
		else {
			height = width;
		}
 
		// dessin des cases (chemin de 12 cases tournant autour de la grille 4x4
		g.setColor(Color.YELLOW);
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				if ( i>0 && i<3 && j>0 && j<3 ) {
					continue; // on dessine un chemin que sur les bords
				}
				g.fillRect(i*getWidth()/4 + 4 , j*getHeight()/4 + 4, getWidth()/4 - 8 , getHeight()/4 - 8);
			}
		}
 
		// dessin des pions (en faisant la conversion des x,y de cases en x,y de pixels ici
 
		// on détermine comment on va disposer les pions
		int squaregridx=(int)Math.ceil(Math.sqrt(players.length));
		int squaregridy=players.length/squaregridx;
 
		// on détermine la position de tous les pions
		if ( players.length==1 ) {
			g.setColor(PIECE_COLORS[0]);
			int x=players[0].pionx*getWidth()/4 + (getWidth()/4-width)/2;
			int y=players[0].piony*getHeight()/4 + (getHeight()/4-height)/2;
			g.fillOval( x, y, width, height);  
		}
		else {
			FontMetrics fm = g.getFontMetrics();
			int[] cases = new int[12]; // 12 cases
			for(int i=0; i<players.length; i++) {
				Piece player = players[i];
				int pionpos=player.pionpos%12; // case du pion
				int squarepos=cases[pionpos]; // la prochaine place disponible dans la case
				cases[pionpos]++; // on ajoute le pion dans la case
				// coordonnée du pion dans la case
				int squarewidth = width/squaregridx; // largeur disponible pour un pion dans la case
				int squareheight = height/squaregridy; // hauteur disponible pour un pion dans la case
				int squaresize = Math.min(squarewidth,squareheight); // on s'arrange pour que le pion ne soit pas oval
				// coordonee de la case
				int xp = (squarepos%squaregridx)*squaresize; // x du pion dans la case
				int yp = (squarepos/squaregridx)*squaresize;
				// ici, comme on tourne autour du panel, les cases changent d'orientation (elles pivotent sur la gauche de 90° à chaque angle)
				if ( pionpos>8 ) {
					int swap = xp;
					xp=squaresize-yp;
					yp=squaresize-swap;
				} else if ( pionpos>5 ) {
					yp=squaresize-yp;
				} else if ( pionpos>2 ) {
					int swap = xp;
					xp=yp;
					yp=squaresize-swap;
				}
				int x=player.pionx*getWidth()/4 + (getWidth()/4-width)/2;
				x+=xp; // on convertit squarepos en coordonnée x (modulo le nombre de colonnes)
				int y=player.piony*getHeight()/4 + (getHeight()/4-height)/2;
				y+=yp;
				g.setColor(PIECE_COLORS[i]);
				g.fillOval( x, y, squaresize, squaresize);  
				g.setColor(Color.WHITE);
				String playerPosition = String.valueOf(player.order);
				g.drawString(playerPosition, x+(int)(squaresize-fm.getStringBounds(playerPosition, g).getWidth())/2, y+(squaresize+fm.getAscent())/2);
			}
		}
 
		int ddice = dice;
		if ( ddice>0 ) { // s'il y a un dé tiré on le dessine
			g.setColor(Color.ORANGE);
 
			// on dessine le dé centré
			int x = (getWidth()-width)/2;
			int y = (getHeight()-height)/2;
			g.fillRoundRect(x, y, width, height, width/10, width/10);
 
			// dessin des points
			int ray = width/10;
			g.setColor(Color.BLACK);
			if ( ddice==1 || ddice==5 || ddice==3 ) {
				// point au centre
				g.fillOval(getWidth()/2 - ray, getHeight()/2 - ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à gauche
				g.fillOval(x+ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en haut à droite
				g.fillOval(x+width-3*ray, y+ray, ray*2, ray*2);
			}
			if ( ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à gauche
				g.fillOval(x+ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==2 || ddice==3 || ddice==4 || ddice==5 || ddice==6 ) {
				// point en bas à droite
				g.fillOval(x+width-3*ray, y+width-3*ray, ray*2, ray*2);
			}
			if ( ddice==6 ) {
				// point à gauche et à droite
				g.fillOval(x+ray, getHeight()/2 - ray, ray*2, ray*2);
				g.fillOval(x+width-3*ray, getHeight()/2 - ray, ray*2, ray*2);
			}
		}
	}
 
	private static class Piece {
		public int order=1;
		public int pionpos = 0;
		public int pionx = 0;
		public int piony = 0;
 
		public int getPosition() {
			return pionpos;
		}
 
		private void movePiece(int dice) {
			pionpos += dice;
			// on convertit la position du pion en coordonnée de cases, parce que c'est bien plus simple à gérer que des coordonnées en pixels
 
	               // la grille 4x4 de cases est comme cela
 
	               // 0 11 10 9
	               // 1 x x 8
	               // 2 x x 7
	               // 3 4 5 6
 
	               // les x sont des cases de la grille où le chemin ne passe pas
	               // le chemin va de 0 à 11 = 12 cases,
 
			int xpion = pionpos%12; // permet de ramener un chemin infini à un chemin de 12 cases
 
	                // on convertit le xpion (coordonnée linéaire sur un chemin de 12 cases) vers pionx et piony, coordonnées cartésiennes dans la grille 4x4 si dessus
			if ( xpion>=0 && xpion<4 ) {
				pionx = 0;
			}
			else if ( xpion<7 ) {
				pionx = xpion-3;
			}
			else if ( xpion<10 ) {
				pionx = 3;
			}
			else {
				pionx = 12-xpion;
			}
			if ( xpion>=0 && xpion<4 ) {
				piony=xpion;
			}
			else if ( xpion<7 ) {
				piony= 3;
			}
			else if ( xpion<10 ) {
				piony=9-xpion;
			}
			else {
				piony = 0;
			}
		}
 
	}
 
	public static void main(String[] args) {
 
		String title="Entrez le nombre de joueur(s)";
		int nbPlayers;
		do {
			String response = JOptionPane.showInputDialog(null, "Nombre de joueur(s) (entre 1 et "+DicePanel.getMaxPlayers()+")", title, JOptionPane.QUESTION_MESSAGE);
			if ( response==null) System.exit(0);
			try {
				nbPlayers = Integer.parseInt(response);
			}
			catch(NumberFormatException e) {
				nbPlayers=0;
			}
			title="Réentrez le nombre de joueur(s)";
		}
		while(!(nbPlayers >0 && nbPlayers<=DicePanel.getMaxPlayers()));
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DicePanel dicePanel = new DicePanel(nbPlayers);
		frame.add(dicePanel);
 
 
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
		frame.add(buttonPanel, BorderLayout.SOUTH);
		JButton diceButton = new JButton("Joueur "+(dicePanel.getCurrentPlayer()+1)+ " joue...");
		buttonPanel.add(diceButton);
		diceButton.addActionListener(e-> {
			if ( askQuestion(frame, dicePanel.getCurrentPlayer()) ) { // si le joueur répond bien à la question, on lance le dé et on avance
				dicePanel.rollDice();
				if ( dicePanel.getCurrentPlayerPosition()>=24 ) {
					// je joueur a gagné
					JOptionPane.showMessageDialog(frame, "Joueur " + (dicePanel.getCurrentPlayer()+1) + " a gagné" );
					System.exit(0);
				}
				else {
					diceButton.doClick(); // le même joueur rejoue
				}
			}
			else { // sinon on passe au joueur suivant
				dicePanel.nextPlayer();
				diceButton.setText("Joueur "+(dicePanel.getCurrentPlayer()+1)+ " joue...");
			}
		});
 
 
		frame.setSize(400, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	private static boolean askQuestion(JFrame frame, int currentPlayer) {
		// tirer une question au hasard...
		// ici je met une question en dur juste pour l'exemple
		String question = "Une question...";
		String[] reponses = {
				"Reponse 1",
				"Reponse 2",
				"Reponse 3",
				"Reponse 4"
				};
 
		JQuestionDialog questions = new JQuestionDialog(frame, currentPlayer, question, 1, reponses);
 
		questions.setVisible(true);
 
		return questions.isOk();
 
	}
 
	private static class JQuestionDialog extends JDialog {
 
		private boolean ok;
 
		public JQuestionDialog(JFrame frame, int player, String question, int bonneReponse, String[] responses) {
			super(frame, true); // le true fait que le dialog bloque la jframe et tout ce qui se trouve dedans tant que le dialogue est visible
			setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
			setLayout(new BorderLayout());
			JTextArea questionText = new JTextArea(question);
			questionText.setEditable(false);
			questionText.setLineWrap(true);
			questionText.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
			questionText.setOpaque(false);
			add(questionText, BorderLayout.NORTH);
 
			JPanel responsePanel = new JPanel(new GridLayout(0, 1));
			ButtonGroup buttonGroup = new ButtonGroup();
			for(int i=0; i<responses.length; i++) {
				String response = responses[i];
				JRadioButton responseButton = new JRadioButton(response);
				responsePanel.add(responseButton);
				buttonGroup.add(responseButton);
				responseButton.addActionListener(e-> setResponse(response.equals(responses[bonneReponse])));
			}
			add(responsePanel);
 
			pack(); // dimensionnement automatique
			if ( getWidth()<frame.getWidth() ) {
				setSize(new Dimension(frame.getWidth(), getHeight())); //on garde la hauteur calculée automatiquement, mais on froce la largeur à au moins la largeur de la frame principal
			}
			setLocationRelativeTo(frame); // on force le centrage
			setLocation(getX(),frame.getY()+frame.getHeight()); // on repositionne la fenêtre de question pour qu'elle ne soit pas au-dessus de l'autre
		}
 
 
		public void setResponse(boolean ok) {
			this.ok = ok;
			if ( ok ) {
				JOptionPane.showMessageDialog(this, "Bravo, bonne réponse");
			}
			else {
				JOptionPane.showMessageDialog(this, "Et non, mauvaise réponse");			
			}
			dispose(); // on ferme la fenêtre
		}
 
		public boolean isOk() {
			return ok;
		}
 
	}
 
}

**peggy67** · 22/05/2017, 09h23

Merci, mais du coup si on veut une bibliothèque avec des 100taines de questions et en tirer une au hasard à chaque fois je fais comment ? parce que là y a que le cas pour une seule question

**joel.drigo** · 22/05/2017, 09h41

Et bien tu fais une classe Question.

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
public class Question {
 
    public String question;
    public String[] reponses;
    public int bonneReponse;
 
public Question(String question, int bonneReponse, String...reponses) {
   this.question=question;
   this.bonneReponse=bonneReponse;
   this.reponses=reponses;
}
 
public static Question getQuestion() {
             // tirer une question au hasard
             return ...
    }
 
}

Et tu remplaces ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
// tirer une question au hasard...
		// ici je met une question en dur juste pour l'exemple
		String question = "Une question...";
		String[] reponses = {
				"Reponse 1",
				"Reponse 2",
				"Reponse 3",
				"Reponse 4"
				};
 
		JQuestionDialog questions = new JQuestionDialog(frame, currentPlayer, question, 1, reponses);

par :

Code :

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

1
2
3
4
5
Question question = Question.getQuestion();
	String question = question.question;
		String[] reponses = questions.reponses;
 
		JQuestionDialog questions = new JQuestionDialog(frame, currentPlayer, question, question.bonneReponse, reponses);

Pour stocker les questions afin de pouvoir en tirer une hasard, il y a plein de solutions. Et ça dépend de ce que vous voulez faire. Par exemple, si le but est d'avoir une liste de questions uniques, que toute le monde se partage, on peut utiliser une liste :

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
public class Question {
 
    public String question;
    public String[] reponses;
    public int bonneResponse;
 
    private static List<Question> questions;
 
public Question(String question, int bonneReponse, String...reponses) {
   this.question=question;
   this.bonneReponse=bonneReponse;
   this.reponses=responses;
}
 
public static void initialiser() {
     questions = chargerLesQuestions();
     Collections.shuffle(questions); // mélanger les questions
}
 
public static int getQuestionsRestantes() {
             return questions.size();
    }
 
public static Question getQuestion() {
             // attention, si plus de questions, ça  provoque une erreur : à voir comment ça se gère
             return questions.remove(0);
    }
 
 
}

et pour chargerLesQuestions() il y a plein de solutions. On peut les créer en dur dans le code :

Code :

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

1
2
3
4
5
6
7
8
9
private List<Question> chargerQuestion() {
     List<Question> questions = new ArrayList<>();
     questions.add(new Question("question 1", 1, "reponse 1", "reponse 2", "reponse 3");
     questions.add(new Question("question 2", 3, "reponse 1", "reponse 2", "reponse 3","reponse 4");
     questions.add(new Question("question 1", 1, "reponse 1", "reponse 2", "reponse 3");
     questions.add(new Question("question 1", 0, "reponse 1", "reponse 2");
     /*...*/
    return questions;
}

Ou les charger depuis un fichier texte, un xml, une base de données etc.

**peggy67** · 22/05/2017, 10h19

Je me demandais : à quoi sert exactement les ... dans le public Question puis dans le return ? Quel est son role ? parce que je n'arrive pas à faire marcher votre programme ..

Merci

**joel.drigo** · 22/05/2017, 10h38

Tu parles de ceux qui sont là public Question(String question, int bonneReponse, String...reponses) { ?

Cela permettre d'indiquer un paramètre dont le nombre n'est pas déterminé d'avance.
On peut écrire new Question("...", 1, "1","2","3"); ou new Question("...", 1, "1","2"); ou new Question("...", 1, "1","2","3","4");, et même new Question("...", 1);Dans la méthode (ou constructeur), ça se traite comme un tableau.

Code :

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

1
2
3
4
5
public void exemple(String...strings) {
   for(int i=0, i<strings.length; i++) {
        System.out.println(strings[i]);
   }
}

Si c'est de ce genre de ... que tu parles :

Code :

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

1
2
3
4
public static Question getQuestion() {
             // tirer une question au hasard
             return ...
    }

ça c'est juste pour dire que ça peut être n'importe quoi comme code : c'est à toi de remplacer les ... par ce que tu veux en fonction de ce que tu veux. Parce que je n'ai pas toujours le temps d'écrire les 3 milliards de solutions possibles pour faire un truc. Dans mon message, je donne unedes solutions possibles pour cette partie un peu plus loin.

PS il y avait une petite faute de frappe dans mon exemple (dans la ligne this.reponses=responses;, c'est this.reponses=reponses;), et c'est pour ça que ça ne compile pasa)

**peggy67** · 22/05/2017, 10h43

Merci beaucoup pour l'explication.
J'avais deja modifié les responses par reponses, mais cela ne compile toujours pas .. Je ne comprends pas pourquoi
Nom : Captuuuuuure.GIF
Affichages : 2815
Taille : 23,7 Ko

Nom : Captuuuuuure.GIF
Affichages : 2815
Taille : 23,7 Ko

**peggy67** · 22/05/2017, 10h44

AH mince ! du coup j'ai oublié de remplacer ! Pardon

**joel.drigo** · 22/05/2017, 10h49

Tu as sûrement remarqué que je postais mon code en texte et pas en image, ce qui te permet de facilement copier/coller le code dans ton EDI. Et bien, ce serait bien que éventuellement cela soit pareil pour moi. Pour faire ça voir ici.

Déplacer un pion en java

Java

Discussions similaires

Partager

Partager