Naviguer entre JPanel

Version imprimable

18/10/2019, 18h56
daprog

Naviguer entre JPanel

Bonjour,

J'ai mon applicationqui contient une page principal, un bouton qui permet de changer de JPanel pour le contentPane que j'ai définit dans une classe dans un autre fichier, et depuis cette nouvelle classe j'aimerais y inclure un bouton permettant de rechanger le JPanel du contentPane de ma JFrame principale, sauf que le problème est que vu que je suis dans une classe de JPanel je peux pas accéder à ma méthode setContentPane de ma JFrame. Quelqu'un saurais?
18/10/2019, 21h02
joel.drigo

Salut,

On peut accéder à la JFrame par SwingUtilities.getWindowAncestor(panel). On peut aussi faire une classe qui étends JPanel et à la construction passer la référence de ce qu'on a besoin.

Sinon, plutôt que de changer le contenu du content pane, ou, pire, le content pane, à chaque fois, utiliser un CardLayout. Le JPanel n'a plus besoin de savoir qui est son parent : c'est juste le bouton qui a besoin de connaître le conteneur et le cardlayout (la sélection du panel à afficher se fait par id). On a pas besoin de faire une classe spéciale : il suffit que le builder sache où ajouter le bouton dans le panel.
19/10/2019, 01h22
daprog

Ok, merci beaucoup!

J'ai opter pour un CardLayout, comment faire pour l'importer dans mes autres JPanel, afin de mettre un ecran "Game over" dès que le joueur a perdu, j'ai tenter de mettre un getCardsLayout dans mon panel CardLayout et un getContentPane, je les importe tout les deux dans mon JPanel, je fait un show dès que le joueur a perdu, mais ça me met un NullPointerException,

Je sais pas trop comment medébrouiller la :/
C'est possible que j'ai mal importer mon cl et contentpane, j'ai mis des static un peu partout je sais pas si c'est bien,

ça me donne l'impression que mon cl ne contient pas de JPanel.

Pour afficher le panneau désiré, il suffit de connaître le conteneur (le composant qui a le CardLayout) et l'id/nom de panneau. Avec un petit composant d'encapsulation (qu'on peut récupérer par une méthode static si la JFrame principale qui contient le conteneur est crée dans la méthode main (elle est donc comme static, même si sa référence n'est pas récupérable).

Exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class CardLayoutExample {
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		// un panneau pour y mettre les différents composants à afficher, avec un cardlayout
		CardLayout cardLayout = new CardLayout();
		JPanel panel = new JPanel(cardLayout);
		frame.getContentPane().add(panel); // on le met au centre du content pane de la fenêtre pour qu'il soit affiché
 
		ActionListenerBuilder builder = new ActionListenerBuilder(panel, cardLayout);
 
		panel.add(createPanel1(builder),"red");
		panel.add(createPanel2(builder),"yellow");
		panel.add(createPanel3(builder),"green");
 
		frame.setSize(600, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true); 
 
	}
 
	private static Component createPanel1(ActionListenerBuilder builder) {
		JPanel panel = new JPanel(new BorderLayout());
		panel.setBackground(Color.RED);
		JPanel buttonPanel = new JPanel();
		{
			JButton button = new JButton("Afficher jaune");
			button.addActionListener(builder.create("yellow"));
			buttonPanel.add(button);
		}
		{
			JButton button = new JButton("Afficher dernier (vert)");
			button.addActionListener(builder.createLast());
			buttonPanel.add(button);
		}
		panel.add(buttonPanel, BorderLayout.SOUTH);
		return panel;
	}
 
	private static Component createPanel2(ActionListenerBuilder builder) {
		JPanel panel = new JPanel(new GridBagLayout());
		panel.setBackground(Color.YELLOW);
		GridBagConstraints gbc = new GridBagConstraints();
		gbc.insets = new Insets(5, 5, 5, 5);
		for(int i=0; i<9; i++) {
			JComponent component;
			switch ( i ) {
			case 4: {
				JButton button = new JButton("Afficher rouge");
				button.addActionListener(builder.create("red"));
				component = button;
				}
				break;
			case 8: {
				JButton button = new JButton("Afficher vert");
				button.addActionListener(builder.create("green"));
				component = button;
				}
				break;
			default:
				component = new JLabel();
			}
			gbc.gridx=i%3;
			gbc.gridy=i/3;
			panel.add(component, gbc);
		} 
		return panel;
	}
 
	private static Component createPanel3(ActionListenerBuilder builder) {
		JPanel panel = new JPanel(new GridBagLayout());
		panel.setBackground(Color.GREEN);
		JButton button = new JButton("Précédent (jaune)");
		button.addActionListener(builder.createPrevious());
		panel.add(button);
		return panel;
	}
 
	public static class ActionListenerBuilder {
 
		private final JPanel panel;
		private final CardLayout cardLayout;
 
		public ActionListenerBuilder(JPanel panel, CardLayout cardLayout) {
			this.panel=panel;
			this.cardLayout=cardLayout;
		}
 
		public ActionListener create(String name) {
			return e-> cardLayout.show(panel, name);
		}
 
		public ActionListener createPrevious() {
			return e-> cardLayout.previous(panel);
		}
 
		public ActionListener createNext() {
			return e-> cardLayout.next(panel);
		}
 
		public ActionListener createFirst() {
			return e-> cardLayout.first(panel);
		}
 
		public ActionListener createLast() {
			return e-> cardLayout.last(panel);
		}
 
	}
 
}

Au lieu d'une méthode statique, si on a par exemple plusieurs JFrame, on peut stocker dans un composant ce composant d'encapsulation, cela forme un contexte, qu'on peut accèder via les méthodes utilitaires de SwingUtilities. Le souci c'est que ça oblige que le composant soit dans son parent, qui doit être éventuellement dans son parent, éventuellement dans sa fenêtre...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionListener;
import java.awt.event.ContainerAdapter;
import java.awt.event.ContainerEvent;
import java.awt.event.HierarchyBoundsListener;
import java.awt.event.HierarchyEvent;
import java.awt.event.HierarchyListener;
import java.util.function.Function;
 
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.text.rtf.RTFEditorKit;
 
public class CardLayoutExample {
 
	public static final String MAIN_CONTAINER = "maincontainer";
	public static final String ACTION_BUILDER = "actionbuilder";
	private static final String ACTION_REGISTERED = "actionregistered";
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		// un panneau pour y mettre les différents composants à afficher, avec un cardlayout
		CardLayout cardLayout = new CardLayout();
		JPanel panel = new JPanel(cardLayout);
		frame.getContentPane().add(panel); // on le met au centre du content pane de la fenêtre pour qu'il soit affiché
 
		panel.setName(MAIN_CONTAINER);// je donne un nom
 
		ActionListenerBuilder builder = new ActionListenerBuilder(panel, cardLayout);
		panel.putClientProperty(ACTION_BUILDER, builder);
 
		panel.add(createPanel1(),"red");
		panel.add(createPanel2(),"yellow");
		panel.add(createPanel3(),"green");
 
		frame.setSize(600, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true); 
 
	}
 
	private static Component createPanel1() {
		JPanel panel = new JPanel(new BorderLayout());
		panel.setBackground(Color.RED);
		JPanel buttonPanel = new JPanel();
		{
			JButton button = new JButton("Afficher jaune");
			button.addHierarchyListener(e-> create(button, builder->builder.create("yellow")));
			buttonPanel.add(button);
		}
		{
			JButton button = new JButton("Afficher dernier (vert)");
			button.addHierarchyListener(e-> create(button, builder->builder.createLast()));
			buttonPanel.add(button);
		}
		panel.add(buttonPanel, BorderLayout.SOUTH);
		return panel;
	}
 
	protected static void create(JButton button, Function<ActionListenerBuilder,ActionListener> buildingFunction) {
		Boolean register = (Boolean) button.getClientProperty(ACTION_REGISTERED); 
		if ( register!=null && register.booleanValue() ) {
			return;
		}
		Container container = SwingUtilities.getAncestorNamed(MAIN_CONTAINER, button);
		if ( container==null ) {
			return;
		}
		ActionListenerBuilder builder = (ActionListenerBuilder) ((JComponent)container).getClientProperty(ACTION_BUILDER); 
		button.addActionListener(buildingFunction.apply( builder ));
		button.putClientProperty(ACTION_REGISTERED, Boolean.TRUE);
	}
 
	private static Component createPanel2() {
		JPanel panel = new JPanel(new GridBagLayout());
		panel.setBackground(Color.YELLOW);
		GridBagConstraints gbc = new GridBagConstraints();
		gbc.insets = new Insets(5, 5, 5, 5);
		for(int i=0; i<9; i++) {
			JComponent component;
			switch ( i ) {
			case 4: {
				JButton button = new JButton("Afficher rouge"); 
				button.addHierarchyListener(e-> create(button, builder->builder.create("red")));
				component = button;
				}
				break;
			case 8: {
				JButton button = new JButton("Afficher vert");
				button.addHierarchyListener(e-> create(button, builder->builder.create("green"))); 
				component = button;
				}
				break;
			default:
				component = new JLabel();
			}
			gbc.gridx=i%3;
			gbc.gridy=i/3;
			panel.add(component, gbc);
		} 
		return panel;
	}
 
	private static Component createPanel3() {
		JPanel panel = new JPanel(new GridBagLayout());
		panel.setBackground(Color.GREEN);
		JButton button = new JButton("Précédent (jaune)"); 
		panel.addHierarchyListener(e-> create(button, builder->builder.createPrevious())); 
		panel.add(button);
		return panel;
	}
 
	public static class ActionListenerBuilder {
 
		private final JPanel panel;
		private final CardLayout cardLayout;
 
		public ActionListenerBuilder(JPanel panel, CardLayout cardLayout) {
			this.panel=panel;
			this.cardLayout=cardLayout;
		}
 
		public ActionListener create(String name) {
			return e-> cardLayout.show(panel, name);
		}
 
		public ActionListener createPrevious() {
			return e-> cardLayout.previous(panel);
		}
 
		public ActionListener createNext() {
			return e-> cardLayout.next(panel);
		}
 
		public ActionListener createFirst() {
			return e-> cardLayout.first(panel);
		}
 
		public ActionListener createLast() {
			return e-> cardLayout.last(panel);
		}
 
	}
 
}

Citation:

Envoyé par daprog

[...] je fait un show dès que le joueur a perdu, mais ça me met un NullPointerException,

[...]

Difficile de répondre sans le code.

Dans le cas "tout les panel dans le même fichier" je comprends bien, le problème est que j'ai plusieurs fichier, chacun représentant un Panel et un avec la JFrame et le cardLayout. Désolé, jeme suis peut être mal exprimé,vous avez raisons je vais mettre du code:

ça c'est ma JFrame :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import java.awt.CardLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class Fenetre extends JFrame{
	static JPanel contentPane;
	static CardLayout cardLayout = new CardLayout();
	JPanel MainWindow = new MainWindow();
	JPanel Game = new Game();
	JPanel GameOver = new GameOver();
	JButton play = ((MainWindow) MainWindow).getButton();
 
	public Fenetre(){
		this.setLocationRelativeTo(null);
		this.setTitle("Le PENDU");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setSize(1000, 800);
 
		contentPane = new JPanel();
		contentPane.setLayout(cardLayout);
 
		contentPane.add(MainWindow, "Page Principale");
		contentPane.add(Game, "Page 1");
		contentPane.add(GameOver, "Page 2");
		play.addActionListener(new ActionL());
		cardLayout.show(contentPane, "Page Principale");
		this.setContentPane(contentPane);
		this.setVisible(true);
	}
 
	public static CardLayout getCl() {
		return cardLayout;
	}
 
	public static JPanel getCont() {
		return contentPane;
	}
 
	class ActionL implements ActionListener{
		public void actionPerformed(ActionEvent e) {
			String src= ((JButton)e.getSource()).getText();
			System.out.println(src);
 
			if(src == "Play") {
				cardLayout.show(contentPane, "Page 1");
			}
		}
	}
}

et ça c'est l'une de mes JPanel :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
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
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
 
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
import java.util.ArrayList;
 
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
class Game extends JPanel{
	JLabel header = new JLabel("Nombre de mot trouvé : 0Votre score actuel est de : 0");
	JLabel mot = new JLabel("***********");
	JPanel lettres = new Clavier();
	String motmystere;
	String mm;
	Boolean jeu =  true;
	Boolean go = false;
	Boolean debut = false;
	JButton ready = new JButton("ready?");
	String motetoile;
	CardLayout cl = Fenetre.getCl();
	JPanel cont = Fenetre.getCont();
	boolean perdu = false;
	int nberreur = 0;
	int score = 0;
	char car = '1';
 
	public Game() {
		this.setSize(1000, 800);
 
 
		JPanel colonne1 = new JPanel();
		colonne1.setBackground(Color.white);
		colonne1.setLayout(new BoxLayout(colonne1, BoxLayout.PAGE_AXIS));
 
		Font font = new Font("Arial",Font.BOLD,12);
		header.setFont(font);
		header.setBackground(Color.white);
		header.setOpaque(true);
		header.setPreferredSize(new Dimension(100,100));
		colonne1.add(header);
 
		Font font2 = new Font("Arial", Font.BOLD, 24);
		mot.setFont(font2);
		mot.setForeground(Color.blue);
		mot.setBackground(Color.white);
		mot.setOpaque(true);
		mot.setPreferredSize(new Dimension(100,20));
		colonne1.add(mot);
 
		ready.addActionListener(new launch());
		colonne1.add(ready);
		colonne1.add(lettres);
 
		JPanel colonne2 = new JPanel();
		colonne2.setBackground(Color.white);
		colonne2.setLayout(new BoxLayout(colonne2, BoxLayout.PAGE_AXIS));
		PanneauPendu pp = new PanneauPendu();
		pp.setWidth(0);
		pp.setHeight(0);
		colonne2.add(pp);
 
 
 
		this.setLayout(new BoxLayout(this, BoxLayout.LINE_AXIS));
		this.setBackground(Color.white);
		this.add(colonne1);
		this.add(colonne2);
	}
 
	public boolean getPerdu() {
		return perdu;
	}
 
 
	public class RunImpl implements Runnable {
		  private String name;
 
		  public RunImpl(String name){
		    this.name = name;
		  }
 
		  public void run() {
			  int i = 0;
			  String motmyst = String(motmystere.length(), "*");
			  mot.setText(motmyst);
			  while (i == 0) {
				  System.out.println("tour : " + i);
				  System.out.println("go : " + go);
				  if (motmystere.indexOf(car) != -1) {
					  identifychar(motmystere, car);
				  }
				  else nberreur++;
				  go = false;
			  }
			  jeu = false;
		}
	}
 
	public class launch implements ActionListener{
		public void actionPerformed(ActionEvent e) {
			motmystere = chmm();
			motetoile = String(motmystere.length(), "*");
			mot.setText(motetoile);
			System.out.println(motmystere);
		}
	}
 
	public String chmm() {
		int nbre = (int)(Math.random()*336529);
		String mm= "aaa";
		try {
			LineNumberReader lnr = new LineNumberReader(new FileReader("dictionnaire.txt"));
			String s = "aaa";
			try {
				s = lnr.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			while (s != null){
				if (lnr.getLineNumber() == nbre){
				mm = s;}
			    try {
					s = lnr.readLine();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		return mm;
	}
 
	public String String(int c, String st) {
		String s = "";
		int i = 0;
		while (i < c){
			s = s + st;
			i++;
		}
		return s;
	}
 
	public static ArrayList<Integer> findIndexes(String searchableString, char keyword){
 
		int index = searchableString.indexOf(keyword);
		ArrayList<Integer> TabIndex = new ArrayList<>();
		TabIndex.add(index);
	    while (index >= 0){
	        index = searchableString.indexOf(keyword, index+1);
	        if(index != -1) TabIndex.add(index);
	    }
	    return TabIndex;
	}
 
	public void identifychar(String mm, char car) {
		ArrayList<Integer> indexes = findIndexes(motmystere, car);
		StringBuffer buffer = new StringBuffer(mm);
		for(int i:indexes) buffer.setCharAt(i, car);
		motetoile = buffer.toString();
		mot.setText(buffer.toString());
	}
 
 
	public class recupchar implements ActionListener{
		public void actionPerformed(ActionEvent e) {
			car = ((JButton)e.getSource()).getText().charAt(0);
			go = true;
			debut = true;
			System.out.println("proposition: " + car);
			if (motmystere.indexOf(car) != -1) {
				identifychar(motetoile, car);
			}
			else{
				nberreur++;
			}
 
			System.out.println(nberreur);
			System.out.println(motetoile);
			System.out.println(motmystere);
 
			if (nberreur == 7) {
				System.out.println("GameOver");
				perdu = true;
				cl.first(cont);
			}
			if (motetoile.indexOf('*') == -1) {
				System.out.println("Gagné bravo!!");
				motmystere = chmm();
				motetoile = String(motmystere.length(), "*");
				mot.setText(motetoile);
				System.out.println(motmystere);
			}
		}
	}
 
	class Clavier extends JPanel{
 
 
	public Clavier() {
		recupchar rc = new recupchar();
		this.setPreferredSize(new Dimension(200,120));
		this.setBackground(Color.white);
 
		JButton a = new JButton("a");
	    a.setBackground(Color.YELLOW);
	    a.setPreferredSize(new Dimension(60, 40));
	    a.addActionListener(rc);
 
	    JButton z = new JButton("z");
	    z.setBackground(Color.YELLOW);
	    z.setPreferredSize(new Dimension(60, 40));
	    z.addActionListener(rc);
 
	    JButton e = new JButton("e");
	    e.setBackground(Color.YELLOW);
	    e.setPreferredSize(new Dimension(60, 40));
	    e.addActionListener(rc);
 
	    JButton r = new JButton("r");
	    r.setBackground(Color.YELLOW);
	    r.setPreferredSize(new Dimension(60, 40));
	    r.addActionListener(rc);
 
	    JButton t = new JButton("t");
	    t.setBackground(Color.YELLOW);
	    t.setPreferredSize(new Dimension(60, 40));
	    t.addActionListener(rc);
 
	    JButton y = new JButton("y");
	    y.setBackground(Color.YELLOW);
	    y.setPreferredSize(new Dimension(60, 40));
	    y.addActionListener(rc);
 
	    JButton u = new JButton("u");
	    u.setBackground(Color.YELLOW);
	    u.setPreferredSize(new Dimension(60, 40));
	    u.addActionListener(rc);
 
	    JButton i = new JButton("i");
	    i.setBackground(Color.YELLOW);
	    i.setPreferredSize(new Dimension(60, 40));
	    i.addActionListener(rc);
 
	    JButton o = new JButton("o");
	    o.setBackground(Color.YELLOW);
	    o.setPreferredSize(new Dimension(60, 40));
	    o.addActionListener(rc);
 
	    JButton p = new JButton("p");
	    p.setBackground(Color.YELLOW);
	    p.setPreferredSize(new Dimension(60, 40));
	    p.addActionListener(rc);
 
	    JButton q = new JButton("q");
	    q.setBackground(Color.YELLOW);
	    q.setPreferredSize(new Dimension(60, 40));
	    q.addActionListener(rc);
 
	    JButton s = new JButton("s");
	    s.setBackground(Color.YELLOW);
	    s.setPreferredSize(new Dimension(60, 40));
	    s.addActionListener(rc);
 
	    JButton d = new JButton("d");
	    d.setBackground(Color.YELLOW);
	    d.setPreferredSize(new Dimension(60, 40));
	    d.addActionListener(rc);
 
	    JButton f = new JButton("f");
	    f.setBackground(Color.YELLOW);
	    f.setPreferredSize(new Dimension(60, 40));
	    f.addActionListener(rc);
 
	    JButton g = new JButton("g");
	    g.setBackground(Color.YELLOW);
	    g.setPreferredSize(new Dimension(60, 40));
	    g.addActionListener(rc);
 
	    JButton h = new JButton("h");
	    h.setBackground(Color.YELLOW);
	    h.setPreferredSize(new Dimension(60, 40));
	    h.addActionListener(rc);
 
	    JButton j = new JButton("j");
	    j.setBackground(Color.YELLOW);
	    j.setPreferredSize(new Dimension(60, 40));
	    j.addActionListener(rc);
 
	    JButton k = new JButton("k");
	    k.setBackground(Color.YELLOW);
	    k.setPreferredSize(new Dimension(60, 40));
	    k.addActionListener(rc);
 
	    JButton l = new JButton("l");
	    l.setBackground(Color.YELLOW);
	    l.setPreferredSize(new Dimension(60, 40));
	    l.addActionListener(rc);
 
	    JButton m = new JButton("m");
	    m.setBackground(Color.YELLOW);
	    m.setPreferredSize(new Dimension(60, 40));
	    m.addActionListener(rc);
 
	    JButton w = new JButton("w");
	    w.setBackground(Color.YELLOW);
	    w.setPreferredSize(new Dimension(60, 40));
	    w.addActionListener(rc);
 
	    JButton x = new JButton("x");
	    x.setBackground(Color.YELLOW);
	    x.setPreferredSize(new Dimension(60, 40));
	    x.addActionListener(rc);
 
	    JButton c = new JButton("c");
	    c.setBackground(Color.YELLOW);
	    c.setPreferredSize(new Dimension(60, 40));
	    c.addActionListener(rc);
 
	    JButton v = new JButton("v");
	    v.setBackground(Color.YELLOW);
	    v.setPreferredSize(new Dimension(60, 40));
	    v.addActionListener(rc);
 
	    JButton b = new JButton("b");
	    b.setBackground(Color.YELLOW);
	    b.setPreferredSize(new Dimension(60, 40));
	    b.addActionListener(rc);
 
	    JButton n = new JButton("n");
	    n.setBackground(Color.YELLOW);
	    n.setPreferredSize(new Dimension(60, 40));
	    n.addActionListener(rc);
 
	    GridBagConstraints gbc = new GridBagConstraints();
 
	    gbc.gridx = 0;
	    gbc.gridy = 0;
 
	    gbc.gridheight = 1;
	    gbc.gridwidth = 1;
 
	    this.add(a, gbc);
 
	    gbc.gridx = 1;
	    this.add(z, gbc);
 
	    gbc.gridx = 2;
	    this.add(e, gbc);
 
	    gbc.gridx = 3;
	    this.add(r, gbc);
 
	    gbc.gridx = 4;
	    this.add(t, gbc);
 
	    gbc.gridx = 5;
	    this.add(y, gbc);
 
	    gbc.gridx = 6;
	    this.add(u, gbc);
 
	    gbc.gridx = 7;
	    this.add(i, gbc);
 
	    gbc.gridx = 8;
	    this.add(o, gbc);
 
	    gbc.gridwidth= GridBagConstraints.REMAINDER;
	    gbc.gridx = 9;
	    this.add(p, gbc);
 
	    gbc.gridx = 0;
	    gbc.gridy = 1;
	    gbc.gridheight = 1;
	    gbc.gridwidth = 1;
 
	    this.add(q, gbc);
 
	    gbc.gridx = 1;
	    this.add(s, gbc);
 
	    gbc.gridx = 2;
	    this.add(d, gbc);
 
	    gbc.gridx = 3;
	    this.add(f, gbc);
 
	    gbc.gridx = 4;
	    this.add(g, gbc);
 
	    gbc.gridx = 5;
	    this.add(h, gbc);
 
	    gbc.gridx = 6;
	    this.add(j, gbc);
 
	    gbc.gridx = 7;
	    this.add(k, gbc);
 
	    gbc.gridx = 8;
	    this.add(l, gbc);
 
	    gbc.gridwidth= GridBagConstraints.REMAINDER;
	    gbc.gridx = 9;
	    this.add(m, gbc);
 
	    gbc.gridx = 0;
	    gbc.gridy = 2;
	    gbc.gridheight = 1;
	    gbc.gridwidth = 1;
 
	    this.add(w, gbc);
 
	    gbc.gridx = 1;
	    this.add(x, gbc);
 
	    gbc.gridx = 2;
	    this.add(c, gbc);
 
	    gbc.gridx = 3;
	    this.add(v, gbc);
 
	    gbc.gridx = 4;
	    this.add(b, gbc);
 
	    gbc.gridx = 5;
	    this.add(n, gbc);
	    gbc.gridwidth= GridBagConstraints.REMAINDER;
	}
}
}

Une erreur intervient quand j'ai 7 erreurs dans mon actionListener, j'ai tout essayé mais il me dise NullPointerException, J'aimerais pouvoir importer mon cardLayout sans problème, pour pouvoir l'utiliser dans chacune de mes JPanel.

Plusieurs classes, pas plusieurs fichiers. Et ça ne change pas grand chose...

Au lieu de

Code:

JPanel GameOver = new GameOver ();

tu fais

Code:

GameOver GameOver = new GameOver ();

et tu ajoutes un accesseur sur le bouton ou un consumer à la classe GameOver (enfin je suppose que cette classe, parce que j'en ai pas le code)
1. un accesseur te permettra de récupérer le bouton et d'ajouter l'action listener
  Code:
  
  1 2 3 public JButton getButton() { return button; }
2. ou une méthode qui ajoute directement l'action listener et tout ce qui va bien sur le bouton prévu pour
  Code:
  
  1 2 3 public void addActionListener(ActionListener listener) { button.addActionListener(listener); }

autre solution (enfin une des autres) : passage de paramètre au constructeur

Code:

1
2
3
public GameOver(ActionBuilder actionBuilder) {
    // ici le code qui créé le bouton est associe l'action listener
}

J'ai changé mon code pour montrer le principe (et que ça ne change pas grand chose, ici les classes sont internes statiques, mais si elles étaient déclarées dans un autre fichier ce serait exactement pareil (les différences ne concernent pas le principe en lui-même) ) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
public class CardLayoutExample {
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		// un panneau pour y mettre les différents composants à afficher, avec un cardlayout
		CardLayout cardLayout = new CardLayout();
		JPanel panel = new JPanel(cardLayout);
		frame.getContentPane().add(panel); // on le met au centre du content pane de la fenêtre pour qu'il soit affiché
 
		ActionListenerBuilder builder = new ActionListenerBuilder(panel, cardLayout);
 
		panel.add(new RedPanel(builder),"red");
		panel.add(new YellowPanel(builder),"yellow");
		panel.add(new GreenPanel(builder),"green");
 
		frame.setSize(600, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true); 
 
	}
 
        // pourrait être déclarée dans RedPanel.java, en public class
	private static class RedPanel extends JPanel {
		public RedPanel(ActionListenerBuilder builder) {
			super(new BorderLayout());
			setBackground(Color.RED);
			JPanel buttonPanel = new JPanel();
			{
				JButton button = new JButton("Afficher jaune");
				button.addActionListener(builder.create("yellow"));
				buttonPanel.add(button);
			}
			{
				JButton button = new JButton("Afficher dernier (vert)");
				button.addActionListener(builder.createLast());
				buttonPanel.add(button);
			}
			add(buttonPanel, BorderLayout.SOUTH);
		}
	}
 
        // pourrait être déclarée dans YellowPanel.java, en public class
	private static class YellowPanel extends JPanel {
		public YellowPanel(ActionListenerBuilder builder) {
			super(new GridBagLayout());
			setBackground(Color.YELLOW);
			GridBagConstraints gbc = new GridBagConstraints();
			gbc.insets = new Insets(5, 5, 5, 5);
			for(int i=0; i<9; i++) {
				JComponent component;
				switch ( i ) {
				case 4: {
					JButton button = new JButton("Afficher rouge");
					button.addActionListener(builder.create("red"));
					component = button;
					}
					break;
				case 8: {
					JButton button = new JButton("Afficher vert");
					button.addActionListener(builder.create("green"));
					component = button;
					}
					break;
				default:
					component = new JLabel();
				}
				gbc.gridx=i%3;
				gbc.gridy=i/3;
				add(component, gbc);
			}  
		}
	}
 
 
        // pourrait être déclarée dans GreenPanel.java, en public class
	private static class GreenPanel extends JPanel {
 
		public GreenPanel(ActionListenerBuilder builder) {
			super(new GridBagLayout());
			setBackground(Color.GREEN);
			JButton button = new JButton("Précédent (jaune)");
			button.addActionListener(builder.createPrevious());
			add(button);
		}
 
	}
 
        // pourrait être déclarée dans ActionListenerBuilder.java, en public class 
	public static class ActionListenerBuilder {
 
		private final JPanel panel;
		private final CardLayout cardLayout;
 
		public ActionListenerBuilder(JPanel panel, CardLayout cardLayout) {
			this.panel=panel;
			this.cardLayout=cardLayout;
		}
 
		public ActionListener create(String name) {
			return e-> cardLayout.show(panel, name);
		}
 
		public ActionListener createPrevious() {
			return e-> cardLayout.previous(panel);
		}
 
		public ActionListener createNext() {
			return e-> cardLayout.next(panel);
		}
 
		public ActionListener createFirst() {
			return e-> cardLayout.first(panel);
		}
 
		public ActionListener createLast() {
			return e-> cardLayout.last(panel);
		}
 
	}
 
}

21/10/2019, 15h50
daprog

Ok merci, je commence à comprendre, juste un dernier problème:

Sur les bouton de mes lettres, j'aimerais qu'ils aient deux actions, la première est de dévoilé une lettre si elle correspond aux mot sinon incrémenter le nombre d'erreur (ce que j'ai fait, ça correspond aux actions de toutes mes touches), et le deuxième c'est d'afficher le JPanel GameOver si le nombre de faute = 7. J'ai du mal à voir comment je pourrais faire.

On peut mettre plusieurs actions (Action, ActionListener...) sur un même JButton, mais elles seront toutes exécutées à chaque action sur le bouton (clic, entrée, tap, touch, etc).
Première solution
Le principe pour faire ce que tu veux est d'avoir un état (le nombre de clic "avant que"). S'il y a plusieurs actions, il faut que l'état soit accessible des deux (une variable membre d'une classe accessible des deux ActionListener). S'il y en a qu'une l'action elle-même peut contenir l'état
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 button.addActionListener(new ActionListener() { private int counter; public void actionPerform(ActionEvent event) { counter++; if ( counter>=7 ) { // gameover : afficher le panel gameover } else { // faire je ne sais quoi pour continuer le jeu } } });
si cette variable counter est déclarée dans la classe Fenetre, elle ne peut être accessible et modifiable que via un wrapper dans un code d'une autre classe. Un wrapper c'est juste une classe qui a l'attribut. Tu pourrais faire par exemple une classe qui contient tous les états du jeu (un modèle finalement) qui est partagé par tous tes composants graphiques. Pour éviter de trop modifier ton code, tu peux aussi simplement déclarer ton compteur de classe AtomicInteger.
Deuxième solution : changer l'action listener. cela demande d'avoir la référence de l'action listener. Ceci est pratique quand l'action qui change doit être fait le "coup" suivant...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ActionListener actionListenerGameOver = e-> afficherGameOver(); // jouer() est une méthode qui fait les trucs qui faut quand on joue ActionListener actionListenerJeu = new ActionListener() { public void actionPerform(ActionEvent event) { if ( !jouer() ) { // retourne false si on perd par exemple // on passe en game over button.removeActionListener(this); button.addActionListener(actionListenerGameOver ); } } } button.addActionListener(actionListenerJeu );
tant que jouer() retourne true, c'est actionListenerJeu qui est déclenché, jusqu'à ce qu'il retourne false et le coup suivant c'est actionListenerGameOver qui a remplacé actionListenerJeu en quelque sorte.
troisième solution : utiliser la commande

Code:

button.setActionCommand("jouer");

dans actionPerformed de l'ActionListener
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 switch(event.getActionCommand()) { case "jouer": // on fait des trucs if ( conditiondegameover() ) { button.setActionCommand("gameover"); } break; case "gameover": // on fait autre chose... break; }

21/10/2019, 17h10
daprog

Ok, j'ai essayé de faire la première solution, y a juste le changement de panel que je comprend pas, vu que l'actionlistener du changement de panel est déjà définit dans un autre fichier, (j'ai repris le code que vous avez écrit avec l'ActionListenerBuilder), comment je pourrais faire pour mettre le panel GameOver?
21/10/2019, 20h07
joel.drigo

Là j'ai été au plus simple pour le principe (le principe = ça fonctionne quelque soit l'implémentation technique final):

Code:

ActionListener actionListenerGameOver = e-> afficherGameOver();

afficherGameOver() ici c'est une hypothétique fonction chargée d'afficher le panneau "gameover", en gros, si on reprend ce qui a été dit précédemment et que tu t'es inspiré de mon ActionListenerBuilder, donc ça pourrait être :

Code:

ActionListener actionListenerGameOver = actionListenerBuilder.create("gameover");

c'est ce que fait cette méthode create ici : créer un action listener qui va demander au cardlayout d'afficher un panneau dont le nom est "gameover".
21/10/2019, 20h28
daprog

ça me met une erreur "cannot make a static reference to a non static method create(string) of type ActionListenerBuilder. ça veut dire quoi?
21/10/2019, 20h38
joel.drigo

ça veut dire que tu es dans un contexte static ( une méthode static par exemple ) et tu essayes d'invoquer une méthode non static, en particulier sans passer par l'instance a qui appartient cette méthode (par exemple, tu as écrit ActionListenerBuilder.create("xxx")) : la méthode create n'est pas static, il faut une instance pour l'appeler, on ne peut pas l'appeler sur la classe, ça n'a pas de sens).

Tu ne devrais avoir aucune méthode static sauf main (éventuellement des méthodes utilitaires indépendantes aussi). Les méthodes static c'est la facilité pour faire des dépendances qui cachent les galères qu'on aura ensuite (les instances qui ont un attribut qui partage une unique valeur, alors que chacune devrait avoir sa valeur, les composants interdépendants qui ne devraient pas (les liens statiques dans tous les sens qui empêchent toute flexibilité du code), les méthodes ou variables statiques qui ne devraient pas (par rebond, parce que l'IDE a tendance à te proposer de passer le code appelant en static quand tu références un contexte static, et que tu valides au lieu de te demander à ce moment si c'est normal (et ça ne l'est que très rarement)), etc).

Donc la question première est "pourquoi le contexte appelant est-il statique ?". Si c'est normal (et il y a peu de chance que cela le soit, si ce n'est pas une méthode utilitaire, comme dans l'un de mes exemples (private static Component createPanel1(ActionListenerBuilder builder) {)), il faudrait passer l'instance en paramètre de la méthode statique, afin de pouvoir en invoquer les méthodes.
21/10/2019, 20h44
daprog

où devrais je donc mettre des statics dans ce cas? (désolé je suis un peu perdu, je suis débutant en java)

Il ne faut pas en mettre à priori.

Comme je n'ai pas de code, je vais essayer d'imaginer le truc au plus proche de ce que tu cherches à faire (s'il y a des static dans mon code, en dehors de la méthode main, c'est juste parce que je référence les classes dans la méthode main et que je les ai incluse dans ma classe Exemple, afin d'avoir un code qu'on peut directement copier/coller dans un fichier unique, mais toutes les public static class pourraient être extraites et mises dans leur propre fichier en public class (non static).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class Exemple {
 
	public static final String GAME = "GAME";
	public static final String GAMEOVER = "GAMEOVER";
 
	public static void main(String[] args) {
 
		GameModel gameModel = new GameModel();
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		// un panneau pour y mettre les différents composants à afficher, avec un cardlayout
		CardLayout cardLayout = new CardLayout();
		JPanel panel = new JPanel(cardLayout);
		frame.getContentPane().add(panel); // on le met au centre du content pane de la fenêtre pour qu'il soit affiché
 
		ActionListenerBuilder builder = new ActionListenerBuilder(panel, cardLayout);
		panel.add(new GamePanel(gameModel, builder),GAME);
		panel.add(new GameOverPanel(gameModel, builder),GAMEOVER);
 
		frame.setSize(600, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true); 
	}
 
	public static class GameModel {
		private int counter;
		private int round=1;
 
		public void reset() {
			counter=0;
			round++;
		}
 
		public void play() {
			counter++;
		}
 
		public int getState() {
			return counter;
		}
 
		public boolean endOfGame() {
			return counter>6;
		}
 
		public String getRound() {
			StringBuilder sb = new StringBuilder().append(round);
			switch (round) {
			case 1:
				sb.append("st");
				break;
			case 2:
				sb.append("nd");
				break;
			case 3:
				sb.append("rd");
				break;
			default:
				sb.append("th");
				break;
			}
			return sb.append(" round / ").toString();
		}
 
	}
 
	public static class GamePanel extends JPanel {
 
		public GamePanel(GameModel gameModel, ActionListenerBuilder builder) {
			super(new BorderLayout());
			setBackground(Color.CYAN);
 
			// ça c'est pour l'affichage (qui va évoluer pendant le jeu)
			JPanel gameboard = new JPanel(new GridBagLayout());
			gameboard.setOpaque(false);
			JLabel gamedisplay = new JLabel("Clic to play...");
			gameboard.add(gamedisplay);
			add(gameboard);
 
			JPanel buttonpanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
			JButton button = new JButton("Play");
 
			// cet action listener sera utilisé lorsqu'on aura atteint un état fin de jeu
			ActionListener gameoverlistener = builder.create(GAMEOVER);
 
			// cet action listener sera utilisé pour jouer
			ActionListener playlistener = new ActionListener() {
 
				@Override
				public void actionPerformed(ActionEvent e) {
					gameModel.play(); // on joue
					gamedisplay.setText(String.valueOf(gameModel.getState())); // on met à jour l'affichage
					if ( gameModel.endOfGame() ) { // si on atteint l'état fin de partie, on change les listeners (c'est le principe que tu m'as demandé si j'ai bien compris, moi j'aurais affiché directement le game over à ce moment)
						button.removeActionListener(this); // pour éviter qu'au prochain clic on continue de jouer
						button.addActionListener(gameoverlistener); // pour qu'au prochain clic on bascule sur le "game over"
					}
				}
 
			};
			button.addActionListener(playlistener); // on affecte l'écouteur dédié au jeu au bouton
			addComponentListener(new ComponentAdapter() { // ça c'est une astuce pour recommencer la partie (en théorie, le GameModel devrait produire ses propres événements, auxquels l'interface graphique devrait réagir pour se mettre à jour, mais je ne vais pas compliquer plus l'exemple)
				public void componentShown(java.awt.event.ComponentEvent e) { 
					button.removeActionListener(gameoverlistener); // il ne faut plus que le bouton bascule sur "game over"
					button.addActionListener(playlistener); // il faut pouvoir rejouer
					gamedisplay.setText(gameModel.getRound()+" Clic to play..."); // on en profite pour mettre à jour l'affichage du game board
				}
			}); 
			buttonpanel.add(button);
			add(buttonpanel, BorderLayout.SOUTH);
		}
 
	}
 
	public static class GameOverPanel extends JPanel {
 
		public GameOverPanel(GameModel gameModel, ActionListenerBuilder builder) {
			super(new BorderLayout());
 
 
			// ça c'est juste pour l'affichage
                        setBackground(Color.ORANGE);
			JPanel gameboard = new JPanel(new GridBagLayout());
			gameboard.setOpaque(false);
			JLabel gamedisplay = new JLabel("Game Over");
			gameboard.add(gamedisplay);
			add(gameboard);
 
                        // le bouton reset le modèle pour recommencer une partie et afficher le gameboard
			JPanel buttonpanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
			JButton button = new JButton("Reset game");
			button.addActionListener(e-> gameModel.reset());
			button.addActionListener(builder.create(GAME));
			buttonpanel.add(button);
			add(buttonpanel, BorderLayout.SOUTH);
 
		}
 
	}
 
	public static class ActionListenerBuilder {
 
		private final JPanel panel;
		private final CardLayout cardLayout;
 
		public ActionListenerBuilder(JPanel panel, CardLayout cardLayout) {
			this.panel=panel;
			this.cardLayout=cardLayout;
		}
 
		public ActionListener create(String name) {
			return e-> cardLayout.show(panel, name);
		}
 
		public ActionListener createPrevious() {
			return e-> cardLayout.previous(panel);
		}
 
		public ActionListener createNext() {
			return e-> cardLayout.next(panel);
		}
 
		public ActionListener createFirst() {
			return e-> cardLayout.first(panel);
		}
 
		public ActionListener createLast() {
			return e-> cardLayout.last(panel);
		}
 
	}
 
}

21/10/2019, 22h13
daprog

Ok, j'y suis presque!

Le seul truc que j'aime pas, c'est que, le joueur, arrive à 6 erreurs, appuie sur un bouton et se trompe, c'est à ce moment la que j'aimerais mettre la frame game over, la il est obliger de rappuyer sur un boutons et il ne sait pas qu'il a déjà perdu, je me suis dis peut être que je devrais, arrivé à 7 erreurs, enlever toute les lettre etajouter un bouton game over!

C'est bien ce dont je m'étonnais dans mon commentaire (// si on atteint l'état fin de partie, on change les listeners (c'est le principe que tu m'as demandé si j'ai bien compris, moi j'aurais affiché directement le game over à ce moment))

On peut éventuellement afficher le "gameover" un coup avant, et faire que ce panneau ressemble au panneau de jeu. Le fait que le modèle soit générateur d'événement devient encore plus intéressant dans ce cas. Ce ne sont plus les boutons qui contrôlent l'affichage, ce sont les réactions aux changements des données du modèle (c'est ce qu'on appelle le modèle MVC / Modèle Vue Contrôleur).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
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
public class Exemple {
 
	public static final String GAME = "GAME";
	public static final String GAMEOVER = "GAMEOVER";
 
	public static void main(String[] args) {
 
		GameModel gameModel = new GameModel();
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		// un panneau pour y mettre les différents composants à afficher, avec un
		// cardlayout
		CardLayout cardLayout = new CardLayout();
		JPanel panel = new JPanel(cardLayout);
		frame.getContentPane().add(panel); // on le met au centre du content pane de la fenêtre pour qu'il soit affiché
 
		panel.add(new GamePanel(gameModel), GAME);
		panel.add(new GameOverPanel(gameModel), GAMEOVER);
 
		GameUI gameui = new GameUI(panel, cardLayout);
		// on met à jour l'affichage en fonction des modifications du modèle
		gameModel.addPropertyChangerListener(GameModel.WIN,
				e -> gameui.show(GAMEOVER)); 
		gameModel.addPropertyChangerListener(GameModel.RESET,
				e -> gameui.show(GAME));
 
 
		frame.setSize(600, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
	}
 
	public static class GameModel {
 
		public static final String COUNTER = "counter";
		public static final String ROUND = "round";
		public static final String WIN = "win";
		public static final String RESET = "reset";
 
		private SwingPropertyChangeSupport eventsupport = new SwingPropertyChangeSupport(this);
 
		private int counter;
		private int round = 1;
		private boolean win;
 
		public void reset() {
			int oldcounter = counter;
			counter = 0;
			eventsupport.firePropertyChange(COUNTER, oldcounter, counter);
			int oldround = round;
			round++;
			eventsupport.firePropertyChange(ROUND, oldround, round);
			boolean oldwin = win;
			win = false;
			eventsupport.firePropertyChange(RESET, false, true);
		}
 
		public void play() {
			if (endOfGame())
				return;
			int oldcounter = counter;
			counter++;
			if (endOfGame()) {
				win = new Random().nextBoolean();
			}
			eventsupport.firePropertyChange(COUNTER, oldcounter, counter);
			if (endOfGame()) {
				eventsupport.firePropertyChange(WIN, !win, win);
			}
		}
 
		public boolean isWin() {
			return win;
		}
 
		public int getState() {
			return counter;
		}
 
		public boolean endOfGame() {
			return counter > 6;
		}
 
		public boolean lastPlay() {
			return counter > 5;
		}
 
		public int getRound() {
			return round;
		}
 
		public void addPropertyChangerListener(String prop, PropertyChangeListener listener) {
			eventsupport.addPropertyChangeListener(prop, listener);
		}
 
		public void removePropertyChangerListener(String prop, PropertyChangeListener listener) {
			eventsupport.removePropertyChangeListener(prop, listener);
		}
 
	}
 
	public static String roundToString(int round) {
		StringBuilder sb = new StringBuilder().append(round);
		switch (round) {
		case 1:
			sb.append("st");
			break;
		case 2:
			sb.append("nd");
			break;
		case 3:
			sb.append("rd");
			break;
		default:
			sb.append("th");
			break;
		}
		return sb.append(" round").toString();
	}
 
	public static class GamePanel extends JPanel {
 
		public GamePanel(GameModel gameModel) {
			super(new BorderLayout());
			setBackground(Color.CYAN);
 
			// ça c'est pour l'affichage (qui va évoluer pendant le jeu)
			JPanel gameboard = new JPanel(new GridBagLayout());
			gameboard.setOpaque(false);
			JLabel gamedisplay = new JLabel("Clic to play...");
			gameboard.add(gamedisplay);
			add(gameboard);
 
			JPanel buttonpanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
			JButton button = new JButton("Play");
 
			button.addActionListener(e-> gameModel.play()); // on affecte l'écouteur dédié au jeu au bouton
 
			buttonpanel.add(button);
			add(buttonpanel, BorderLayout.SOUTH);
			// on met à jour l'affichage en fonction des modifications du modèle
			gameModel.addPropertyChangerListener(GameModel.COUNTER,
					e -> gamedisplay.setText(String.valueOf(gameModel.getState()))); 
			gameModel.addPropertyChangerListener(GameModel.ROUND,
					e -> gamedisplay.setText(roundToString(gameModel.getRound()) + " / Clic to play..."));
 
		}
 
	}
 
	public static class GameOverPanel extends JPanel {
 
		public GameOverPanel(GameModel gameModel) {
			super(new BorderLayout());
 
			// ça c'est juste pour l'affichage
			setBackground(Color.ORANGE);
			JPanel gameboard = new JPanel(new GridBagLayout());
			GridBagConstraints gbc = new GridBagConstraints();
			gbc.gridx = 0;
			gbc.gridy = GridBagConstraints.RELATIVE;
			gameboard.setOpaque(false);
			JLabel gameoverdisplay = new JLabel("Game Over");
			gameboard.add(gameoverdisplay, gbc);
			JLabel gamedisplay = new JLabel();
			gameboard.add(gamedisplay, gbc);
			add(gameboard);
 
			// le bouton reset le modèle pour recommencer une partie et afficher le
			// gameboard
			JPanel buttonpanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
			JButton button = new JButton("Reset game");
			button.addActionListener(e -> gameModel.reset());
			buttonpanel.add(button);
			add(buttonpanel, BorderLayout.SOUTH);
			// on met à jour l'affichage en fonction des modifications du modèle
			gameModel.addPropertyChangerListener(GameModel.WIN,
					e -> gamedisplay.setText(roundToString(gameModel.getRound()) +": " + gameModel.getState() + " / " + (gameModel.isWin() ? "Gagné" : "Perdu")));
 
		}
 
	}
 
	public static class GameUI {
 
		private final JPanel panel;
		private final CardLayout cardLayout;
 
		public GameUI(JPanel panel, CardLayout cardLayout) {
			this.panel = panel;
			this.cardLayout = cardLayout;
		}
 
		public void show(String name) {
			cardLayout.show(panel, name);
		}
 
	}
 
}

22/10/2019, 13h24
daprog

Oh pardon pour la confusion ^^'

Où est ce que dans le code on procède à l'affichage du GameOverPanel?

Citation:

Envoyé par daprog

Où est ce que dans le code on procède à l'affichage du GameOverPanel?

Ici :
Code:

1 2 gameModel.addPropertyChangerListener(GameModel.WIN, e -> gameui.show(GAMEOVER));
L'évenement WIN est déclenché ici :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public void play() { if (endOfGame()) return; int oldcounter = counter; counter++; if (endOfGame()) { win = new Random().nextBoolean(); } eventsupport.firePropertyChange(COUNTER, oldcounter, counter); if (endOfGame()) { eventsupport.firePropertyChange(WIN, !win, win); } }
Bon, ici c'est un peu bidon, juste pour l'exemple de principe : lorsqu'on atteint le nombre de coup maxi (qui dit que le jeu est terminé), enfin on appelle endOfGame() (ça pourrait tester n'importe quelle condition en fait qui dit que c'est la fin du jeu (nombre de vie à zéro, destination finale atteinte, boss battu, niveau de vie à zéro, etc), on détermine si le joueur a gagner ou perdu (dans mon exemple, c'est aléatoire, mais peu importe, c'est juste un état calculé en fonction de ce qu'on veut qui détermine si le joueur a gagné, ou perdu, comme pour endOfGame()). Là, un événement est lancé pour dire que cet état "gagné/perdu" a été déterminé (a changé). Je détermine l'état avant d'envoyer tout événement pour avoir un état cohérent.

22/10/2019, 13h59
daprog

Ok, je vois, mais à quoi servent le win et !win passer en paramètre?
22/10/2019, 14h12
joel.drigo

Pour lancer un événement, avec SwingPropertyChangeSupport, il faut fournir l'ancienne valeur de l'état et la nouvelle. En plus, il faut qu'elles soient différentes sinon l'événement ne sera pas propagé vers les écouteurs.

Dans le cas de WIN, je n'ai qu'un état constant, gagné ou perdu, stocké dans l'attribut win (j'aurais pu ne pas le stocker et ne le transmettre que par événement). L'ancienne valeur n'a pas à priori d'importance. Mais il en faut une, et une différente de l'état, donc j'ai pris !win qui est forcément différent de win.

Dans le cas de RESET, il n'y a même pas d'état, je voulais juste avoir une notification. Pour éviter d'avoir à mettre en place tout un système d'événement/écouteur/producteur juste pour ça, j'ai choisi l'astuce d'un événement de changement d'état Swing, donc la valeur n'a aucun sens et je passe deux valeurs différentes pour qu'il ne soit pas filtré (en l’occurrence false et true, mais j'aurais pu prendre n'importe quoi, "gon" & "kirua", 42 & 1337, etc.
22/10/2019, 14h33
daprog

Ok, du coup tout les evenement de mon jeu devras se dérouler dans mon GameModel? ou ce serait mieux de manipuler les variable de jeux hors de mon model?
22/10/2019, 15h03
joel.drigo
Il est toujours mieux de gérer une UI via un modèle MVC (Modèle/Vue/Contrôleur) :
1. modèle : les données du jeu
2. vue : l'affichage
3. contrôleur : ce qui gère le tout
La vue écoute le modèle pour se mettre à jour et utilise le contrôleur pour déclencher les actions. Le contrôleur peut écouter le modèle pour gérer ses possibilités d'action et pilote la vue (affiche ou cache des composants, active ou non des boutons, etc). La vue et le contrôleur accèdent au modèle éventuellement. Le modèle ne doit connaître ni la vue, ni le contrôleur, excepté via des écouteurs d'événements.

On peut simplifier avec un modèle MV, ou la vue porte des contrôleurs (c'est le cas des composants Swing). Dans le cadre d'un jeu, en particulier un jeu d'action, on utilisera plutôt un modèle ECS (Entités/Composants/Systèmes), avec une boucle de jeu (gameloop, ou eventloop). Mais un modèle MVC pour un jeu en Swing est valable, surtout pour un jeu sans problématique de rapidité.

Si on adopte le modèle MVC, autant le respecter complètement, sauf qu'en Swing, on a immanquablement des parties du contrôleur dans les composants Swing (les ActionListener des boutons par exemple, mais ils peuvent ne faire qu'invoquer une méthode du contrôleur). Dans une application bureautique par exemple, le contrôleur fournira un ActionManager et l'ui ne fera que distribuer ses Action dans des boutons, menus, etc.

Après ce n'est pas une obligation légale, c'est juste que ça simplifie les traitements et la portée des données de jeu. Le fait d'avoir une seule classe qui regroupe toutes les données évite d'avoir à gérer des accès interclasses justement. Et ça découple fortement chaque composant. On peut utiliser le même modèle dans différents environnement et le contrôleur peut avoir une base commune avec des versions pour chaque type d'environnement. Ensuite on a une vue ou plusieurs par environnement (Par exemple, pour un téléphone, on pourra avoir une vue portrait et une vue paysage, avec une disposition des composants différentes, mais le modèle c'est bien le même et les actions sont les mêmes, puisque c'est le même jeu). Et tout dépend du but final. Faire quelque chose qui fonctionne, ou quelque chose de super bien modélisé.
22/10/2019, 15h51
daprog

Ok, Je vois.

La j'essaye d'appeler mon gameModel de ma classe Game (Le JPanel) dans un ActionListener, sauf que je peux pas, ça me met gameModel cannot beresolved, je sais pas comment faire pour l'utiliser (je l'ai mis en parametre dans le constructeur de Game)

Dans le code que tu avais déjà publié dans un message précédent tu avais :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Game extends JPanel{
                   /* du code */
 
	public Game() {
                   /* du code */
        }
 
        /* du code */
 
      public class launch implements ActionListener{
		public void actionPerformed(ActionEvent e) {
			motmystere = chmm();
			motetoile = String(motmystere.length(), "*");
			mot.setText(motetoile);
			System.out.println(motmystere);
		}
	}
 
        /* du code */
 
}

et donc, par exemple, tu peux faire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Game extends JPanel{
 
                   /* du code */
        private GameModel gameModel;
 
	public Game(GameModel gameModel) {
                   /* du code */
                this.gameModel = gameModel;
        }
 
        /* du code */
 
      public class launch implements ActionListener{
		public void actionPerformed(ActionEvent e) {
			// ici tu peux utiliser gameModel, par exemple (en supposant que ces méthodes existent...)
                       motmystere = gameModel.chmm();
		       motetoile = String(gameModel.getMotMystereLength(), "*");
		       mot.setText(motetoile);
 
		}
	}
 
        /* du code */
 
}

et dans Fenetre, au lieu de faire

Code:

1
2
JPanel Game = new Game();
	JPanel GameOver = new GameOver();

Code:

1
2
3
GameModel gameModel = new GameModel();
JPanel Game = new Game(gameModel);
JPanel GameOver = new GameOver();

Si tu as un problème de précédence (tu ne peux pas créer gameModel à cet endroit), il faut revoir ta construction. Personnellement je n'utilise jamais cette possibilité d'instancier des objets attributs dans la déclaration, je le fais toujours dans le constructeur, justement parce que c'est bien plus souple et ça évite aussi certains problèmes lors de l'héritage le cas échéant.

donc :

Code:

1
2
3
private GameModel gameModel;
private JPanel Game;
private JPanel GameOver;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public Fenetre(){
		this.setLocationRelativeTo(null);
		this.setTitle("Le PENDU");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setSize(1000, 800);
 
		contentPane = new JPanel();
		contentPane.setLayout(cardLayout);
 
               
                gameModel = new GameModel();
                Game = new Game(gameModel);
                GameOver = new GameOver(gameModel);
                

		contentPane.add(MainWindow, "Page Principale");
		contentPane.add(Game, "Page 1");
		contentPane.add(GameOver, "Page 2");

22/10/2019, 17h14
daprog

Ok c'est bon ça marche!!

Merci beaucoup de m'avoir aidé! Je vais pouvoir finir ce pendu et avancé aux autres chapitre :D