Discussion :

[joel.drigo]

La représentation d'un bateau n'a pas besoin de savoir où elle est placée. C'est un bateau qui vit sa vie hors d'une grille, de la notion de placement et de tout le reste, c'est tout.

Dans la grille on peut avoir par exemple :

		Case 1 du Bateau A				Case 1 du Bateau B	Case 2 du Bateau B	Case 3 du Bateau B	Case 4 du Bateau B
		Case 2 du Bateau A
		Case 3 du Bateau A

Donc la grille seule peut permettre de modéliser des bateaux dans une grille. Le bateau n'a même pas besoin de savoir qu'il est en x,y : la grille le sait. Seulement, il est plus simple de stocker le numéro de case de bateau pour éviter d'avoir à le rechercher à chaque fois qu'on a besoin.

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
public class ExempleBateau {
 
	public enum TypeBateau {
		PORTEAVION(5),
		CUIRASSE(4),
		CONTRE_TORPILLEUR(3),
		SOUS_MARIN(3),
		TORPILLEUR(2);
		private final int nb;
		private TypeBateau(int nb) {
			this.nb=nb;
		}
 
		public int getLongueur() {
			return nb;
		}
	}
 
	public static class Bateau {
 
		private TypeBateau typeBateau;
 
		private Bateau(TypeBateau typeBateau) {
			this.typeBateau=typeBateau;
		}
 
		public int getLongueur() {
			return this.typeBateau.getLongueur();
		}
 
	}
 
	public enum Orientation {
		HORIZONTAL,
		VERTICAL
	}
 
	public static void placer(Bateau[][] grille, int x, int y, Bateau bateau, Orientation orientation) {
			for(int i=0; i<bateau.getLongueur(); i++) {
				switch(orientation) {
				case HORIZONTAL:
					placer(grille, x+i, y, bateau);
					break;
				case VERTICAL:
					placer(grille, x, y+i, bateau);
					break;
			}
		}
 
	}
 
	private static void placer(Bateau[][] grille, int x, int y, Bateau bateau) {
		grille[x][y] = bateau; 
	}
 
}

Ici, après placer un bateau, la grille a dans ces cases des morceaux de bateau et sait de quel bateau il s'agit. Elle ne sait pas si c'est l'avant du bateau, l'arrière ou le milieu. Mais après tout on s'en fout, tant qu'on a pas besoin de dessiner. On a juste besoin de savoir s'il y a un bateau (pour savoir si c'est un touché ou dans l'eau) et de savoir quel bateau (pour le toucher et éventuellement le couler). Pour le comptage des cases touchées d'un bateau et leur position, on peut utiliser une grille avec les états (comme dans l'exemple que je t'avais donné au début).

Maintenant, on peut aussi gérer un petit tableau dans le Bateau, pour connaitre les états (touché ou pas) et la position dans la grille, et l'orientation, pour plus facilement gérer ça en objet et faire un rendu plus sympa (dessiner chaque partie du bateau, détruite ou pas, ou en train de couler, etc). Il suffit au moment où on place communiquer avec le bateau :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
	public static void placer(Bateau[][] grille, int x, int y, Bateau bateau, Orientation orientation) {
			for(int i=0; i<bateau.getLongueur(); i++) {
				switch(orientation) {
				case HORIZONTAL:
					placer(grille, x+i, y, bateau, i, orientation);
					break;
				case VERTICAL:
					placer(grille, x, y+i, bateau, i, orientation);
					break;
			}
		}
 
	}
 
	private static void placer(Bateau[][] grille, int x, int y, Bateau bateau, int numeroCase, Orientation orientation) {
		grille[x][y] = bateau; 
                bateau.setCase(numeroCase, x, y, orientation); // par exemple
	}

[SoulHokib]

Le mieux c'est de constituer une représentation de ta case indépendante de ce que tu utilises pour la représenter dans l'UI : ainsi passer d'une représentation par JButton à une représentation par autre chose (JLabel avec une image, image directement en Java2D, ou peu importe) ne modifie pas cette réprésentation. On appelle ça le MVC : modèle/vue/contrôleur. Le modèle est ce qui représente la case indépendamment de sa gestion et de l'UI, donc ses propriétés (touché, coulé, partie d'un bateau de type x...). Le contrôleur est le code de gestion (si on tire sur la case, et qu'il y a une partie de bateau dedans, alors il se passe ceci...), y compris la partie évenement d'UI. La vue est la représentation graphique. Un moyen simple d'éviter d'avoir du code qui dépend du contrôleur ou de la vue dans le modèle est de procéder par événement (voir les classes PropertyChangeSupport et SwingPropertyChangeSupport). Le modèle ignore complètement le contrôleur et la vue : il représente une case de jeu de bataille navale et c'est tout, mais permet à d'autres objets d'être informés des changements de ses attributs par évenement. La vue se met à jour en écoutant les changements dans le modèle. Le contrôleur écoute les deux et envoie des ordres aux deux pour réaliser le fonctionnement de tout ça (changer telle propriété dans le modèle).

Maintenant, on peut aussi simplifier en faisant des tableaux qui contiennent les états.

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
public class Plateau extends JPanel{
 
    private static final int SIZE = 10; // nombre de lignes et colonnes
 
/**
         * Représente l'état d'une case
         *
         */
	public enum State {
		HIT, // touchée
		SUNK, // coulée
		MISS, // tirée mais manquée
		SEA, // mer
		SHIP // bateau
	}
 
	/**
         * Représente le type de bateau
         *
         */
	public enum ShipType {
		CARRIER(5),
		BATTLESHIP(4),
		CRUISER(3),
		SUBMARINE(3),
		DESTROYER(2);
 
		private int size; // la taille du bateau
		private ShipType (int size) {
			this.size=size;
		}
 
		public int size() {
			return size;
		}
	}
 
    private State[][] states; // un tableau pour les états
    private Ship[][] ships; // un tableau pour les bateau
 
    public Plateau() {
        /*...*/
        states = new State[SIZE][SIZE]; // on crée un tableau qui contient l'état des cases
        ships = new Ship[SIZE][SIZE]; // on crée un tableau qui contient les instances de bateau des cases qui contiennent un bateau
        /*...*/
    }
 
}

Et donc tu peux ensuite écrire 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
private void caseClick(JButton button, int x, int y) {
 
      switch(states[y][x]) {
      case SEA:
            // coup dans l'eau...
            states[y][x]=State.MISS;
            break;
      case SHIP:
            // touché...
            states[y][x]=State.HIT;
                 // on avertit que le bateau a été touché (
            if ( ships[y][y].hit(x,y) ) {
                 // le bateau est coulé
                 int size = ships[y][y].getType().getSize();
                 for(Point location : ships[y][y].getLocations() ) { // on parcourt les cases du bateau
                      if ( states[location.y][location.x]==State.HIT ) {
                          size--;
                      }
                 }
                 if ( size==0 ) { // le bateau est coulé
                    for(Point location : ships[y][y].getLocations() ) { 
                        states[location.y][location.x]=State.SUNK;
                    }
                 }
            }
            break;
      case SUNK:
            // on a tiré sur un bateau coulé
            // on fait un truc ou pas
            break;
      case HIT:
            // on a tiré sur un bateau déjà touché
            // on fait un truc ou pas
            break;
      case MISS:
            // on a tiré sur un bout de mer déjà touchée
            // on fait un truc ou pas
            break;
      } 
 
            setIcon(button, x,y); // on appelle une méthode qui change l'icon du bouton en fonction de son état 
            repaint();
 
 
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
setIcon(JButton button, int x, int y) {
      Icon icon;
     switch(state[y][x]) {
     case SHIP:
            icon = ships[y][x].getIcon(x,y) {
            break;
      case SEA:
            icon = ...
            break;
      ...
     }
     button.setIcon(icon);
}

Comme tu me l'as suggéré, je me suis penché sur cet exemple que tu m'as fourni. Je n'ai pas utilisé la méthode setIcon car je ne la comprennais pas, j'ai adapté certains trucs. Cependant, dans la méthode CaseClick(), je ne comprends pas d'où sortent tous les "hit(x,y)"; "getLocation" etc. Sont-ce des méthodes que je dois créer dans ma classe Bateau ?

J'avoue que malgré les aides, je suis perdu et j'ai vraiment du mal, j'en suis désolé

[joel.drigo]

Cependant, dans la méthode CaseClick(), je ne comprends pas d'où sortent tous les "hit(x,y)"; "getLocation" etc. Sont-ce des méthodes que je dois créer dans ma classe Bateau ?

Oui, ce sont bien des méthodes à implémenter dans la classe Bateau. Ou pas. C'est comme tu veux. Le but de cet exemple était de donner l'idée général de l'algorithme. Disons qu'en objet c'est toujours mieux que les comportements soient dans les objets, puisque ça permet d'isoler le code.

1. hit(x,y)
   Cette méthode est censée retourner true si on touche le bateau. Le fait de faire une méthode dans le bateau permet de faire ce qu'on veut au sein du bateau (à commencer par stocker une information qui va permettre de savoir qu'une case du bateau est touchée, ce qui permet par exemple de faire un rendu spécial de la case, ou n'importe quoi d'autres comme traitement), et même de décider si le coup porte ou non selon des conditions différentes par type de bateau. Le plus simple soit qu'elle retourne true.
2. getLocation() est censée retourner la liste des couples de coordonnées de case du bateau, ce qui permet à tout moment de les parcourir pour tester leur état, donc de pouvoir déterminer si un bateau est coulé ou pas, par exemple.

Je n'ai pas utilisé la méthode setIcon car je ne la comprennais pas

Cette méthode est censée déterminer en fonction de l'état d'une case, l'image qu'on doit affecter au bouton, pour que le rendu soit conforme à cet état. Par exemple, si la case est de la mer, on affiche une image de mer (ça peut être un carré tout bleu, ou une image symbolique bleu avec des petites vaguelettes blanches, ou une photo de mer, ou un M, ou n'importe quoi d'autres qu'on veut afficher. Evidemment pour de la mer, l'état ne change pas en théorie (Il y a des variantes de batailles navales où on peut changer tout les n tours la position d'un bateau, et dans ce cas, une case pourrait passer de l'état mer à l'état bateau dedans). A chaque fois qu'on change l'état d'une case (de bateau à bateau touché, de bateau touché à bateau coulé, etc) on détermine le nouvel icône à affecter au bouton qui est dans cet case. On peut aussi procéder par évenement (le bouton écoute quelque chose lui disant voilà ta nouvelle icône, mais ça me semble plus compliqué à faire pour toi. Si tu avais opté pour la solution tout graphique comme on t'avait conseillé au départ, ça aurait probablement été mieux.

[SoulHokib]

Si j'ai bien suivi tes explications, il va rester compliqué pour moi de faire la fameuse actualisation en cascade dont je parlais avec les JButton, car il est compliqué d'actualiser l'icône du bouton s'il n'est pas cliqué. Etant donné qu'il me reste du temps, penses-tu qu'il serait raisonnable de recommencer le projet du point de vue graphique en passant donc sur du Java2D + images ? Les méthodes dans leur conception logiquement ne seraient pas tant chamboulées.

[joel.drigo]

Je ne comprends pas trop de quoi tu parles par "actualisation en cascade".

On peut changer l'icône du bouton indépendamment du fait qu'il soit cliqué et ça n'a rien de complexe ni de particulière compliqué. Mais changer l'icône d'un bouton est nécessaire suite à un changement d'état : pour un joueur humain qui joue via l'interface, c'est forcément à la suite d'une action. Pour ce qui est d'une IA, le processus est le même, simplement doit-il déléguer à l'EDT le changement d'état (dans un MVC, ce serait fait par le contrôleur naturellement), ce que doit faire de toute manière tout processus non graphique lorsqu'il doit modifier quelque chose dans l'UI.

Le truc qui est plus simple avec une UI en Java2D, c'est que tu peux faire des composants qui ont une méthode de rendu, alors qu'avec un bouton, sans faire un modèle custom (ce qui n'est pas simple pour un néophyte), c'est que tu ne peux procéder que par changement d'état (l'état dont je parle ici, c'est l'icône du bouton).

Pour la dernière question, tout dépend de ce qu'il te reste comme temps et de tes facultés à créer une interface purement graphique. Pour quelqu'un connaissant très bien Java et ayant de bonne facultés de conception, créer tout le jeu de bataille navale en Java2D avec un système de base, sans la partie "créa graphique" et sans IA (ça c'est une autre histoire), c'est l'affaire de quelques heures, sans se presser. Mais ce n'est pas ton cas.

[SoulHokib]

Quand je dis "en cascades" c'est qu'actuellement, quand je plaçais un bateau, ça n'actualisait l'icône que de la première case du bateau, pas le reste. C'est ça que je n'arrive pas à faire.

Cependant, étant donné qu'il me reste jusqu'à Mai (théoriquement, j'aimerais avoir fini d'ici 1 mois) pour boucler la bataille navale, je vais sûrement réorienter sur du Java2D en utilisant des pane content (GridBagLayout ? Je ne sais encore lequel) dans lequel je dessinerais ma grille. Le travail jusque là n'étant pas perdu étant donné que certaines méthodes pourront être réutilisées en adaptant bien évidemment au dessin.

[joel.drigo]

Ah, il n'y a pas de "cascade" dans cette histoire : la notion de cascade, c'est récursif, c'est quand quelque chose déclenche quelque chose qui déclenche quelque chose qui déclenche quelque chose etc (comme une suppression en cascade d'un élément, qui va supprimer les éléments qui lui sont rattachés par un lien déterminé, et donc la suppression de ces éléments va elle même déclencher la suppressions de ceux qui leur sont rattachés, etc).

On pourrait implémenter le placement de bateau de manière récursive, mais ce serait se compliquer la vie alors qu'une simple boucle et une incrémentation est suffisante.

[SoulHokib]

Je ne vois pas quel type de boucle réaliser. J'ai certes récupéré les valeurs x et y de la case du début du bateau, mais je ne peux pas changer ma valeur de case (qui permet de changer l'affichage) en faisant une boucle incrémentant par exemple sur x ou sur y.

J'ai par ailleurs commencé à travailler sur du Java2D et à faire des tests avec une représentation de grille à part de mon projet. J'ai aussi réussi à créer un MouseListener fonctionnel. J'essaierais bientôt d'adapter ça pour ma bataille navale, je reviendrais vous si j'ai des questions. Encore merci, une fois de plus, vous m'aidez beaucoup.

[joel.drigo]

Cependant, étant donné qu'il me reste jusqu'à Mai (théoriquement, j'aimerais avoir fini d'ici 1 mois)

Il y a largement assez de temps !

pour boucler la bataille navale, je vais sûrement réorienter sur du Java2D en utilisant des pane content (GridBagLayout ? Je ne sais encore lequel)

euh non justement plus de layout manager avec Java2D.

Regarde cet 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
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
import java.awt.AlphaComposite;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dialog.ModalityType;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.TexturePaint;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.io.File;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.DefaultListCellRenderer;
import javax.swing.DefaultListModel;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.ListSelectionModel;
import javax.swing.SwingUtilities;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
 
public class DemoGrilleJava2D extends JPanel {
 
	private static final int TAILLE_SPRITE = 32;
	private static final int TAILLE_GRILLE = 10;
 
	private static final int SPRITE_COL = 8;
	private static final int SPRITE_LIG = 4;
 
	private Sprite[][] grille; 
	private Sprite sprite;
	private boolean showGrid=true;
	private Point mouseLocation;
	private Point mouseLocationStart;
	public DemoGrilleJava2D( ) { 
		grille = new Sprite[10][10];
		setPreferredSize(new Dimension(TAILLE_GRILLE*TAILLE_SPRITE,TAILLE_GRILLE*TAILLE_SPRITE));
		MouseAdapter mouseAdapter = new MouseAdapter() {
			private Point start;
 
			@Override
			public void mouseClicked(MouseEvent e) {
				start = null;
				mouseLocationStart = null;
				setSprite(mouseToGrille(e.getPoint()));
			}
			@Override
			public void mousePressed(MouseEvent e) {
				start = mouseToGrille(e.getPoint());
				mouseLocationStart = start; 
			}
			@Override
			public void mouseReleased(MouseEvent e) {
				mouseLocationStart = null;
				setSprites(start, mouseToGrille(e.getPoint()));
			}
			@Override
			public void mouseMoved(MouseEvent e) {
				Point lastLocation = mouseLocation;
				mouseLocation = mouseToGrille(e.getPoint());
				if ( lastLocation==null || !lastLocation.equals(mouseLocation) ) {
					repaint();
				}
			}
			@Override
			public void mouseDragged(MouseEvent e) {
				Point lastLocation = mouseLocation;
				mouseLocation = mouseToGrille(e.getPoint());
				if ( lastLocation==null || !lastLocation.equals(mouseLocation) ) {
					repaint();
				}
			}
		};
		addMouseListener(mouseAdapter);
		addMouseMotionListener(mouseAdapter);
	}
 
	public void setGridVisible(boolean show) {
		this.showGrid=show;
		repaint();
	}
 
	public boolean isGridVisible() {
		return this.showGrid;
	}
 
	public void setCurrentSprite(Sprite sprite) {
		this.sprite=sprite;
	}
 
	protected void setSprite(Point position) {
		grille[position.x][position.y]=sprite;
		repaint();
	}
 
	protected void setSprites(Point start, Point end) {
		int dx = Math.min(start.x, end.x);
		int fx = Math.max(start.x, end.x);
		int dy = Math.min(start.y, end.y);
		int fy = Math.max(start.y, end.y);
		for(int i=dx; i<=fx; i++) {
			for(int j=dy; j<=fy; j++) {
				if ( i>=0 && i<TAILLE_GRILLE && j>=0 && j<TAILLE_GRILLE ) {
					grille[i][j]=sprite; 
				}
			}
		}
		repaint();
	}
 
 
	protected Point mouseToGrille(Point point) {
		int x = point.x / TAILLE_SPRITE;
		int y = point.y / TAILLE_SPRITE; 
		return new Point(x,y);
	}
 
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
 
		Graphics2D g2dTuile = (Graphics2D)g.create();
		if  ( mouseLocation!=null && mouseLocationStart!=null ) { 
			g2dTuile.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.3f));
		}
 
 
		// on dessine les tuiles déjà posées
		for(int i=0; i<grille.length; i++) {
			for(int j=0; j<grille[i].length; j++) {
				Sprite sprite = grille[i][j];
				if ( sprite!=null ) {
					sprite.draw(g2dTuile, i*TAILLE_SPRITE, j*TAILLE_SPRITE, this);
				}
			}
		}
 
		g2dTuile.dispose();
 
		// on dessine une grille
		if ( showGrid) {
			g.setColor(Color.RED);
			for(int i=0; i<grille.length; i++) {
				for(int j=0; j<grille[i].length; j++) {
					g.drawRect(i*TAILLE_SPRITE, j*TAILLE_SPRITE, TAILLE_SPRITE, TAILLE_SPRITE);
				}
			}
			g.drawRect(0, 0, TAILLE_GRILLE*TAILLE_SPRITE-1, TAILLE_GRILLE*TAILLE_SPRITE-1);
		}
 
		// puis on dessine la tuile en cours 
		if  ( mouseLocation!=null ) {
			Graphics2D g2d = (Graphics2D)g.create();
				g2d.setXORMode(Color.RED);
			if ( mouseLocationStart!=null ) { 
 
				Point start = new Point(mouseLocationStart);
				Point end = new Point(mouseLocation);
				if ( start.x>end.x ) {
					int x = start.x;
					start.x=end.x;
					end.x=x;
				}
				if ( start.y>end.y ) {
					int y = start.y;
					start.y=end.y;
					end.y=y;
				}
 
				if ( sprite!=null ) {
 
					TexturePaint texturePaint = new TexturePaint(sprite.getBufferedImage(),new Rectangle2D.Double(
							start.x*TAILLE_SPRITE,start.y*TAILLE_SPRITE, TAILLE_SPRITE, TAILLE_SPRITE));
					g2d.setPaint(texturePaint);
					g2d.fillRect(start.x*TAILLE_SPRITE, start.y*TAILLE_SPRITE,
							(end.x-start.x+1)*TAILLE_SPRITE, (end.y-start.y+1)*TAILLE_SPRITE);
				}
				else {
					g2d.setColor(Color.BLACK);
					g2d.fillRect(start.x*TAILLE_SPRITE, start.y*TAILLE_SPRITE,
							(end.x-start.x+1)*TAILLE_SPRITE, (end.y-start.y+1)*TAILLE_SPRITE);
 
				}
 
			}
			else {
				if ( sprite!=null ) {
					sprite.draw(g2d, mouseLocation.x*TAILLE_SPRITE, mouseLocation.y*TAILLE_SPRITE, this);
				}
				else {
					g2d.setColor(Color.BLACK);
					g2d.fillRect(mouseLocation.x*TAILLE_SPRITE, mouseLocation.y*TAILLE_SPRITE, TAILLE_SPRITE, TAILLE_SPRITE);
				}
			}
			g2d.dispose();
		}
 
 
 
	}
 
	public static void main(String[] args) throws IOException {
		BufferedImage image = ImageIO.read(new File("fantasy-tileset.png"));
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DemoGrilleJava2D grille = new DemoGrilleJava2D();
		frame.add(grille);
 
		JPanel south = new JPanel(new BorderLayout());
		JLabel label = new JLabel("Effacer");
		south.add(label,BorderLayout.WEST);
		JCheckBox buttonShowGrid = new JCheckBox("Grille");
		buttonShowGrid.setSelected(grille.isGridVisible());
		buttonShowGrid.addActionListener(e-> grille.setGridVisible(buttonShowGrid.isSelected()));
		JButton buttonSprite = new JButton("Sprite");
		JButton buttonEfface = new JButton("Effacer");
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.TRAILING,5,5));
		south.add(buttonPanel,BorderLayout.EAST);
		buttonPanel.add(buttonShowGrid);
		buttonPanel.add(buttonSprite);
		buttonPanel.add(buttonEfface);
		buttonEfface.addActionListener(e-> {
			grille.setCurrentSprite(null);
			label.setText("Effacer");
			label.setIcon(null);
		});
		buttonSprite.addActionListener(e->choixSprite(grille,image,label));
 
		frame.add(south, BorderLayout.SOUTH);
 
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	private static void choixSprite(DemoGrilleJava2D grille, BufferedImage image, JLabel label) {
		JList<Sprite> sprites = new JList<>();
		sprites.setCellRenderer(new DefaultListCellRenderer() {
			@Override
			public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected,
					boolean cellHasFocus) {
				return super.getListCellRendererComponent(list, ((Sprite)value).getIcon(), index, isSelected, cellHasFocus);
			}
		}) ;
		DefaultListModel<Sprite> model = new DefaultListModel<>();
		for(int i=0; i<SPRITE_LIG; i++) {
			for(int j=0; j<SPRITE_COL; j++) {
				model.addElement(new Sprite(image, j, i));
			}
		}
		sprites.setModel(model);
		sprites.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
		sprites.setLayoutOrientation(JList.HORIZONTAL_WRAP);
 
		JDialog dialog = new JDialog(SwingUtilities.getWindowAncestor(grille),"Choix du sprite", ModalityType.DOCUMENT_MODAL);
		dialog.getContentPane().add(sprites);
		sprites.addListSelectionListener(new ListSelectionListener() {
 
			@Override
			public void valueChanged(ListSelectionEvent e) {
				if ( !e.getValueIsAdjusting() ) {
					grille.setCurrentSprite(sprites.getSelectedValue());
					label.setText("");
					label.setIcon(sprites.getSelectedValue().getIcon());
					dialog.dispose();
				}
			}
		});
		dialog.pack();
		dialog.setLocationRelativeTo(grille);
		dialog.setVisible(true);
	} 
 
	public static class Sprite {
 
		private final BufferedImage image;
		private final int xs;
		private final int ys;
		private final ImageIcon imageIcon;
		private BufferedImage subImage;
 
		public Sprite(BufferedImage image, int x, int y) {
			this.image=image;
			this.xs=x*TAILLE_SPRITE;
			this.ys=y*TAILLE_SPRITE;
			subImage = image.getSubimage(xs, ys, TAILLE_SPRITE, TAILLE_SPRITE);
			imageIcon = new ImageIcon(subImage);
		}
 
		public BufferedImage getBufferedImage() {
			return subImage;
		}
 
		public ImageIcon getIcon() {
			return imageIcon;
		}
 
		public void draw(Graphics g, int xd, int yd, ImageObserver observer) {
			g.drawImage(image, xd, yd, xd+TAILLE_SPRITE, yd+TAILLE_SPRITE, xs, ys, xs+TAILLE_SPRITE, ys+TAILLE_SPRITE, observer);
		}
 
 
	}
 
}

Je ne vois pas quel type de boucle réaliser. .

Une boucle sur des cases. C'est ce que je te montre dans le message 21.
Ça c'est une boucle :

Code :

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

for(int i=0; i<bateau.getLongueur(); i++) {

L'image pour la petite démo est en pièce joint (image que j'ai récupérée sur OpenGameArt.org)

[SoulHokib]

Merci !

Je vais me pencher sur l'exemple dès que possible. J'ai juste une question. Est-il possible, par exemple quand je trace ma grille, de prendre l'angle haut gauche de la grille comme coordonnée (0,0) ? (Peut-être est-ce écrit dans l'exemple, je le verrais à ce moment là alors). Ca simplifierait grandement les manipulations. Encore une fois merci beaucoup, je vais rester sur le Java2D.

[joel.drigo]

Est-il possible, par exemple quand je trace ma grille, de prendre l'angle haut gauche de la grille comme coordonnée (0,0) ?

oui, justement, c'est bien le cas, le haut-gauche, c'est toujours 0,0. Et c'est effectivement bien plus facile pour les calculs comme ça.

[SoulHokib]

Je me suis peut-être mal exprimé. Concrètement, quand je vais faire ma fenêtre de jeu, j'aimerais tracer 2 grilles : une ordinateur, une pour le joueur. De ce fait, les deux ne seront pas "collés" à l'angle de la fenêtre (en 0,0), c'est donc possible de faire en sorte que pour chaque grille, son angle en haut à gauche soit considéré comme étant la coordonnée (0,0) (il y'aurait donc un système de coordonnées propre à chaque grille) ?

Si c'est le cas, je me pencherais dessus pour trouver comment faire par moi-même ! Merci encore.

[joel.drigo]

tu gères chaque grille dans un JPanel différent. Tu fais un objet Grille donc (qui étend JPanel). Après tout les deux grilles c'est la même chose, donc autant en faire un objet. Ce qui évitera d'avoir à dupliquer tout le code. Et du coup, dans un panel, tu ne dessines qu'une grille. Donc pas de problème à se poser pour dessiner l'autre. Et ce panel, tu peux en faire autant d'instances que nécessaires, toutes les afficher dans une même fenêtre ou dans plusieurs. Et tu peux même ensuite faire des versions de grille : la grille pour placer peut s'afficher d'une manière légèrement différente que celle pour jouer. Celle du joueur va s'afficher différemment de celle qui correspond à celle de l'autre joueur : dans celle du joueur il voit tous ses bateaux, et dans celle de l'autre, il ne voit que les parties de bateaux qu'il a déjà touchées.

[SoulHokib]

Bonjour !

Cela fait un moment que je ne suis pas passé, mais à l'approche de devoir rendre ma bataille navale, j'ai besoin une dernière fois de votre aide. Tout d'abord, ma bataille navale est finalement fonctionnelle, et j'ai réussi à avoir un rendu qui me plaît. Cependant, un dernier problème subsiste : lorsque je la lance, les cases (des Jbuttons) de mes grilles n'apparaîssent pas tant que je n'ai pas passé ma souris dessus. Ci-dessous un screen pour vous démontrer le problème :



Ci-joint, le code de mon main, qui crée la fenêtre, et celui de mon Panel de joueur, avec la création des cases.

Le main :

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
public class BatailleNavale {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        //Les deux plateaux sont les cases faisant fonctionner le code.
        //Ici, on gère simplement l'interface graphique globale.
        JFrame fenetre = new JFrame();
        PanelFond espacement = new PanelFond();
        JPanel panel_joueur = new javax.swing.JPanel();
        JPanel panel_IA = new javax.swing.JPanel();
        JLabel label_joueur = new javax.swing.JLabel();
        JLabel label_IA = new javax.swing.JLabel();
        JButton Quitter = new javax.swing.JButton();
        Plateau_IA plateau_IA = new Plateau_IA();
        Plateau_joueur plateau_joueur = new Plateau_joueur();
        //On crée les plateaux du joueur et de l'ordinateur ici.
        fenetre.setTitle("Bataille navale");
        fenetre.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        fenetre.setMaximumSize(new java.awt.Dimension(1366, 768));
        fenetre.setMinimumSize(new java.awt.Dimension(1366, 768));
        fenetre.setPreferredSize(new java.awt.Dimension(1366, 768));
        java.awt.GridBagLayout layout = new java.awt.GridBagLayout();
        layout.columnWidths = new int[] {103, 400, 360, 400, 103};
        layout.rowHeights = new int[] {184, 400, 184};
        fenetre.getContentPane().setLayout(layout);
        fenetre.setLocationRelativeTo(null);
        fenetre.setResizable(false);
        fenetre.setLayout(new GridBagLayout());
                javax.swing.GroupLayout panel_joueurLayout = new javax.swing.GroupLayout(panel_joueur);
        panel_joueur.setLayout(panel_joueurLayout);
        panel_joueurLayout.setHorizontalGroup(
            panel_joueurLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 400, Short.MAX_VALUE)
        );
        panel_joueurLayout.setVerticalGroup(
            panel_joueurLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 400, Short.MAX_VALUE)
        );
 
        GridBagConstraints gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 1;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
        fenetre.getContentPane().add(panel_joueur, gridBagConstraints);
 
        javax.swing.GroupLayout panel_IALayout = new javax.swing.GroupLayout(panel_IA);
        panel_IA.setLayout(panel_IALayout);
        panel_IALayout.setHorizontalGroup(
            panel_IALayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 400, Short.MAX_VALUE)
        );
        panel_IALayout.setVerticalGroup(
            panel_IALayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 400, Short.MAX_VALUE)
        );
 
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 3;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
        fenetre.getContentPane().add(panel_IA, gridBagConstraints);
 
        label_joueur.setFont(new java.awt.Font("Nirmala UI", 1, 24)); // NOI18N
        label_joueur.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
        label_joueur.setText("Grille du joueur");
        label_joueur.setVerticalAlignment(javax.swing.SwingConstants.BOTTOM);
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 1;
        gridBagConstraints.gridy = 0;
        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
        fenetre.getContentPane().add(label_joueur, gridBagConstraints);
        label_joueur.getAccessibleContext().setAccessibleName("Grille Joueur");
 
        label_IA.setFont(new java.awt.Font("Nirmala UI", 1, 24)); // NOI18N
        label_IA.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
        label_IA.setText("Grille de l'ordinateur");
        label_IA.setVerticalAlignment(javax.swing.SwingConstants.BOTTOM);
        label_IA.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 3;
        gridBagConstraints.gridy = 0;
        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
        fenetre.getContentPane().add(label_IA, gridBagConstraints);
 
        Quitter.setText("Abandonner");
        Quitter.setVerticalAlignment(javax.swing.SwingConstants.BOTTOM);
        Quitter.addActionListener(event -> fermer());
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 1;
        gridBagConstraints.gridy = 4;
        fenetre.getContentPane().add(Quitter, gridBagConstraints);
 
        javax.swing.GroupLayout espacementLayout = new javax.swing.GroupLayout(espacement);
        espacement.setLayout(espacementLayout);
        espacementLayout.setHorizontalGroup(
            espacementLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 400, Short.MAX_VALUE)
        );
        espacementLayout.setVerticalGroup(
            espacementLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 400, Short.MAX_VALUE)
        );
 
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 2;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
        fenetre.getContentPane().add(espacement, gridBagConstraints);
 
        panel_joueur.add(plateau_joueur);
        panel_IA.add(plateau_IA);
        fenetre.pack();
        fenetre.setVisible(true);
    } 
 
    private static void fermer(){
        System.exit(0); 
    }
}

Ci-dessous mon panel de joueur, avec les parties intéressantes :

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
public class Plateau_joueur extends JPanel {
 
    protected static ArrayList<Bateau> lesBateaux = new ArrayList<>(); //Liste des bateaux du joueur.
    private static final int SIZE = 10; // nombre de lignes et colonnes
    protected static Case[][] lesCases; // un tableau pour ranger toutes les cases de la grille, leur état et les bateaux en leur sein.
    protected static int place = -1;//variable de placement utilisée dans un switch. Lorsqu'elle arrive à 4, on passe au jeu.
    Random rand = new Random();
 
    public Plateau_joueur() {
        //Sur toute cette section, création des cases de la bataille navale.
        //Elles sont ajoutées au plateau du joueur : grille de 10x10.
        final Icon grillevideicon = new ImageIcon("case_vide.jpg");
        lesCases = new Case[SIZE][SIZE];
        this.setVisible(true);
        this.setSize(400, 400);
        this.setLayout(new GridLayout(SIZE, SIZE));
        this.revalidate();
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                int x = i;
                int y = j;
                lesCases[i][j] = new Case(i, j);
                lesCases[i][j].setEtats(Etats.MER);//Toutes les cases sont initialisées à un état de mer.
                lesCases[i][j].setIcon(grillevideicon);//On attribue une icone, initialisée plus haut. Les images sont fournies dans le package.
                lesCases[i][j].addActionListener(event -> caseClick(lesCases[x][y]));
                lesCases[i][j].setSize(40,40);
                lesCases[i][j].setVisible(true);
                this.add(lesCases[i][j]);//Ajout de la grille de cases au JPanel
            }
        }
        //création de la vue des cases
    }

Encore une fois en avance, merci pour votre aide.

[joel.drigo]

Salut,

Ne voyant rien de spécial, j'ai repris les deux classes et j'ai complété, en affichant des JButton normaux. Aucun souci de mon côté, ils sont bien tous visibles. Donc, à priori, le problème est dans la classe Case. Tu peux me montrer le code ?

[SoulHokib]

Merci pour la réponse rapide, voici ma classe Case :

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
package bataillenavale;
 
import java.awt.Graphics;
import javax.swing.JButton;
 
/**
 *
 * @author Utilisateur
 */
public class Case extends JButton {
//Classe héritant des propriétés  des JButton.
 
    protected int X;
    protected int Y;
    protected Etats e;
    protected Bateau b;
 
    //On crée une case avec des coordonnées (X,Y)
    public Case(int x, int y) {
        X = x;
        Y = y;
    }
 
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
    }
 
    @Override
    //Getter de coordonnée X.
    public int getX() {
        return X;
    }
 
    //Setter de coordonnée X.
    public void setX(int x) {
        X = x;
    }
 
    //Setter de coordonnée Y.
    public void setY(int y) {
        Y = y;
    }
 
    //Setter de l'état d'une case (MER,BATEAU,...).
    public void setEtats(Etats et) {
        e = et;
    }
 
    //Setter de bateau d'une case.
    public void setBateau(Bateau bat) {
        b = bat;
    }
 
    //Méthode pour enlever un bateau. Utilisé pour la réinitialisation du jeu.
    public void removeBateau() {
        b = null;
    }
 
    //Getter de l'état d'une case (MER,BATEAU,...).
    public Etats getEtat() {
        return e;
    }
 
    //Getter du bateau d'une case.
    public Bateau getBateau() {
        return b;
    }
 
    @Override
    //Getter de la coordonnée Y.
    public int getY() {
        return Y;
    }
 
}

[joel.drigo]

Le gros problème, c'est que tu redéfinis des méthodes de Swing avec tes propres méthodes, du coup ça le fait foirer jusqu'à qu'il rattrape le problème (et du coup ça doit foutre la zone dans ton appli, à moins que tu ne fasses tout ça pour rien (je veux dire que tu ne t'en sers pas) ce qui est doublement dommage.

setX(), getX(), setY(), getY() ce sont des méthodes de Swing, dont il se sert pour positionner les composants dans un container. Comme toi tu les as rédéfinis pour t'en servir pour tes propres données à toi, plus rien de fonctionne correctement jusqu'à ce qu'un layout passe et ça remet tout en ordre (mais il n'est pas exclu que ça puisse refoirer).

Nulle part dans ton code tu utilises ces méthodes pour connaître les valeurs de X et Y ou les modifier. D'ailleurs, à quoi ça servirait de les modifier : une case ne bouge pas dans le tableau. Donc déjà supprime setX et setY. Et si tu n'a pas eu besoin d'appeler les getX() et getY(), tu peux aussi bien les enlever. D'ailleurs, tu pourrais aussi bien du coup virer X et Y, puisque tu ne t'en sers pas.

[SoulHokib]

Je vais essayer de les supprimer et je reviendrais vers vous pour vous tenir au courant. Merci de la réponse.

EDIT : C'était bien ça. Je vous remercie, plus qu'à intégrer ça dans notre boîte à jeu et à rendre le travail. Merci beaucoup pour toute l'aide apportée au cours de mon projet.