Discussion :

[tamerla]

Salut,

je suis en train de programmer un jeu qui nécessite un plateau de jeu (une grille quoi). Cependant je ne sais pas quelle est la manière la plus judicieuse de coder ça.
J'ai une classe Plateau qui étend JPanel , ainsi qu'une classe Case et Pion qui étendent aussi de JPanel. J'ai alors opté pour un tableau de Case à deux dimensions que j'ai mis dans un GridLayout dans Plateau. Cependant je trouve cette méthode lourde car beaucoup de JPanel sont crées (le plateau peut avoir une taille max de 20x20) ... sachant aussi que j'aimerai pouvoir déplacer mes objets Pions sur le plateau avec une animation de déplacement.

J'ai aussi pensé a dessiner un grillage en redefinissant paintComponent(Graphics g), cependant cette méthode me semble un peu "abstraite" vu que c'est finalement juste visuel , on ne peut pas vraiment interagir avec..

Quelle serait finalement la meilleur méthode pour mes besoins ?
merci.

[joel.drigo]

Salut,

On peut coder l'affichage en SWING d'un plateur de type tableau de cases (damier, échiquier, etc...) avec des composants SWING (tes que des JPanel, des JLabel, des Canvas, etc...), placés dans un JPanel. Le nombre ne pose pas vraiment de problème tant qu'on reste dans certaines limites. Aucun problème pour faire 10x10 cases. J'ai jamais vraiment fait de tests avec beaucoup plus, mais pour avoir fait des interfaces graphiques d'applications professionelles ent SWT avec des centaines de composants, voire des milliers, je ne pense pas que ça soit vraiment un problème de le faire en SWING. C'est sûr qu'il y a toujours une limite.

Ensuite, personnellement, je trouve que pour faire des jeux, il devient souvent très vite intéressant d'abandonner cette méthode pour faire un système qui dessine directement dans un Canvas, ou un JPanel, donc en redéfinissant paintComponent() (ou paint() pour Canvas). Bien sûr cela oblige à redéfinir un minimum de choses pour reproduire l'interaction (rien de très complexe) qu'on peut avoir avec un système à la composants SWING, mais la gestion de l'emplacement des éléments, les possiblités graphiques étendues, sont beaucoup plus pratiques dès qu'on veut des graphismes un peu évolués (en particulier grâce aux Composites les transformées affines, le cliping, les Shape (et en particulier les Path2D ou les Area), etc.), ou des animations.

Les possibilités d'agencement avec les LayoutManagers sont souvent très formatées pour faire des UI qui ne sont pas vraiment celles des jeux. On se retrouve donc, lorsqu'on fait des jeux, à devoir faire plein de code supplémentaire pour que les graphismes soient satisfaisants, et on peut même être très restreint et ne pas pouvoir faire tout ce qu'on veut, ou le faire avec moins de facilités que par dessin direct. Au final, autant refaire son propre système, car on a tellement de code à soi, et on utilise finalement que très peu de code des composants SWING : en faisant ses propres composants, on a des composants plus légers qui font exactement ce qu'on veut. Il y a probablement des bibliothèques de base qui permettent de le faire. Je n'en connais pas spécifiquement pour faire des jeux, mais j'en utilise une pour faire une ZUI dans une application professionelle (Piccolo2D) qui est infiniment plus pratique que SWING, et permet de faire des zooms, des rotations, des animations et pleins d'autres choses, qui demanderaient beaucoup de travail en SWING. Cette bibliothèque pourrait être utilisée sans problème pour faire des jeux de type plateaux.

[tamerla]

Merci pour cette réponse enrichissante.
Je pense me diriger vers la premiere solution qui me semble etre la plus adaptée car le jeu est assez basique.

Cependant si je redefinissais la méthode paintComponent(), je me demandais comment je pourrai gérer la taille des cases de la grille quand la fenetre du jeu change de taille vu qu'il ny'a plus de layout, et aussi comment faire pour avoir un système de coordonnées plus "simple" (par exemple la premiere case serait (0,0), celle de droite (0,1) au lieu d'utiliser les coordonnées absolues, ce qui me semble compliquer pour gérer le placement des objets)
?

[joel.drigo]

Merci pour cette réponse enrichissante.
Je pense me diriger vers la premiere solution qui me semble etre la plus adaptée car le jeu est assez basique.

Cependant si je redefinissais la méthode paintComponent(), je me demandais comment je pourrai gérer la taille des cases de la grille quand la fenetre du jeu change de taille vu qu'il ny'a plus de layout,

Le fait qu'il y ait plus de layout implique juste qu'on a le gérer soi-même : ensuite ça dépend de ce qu'on veut faire :

• On peut avoir un plateau dont la taille s'ajuste à taille de la fenêtre : l'échelle d'affichage dépend de la taille de la fenêtre,
• ou on verra plus ou moins de cases selon la taille de la fenêtre
• Ou c'est les éléments autour du plateau qui varient en fonction de la taille de la fenêtre, affichant plus ou moins d'informations, à différents endroits, selon la place disponible
• un combinaison des trois précédents, avec une échelle maximum,

et aussi comment faire pour avoir un système de coordonnées plus "simple" (par exemple la premiere case serait (0,0), celle de droite (0,1) au lieu d'utiliser les coordonnées absolues, ce qui me semble compliquer pour gérer le placement des objets)
?

Là, je pense ne pas comprendre ce que tu veux dire, parce que je comprends que tu veux parler de passer d'un système de coordonnées dans le tableau 2D à un système de coordonnées graphiques 2D.

Pour un nombre de cases fixes : Or, ça se fait pas division entière tout simplement. Pour un plateau plus grand que l'écran (et scrolling), on prendra une base de taille (par exemple une échelle nominal qui dit à l'échelle 1, on doit voir tant de cases (ou une case a telle taille métrique), quelque soit la taille et la résolution de l'écran, ce qui permet de définir une échelle standard.

A moins que tu parles de passer de coordonnées linéaires 1D à un système de coordonnées 2D et vice versa :

• y = index / nb en largeur (division entière)
  x = index reste de la division entière y / nb en largeur (modulo)
• index = y * nb en largeur + x

[tamerla]

Merci pour ces infos , elles me seront surement utiles bientot .

Par contre j'ai une question par rapport à mon projet, j'utilise donc un tableau[][] de JPanel qui se trouvent dans un JPanel et un GridLayout pour agencer tout ça.
J'imagine bien que c'est pas la meilleure idée mais c'est celle qui me paraissait le plus simple pour faire une grille pour un jeu simple. Cependant je suis confronté à un problème car j'aimerai pouvoir réaliser une sorte d'animation de déplacement, pour cela j'ai essayé de déplacer mes Pions JPanel sur le tableau mais rien à faire ca ne fonctionne pas en modifiant les coordonnées absolues.

J'ai laissé tomber cette idée et j'ai essayé de dessiner mes Pions avec paintComponent() (en ajoutant une image), là j'arrive a déplacer mes pions en modifiant leurs attributs x, y dans une boucle et avec repaint() pour les redessiner, cependant mes pions n'apparaissent plus dans les cases du tableau mais derrière le tableau ...(je sais pas si je suis clair).
Je m'y prends mal surement mais j'aimerai pouvoir concilier mon tableau de JPanel dans un gridLayout avec mes Pions qui sont aussi des JPanel et que j'aimerai pouvoir déplacer par une animation et pas seulement les supprimer pour les ajouter dans une autre case.
merci (je peux mettre du code si jamais ce n'est pas clair).

[joel.drigo]

Cependant je suis confronté à un problème car j'aimerai pouvoir réaliser une sorte d'animation de déplacement, pour cela j'ai essayé de déplacer mes Pions JPanel sur le tableau mais rien à faire ca ne fonctionne pas en modifiant les coordonnées absolues.

C'est tout-à-fait normal : un LayoutManager contrôle les bounds (position et dimensions) de chaque composant. Donc tout ce que tu peux faire en modifiant toi-même la position ou les dimensions sera "annulé" par le LayoutManager.

J'ai laissé tomber cette idée et j'ai essayé de dessiner mes Pions avec paintComponent() (en ajoutant une image), là j'arrive a déplacer mes pions en modifiant leurs attributs x, y dans une boucle et avec repaint() pour les redessiner, cependant mes pions n'apparaissent plus dans les cases du tableau mais derrière le tableau ...(je sais pas si je suis clair).

Il faut redéfinir paintChildren() au lieu de paintComponent()

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
public class Dammier extends JPanel {
 
	public Dammier() {
		super(new GridLayout(0, 10));
		for (int i = 0; i < 10; i++) {
			for (int j = 0; j < 10; j++) {
				JPanel panel = new JPanel();
				if (j % 2 == (i % 2 == 0 ? 0 : 1)) {
					panel.setBackground(Color.WHITE);
				} else {
					panel.setOpaque(false);
				}
				add(panel);
			}
		}
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		int w = getWidth() / 2;
		int h = getHeight() / 2;
		g.setColor(Color.RED);
		g.fillRect(0, 0, w, h);
	}
 
	@Override
	protected void paintChildren(Graphics g) {
		super.paintChildren(g);
		int w = getWidth() / 2;
		int h = getHeight() / 2;
		g.setColor(Color.GREEN);
		g.fillRect(w, h, w, h);
	}
 
	public static void main(String[] args) {
		SwingUtilities.invokeLater(() -> run());
	}
 
	private static void run() {
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		JPanel mainPanel = new Dammier();
 
		frame.getContentPane().add(mainPanel);
 
		frame.setSize(300, 300);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
	}
 
}

Je m'y prends mal surement mais j'aimerai pouvoir concilier mon tableau de JPanel dans un gridLayout avec mes Pions qui sont aussi des JPanel et que j'aimerai pouvoir déplacer par une animation et pas seulement les supprimer pour les ajouter dans une autre case.
merci (je peux mettre du code si jamais ce n'est pas clair).

Tu peux aussi utiliser les GlassPane, ou les JLayer.