Discussion :

[peggy67]

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]

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]

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]

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

[peggy67]

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]

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.

1. 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.
2. 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.
3. 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