Discussion :

[joel.drigo]

Et bien :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
grille.addImageClicker(new CodeGrille.ImageClicker() {
 
			@Override
			public void click(int colonne, int ligne, int image) {
				if ( image==0 ) {
                                     // ici code pour la première image
                                }
                                else {
                                     // code pour la seconde
                                }
			}
 
		});

[joel.drigo]

ensuite, ça peut dépendre de ce que tu veux faire aussi. Par exemple, si tu voulais remplacer l'image cliquée par l'autre, on pourrait procéder comme ça :

Faire une méthode dans CodeGrille :

Code :

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

1
2
3
4
public void toggleImage(int colonne, int ligne) {
    grid[ligne][colonne] = 1-grid[ligne][colonne]; // marche seulement si on a que 2 images
    repaint();
}

Et :

Code :

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

1
2
3
4
5
6
grille.addImageClicker(new CodeGrille.ImageClicker() {
 
			@Override
			public void click(int colonne, int ligne, int image) {
				grille.toggleImage(colonne, ligne);
			}

[LeMarseillais78]

D' accord Merci , ce système je voudrais l intégrer à ma propre classe je te la montre:

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 CreationGrille extends JPanel {
 
	GenerateurCarte generateurCarte = new GenerateurCarte();//mon generateur de carte qui va me permettre de generer la carte
	JoueurHumain joueurHumain = new JoueurHumain("joueur1");
	JoueurHumain joueurHumain2 = new JoueurHumain("joueur2");
	ArrayList<ModelJoueur> joueurs = new ArrayList<ModelJoueur>();
	GrilleJeu grille = new GrilleJeu();
 
 
 
	public  void initialisation(){
		joueurs.add(joueurHumain);//j ajoute 2 joueurs humains
		joueurs.add(joueurHumain2);
		GrilleJeu grilleJeu = generateurCarte.genererCarte(5, 5,ConstanteCarte.VALEUR_MAX_GENERATEUR/5, new ArrayList<ModelJoueur>());//je genere ma carte de la grille de jeu
	}
 
 
	public void grilleGraphique(GrilleJeu grilleJeu,int i,int ii,Graphics g){
		CaseTerrain[][]  caseTerrains = grille.getGrille();
 
		String id = caseTerrains[i][ii].getTerrain().getIdentifiant();
		int width = getWidth();
		int height = getHeight();
		int largeur = width / grille.getAbcisseMax();
		int hauteur = height / grille.getOrdonneeMax();
		Image img;
		ImageIcon in=new ImageIcon("bleu.jpg");
		img=in.getImage();
		Image img2;
		ImageIcon in2=new ImageIcon("vert.jpg");
		img2=in2.getImage();
		for(i = 0 ; i < grille.getAbcisseMax();i++){
			for(ii = 0; ii < grille.getOrdonneeMax(); ii++){
				int x = ii * largeur;
				int y = i * hauteur;
 
				if(id.equals("terrain")){//si le terrain est un terrain neutre je dessine cette image
					g.drawImage(img, x, y, largeur, hauteur, this); 
 
				}
 
				if(id.equals("mer")){// sinon si c la mer je dessine cette image la
					g.drawImage(img2, x, y, largeur, hauteur, this);
				}
 
 
 
				}
			}
		}
	}

Classe Grille jeu

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
 
 
public class GrilleJeu {
	private int abcisseMax;
	private int ordonneeMax;
	private CaseTerrain[][] grille;
	private ArrayList<CoordonneesTerrain> listeCoordonnes = new ArrayList<CoordonneesTerrain>();
	private HashMap<CoordonneesTerrain, ModelTerrainJeu> listeTerrain = new HashMap<CoordonneesTerrain,ModelTerrainJeu>();
 
	public GrilleJeu() {
		this(5, 5);
	}
 
	public GrilleJeu(int x, int y) {
		this.abcisseMax = x;
		this.ordonneeMax = y;
		this.grille = new CaseTerrain[x][y];
		for (int i = 0; i < x; i++) {
			for (int ii = 0; ii < y; ii++) {
				grille[i][ii] = new CaseTerrain(i, ii);
				listeCoordonnes.add(new CoordonneesTerrain(i, ii));
			}
		}
	}
 
	public ArrayList<CoordonneesTerrain> getListeCoordonnes() {
		return listeCoordonnes;
	}
 
	public HashMap<CoordonneesTerrain, ModelTerrainJeu> getListeTerrain() {
		return listeTerrain;
	}
 
	public int getAbcisseMax() {
		return abcisseMax;
	}
 
	public int getOrdonneeMax() {
		return ordonneeMax;
	}
 
	public CaseTerrain[][] getGrille() {
		return grille;
	}
 
	public void setTerrainAt(CoordonneesTerrain coordonneesTerrain, ModelTerrainJeu terrain) {
		int x = coordonneesTerrain.getX();
		int y = coordonneesTerrain.getY();
		if (x > 0 && x < abcisseMax && y > 0 && y < ordonneeMax) {
			grille[x][y].setTerrain(terrain);
		}
	}
 
	public String toString() {
		String el = "abcisseMax=" + abcisseMax + "\n ordonneeMax="
				+ ordonneeMax + "\n";
		for (int i = 0; i < abcisseMax; i++) {
			for (int ii = 0; ii < ordonneeMax; ii++) {
				el += grille[i][ii]+ "\n";
			}
		}
		return el;
	}
 
}

La classe CaseTerrain:

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 CaseTerrain {
	private ModelTerrainJeu terrain;
	private CoordonneesTerrain coordonneesTerrain;
 
	public CaseTerrain(){
 
	}
 
	public CaseTerrain(int x , int y){
		this( new TerrainNonDefini(), x ,y);
 
 
	}
 
	public CaseTerrain(ModelTerrainJeu terrain , int x , int y){
		this(terrain ,new CoordonneesTerrain(x, y));	
	}
 
	public CaseTerrain(ModelTerrainJeu terrain,CoordonneesTerrain coordonneesTerrain){
		this.coordonneesTerrain = coordonneesTerrain;
		this.terrain = terrain;
	}
 
	public ModelTerrainJeu getTerrain() {
		return terrain;
	}
 
	public CoordonneesTerrain getCoordonneesTerrain() {
		return coordonneesTerrain;
	}
 
	public void setTerrain(ModelTerrainJeu terrain) {
		this.terrain = terrain;
	}
 
	@Override
	public String toString() {
		return "CaseTerrain [terrain=" + terrain + ", coordonneesTerrain="
				+ coordonneesTerrain + "]";
	}
 
 
 
 
 
}

[joel.drigo]

Déjà, dans :

Code :

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

public void grilleGraphique(GrilleJeu grilleJeu,int i,int ii,Graphics g){

Tu peux enlever grilleJeu, puisque c'est la variable grille qui doit être utilisé (d'ailleurs nulle part tu utilises grilleJeu dans la méthode). Tu peux également virer la boucle, puisque le but est de dessiner la case i, ii (utilises plutôt des variables avec des noms plus significatifs). Charges tes images une fois pour toute, elles ne prennent probablement pas énormément de mémoire, et ça évitera de perdre du temps dans des io pendant la phase de dessin (tu auras un affichage plus rapide du coup).

Sinon, pour adapter mon exemple au tiens, là ou je manipule grid, tu manipules grilles, et tu remplaces les constantes NB_LIGNES et NB_COLONNES par les appels à tes méthodes : grille.getAbcisseMax() et grille.getOrdonneeMax(). Et au lieu de passer l'indice dans le tableau images, tu peux passer peut être l'instance de CaseTerrain, ou passer celle de GrilleJeu, qui te permet de récupérer la case

Ca pourrait donner (enfin tu peux changer le nom en CaseClicker, ou TerrainCLicker ou ce que tu veux qui ait plus de sens dans le contexte de ton programme) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
	public static abstract class ImageClicker {
 
		public ImageClicker() {
		}
 
                // tu n'est pas obligé de mettre les 2, la première peux suffire à tout faire
                // la seconde peut simplifier certains traitements qui ne concernent que la case seule
                // si tu ne mets qu'une seule méthode, au lieu d'une classe abstraite, ImageClicker peut être une interface
		public void click(GrilleJeu source, int colonne, int ligne) {
                }
		public void click(CaseTerrain caseTerrain) {
                }
 
 
	}

Et dans CreationGrille :

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
public void addImageClicker(final ImageClicker imageClicker) {
                // en encapsule le faux listener dans le vrai listener de souris (ici un MouseAdapter, une implémentation de MouseListener qui ne t'oblige pas à implémenter toutes ses méthodes (parce qu'elles le sont déjà)
		addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(MouseEvent e) {
                                // comme je l'ai dit, on calcule la hauteur et la largeur de la m^me manière qu'on la fait pour dessiner
				int width = getWidth();
				int height = getHeight();
				int largeur = width / grille.getAbcisseMax();
				int hauteur = height / grille.getOrdonneeMax();
                                // on détermine la colonne et la ligne dans la grille
				int colonne = e.getX()/largeur;
				int ligne = e.getY()/hauteur;
                                // on transmet les informations au faux listener, de manière à ce qu'on puisse réagir avec quand on l'utilise
				imageClicker.click(grille.getGrille()[colonne][ligne]);
				imageClicker.click(grille, colonne, ligne);
			}
		});
	}

Si on a besoin de gérer le click hors contexte, uniquement sur la case, on fait :

Code :

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

1
2
3
4
5
6
grille.addImageClicker(new CodeGrille.ImageClicker() {
 
			@Override
			public void click(CaseTerrain caseTerrain) {
				// code...
			}

Si tu as besoin de gérer le click dans un contexte plus général (comme par exemple avoir besoin de tester les cases autour de la case cliquée), tu fais :

Code :

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

1
2
3
4
5
6
grille.addImageClicker(new CodeGrille.ImageClicker() {
 
			@Override
			public void click(GrilleJeu source, int colonne, int ligne) {
				// code... 
			}

[LeMarseillais78]

Merci mais vu que je suis débutant en Graphics j'ai mis quelques commentaire.

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
 
 
 
public class CreationGrille extends JPanel {
 
	GenerateurCarte generateurCarte = new GenerateurCarte();//mon generateur de carte qui va me permettre de generer la carte
	JoueurHumain joueurHumain = new JoueurHumain("joueur1");
	JoueurHumain joueurHumain2 = new JoueurHumain("joueur2");
	ArrayList<ModelJoueur> joueurs = new ArrayList<ModelJoueur>();
	GrilleJeu grille = new GrilleJeu();
 
 
 
	public  void initialisation(){
		joueurs.add(joueurHumain);//j ajoute 2 joueurs humains
		joueurs.add(joueurHumain2);
		GrilleJeu grilleJeu = generateurCarte.genererCarte(5, 5,ConstanteCarte.VALEUR_MAX_GENERATEUR/5, new ArrayList<ModelJoueur>());//je genere ma carte de la grille de jeu
	}
 
 
	public void grilleGraphique(GrilleJeu grille,int i,int j,Graphics g){
		CaseTerrain[][]  caseTerrains = grille.getGrille();
 
		String id = caseTerrains[i][j].getTerrain().getIdentifiant();
		int width = getWidth();
		int height = getHeight();
		int largeur = width / grille.getAbcisseMax();
		int hauteur = height / grille.getOrdonneeMax();
		Image img;// Quand tu dis charger les images ca veut dire quoi? Elles sont pas chargé la?
		ImageIcon in=new ImageIcon("bleu.jpg");
		img=in.getImage();
		Image img2;
		ImageIcon in2=new ImageIcon("vert.jpg");
		img2=in2.getImage();
		for(i = 0 ; i < grille.getAbcisseMax();i++){//je supprime cette boucle 
			for(j = 0; j < grille.getOrdonneeMax(); j++){//et celle la ?
				int x = j * largeur;
				int y = i * hauteur;
 
				if(id.equals("terrain")){
					g.drawImage(img, x, y, largeur, hauteur, this); 
 
				}
 
				if(id.equals("mer")){
					g.drawImage(img2, x, y, largeur, hauteur, this);
				}
 
 
 
				}
			}
		}
	}

[joel.drigo]

// Quand tu dis charger les images ca veut dire quoi? Elles sont pas chargé la?

Oui, elles sont bien chargées ici. Mais cette méthode ne dessiner qu'une seule case, et n'utilise qu'une seule des deux images : il faudra donc l'appeler autant de fois qu'il y a de case, et à chaque fois qu'il est nécessaire de redessiner (ce que tu ne contrôle pas dans l'absolu, puisque SWING peut estimer qu'il est nécessaire à un moment donné de redessiner. Donc ces 2 images, vont être chargées des centaines de fois, voire plus, alors qu'il suffit de les charger qu'une seule fois : une fois en mémoire, elles le sont. Il suffit que les variables qui contiennent les références des instances de BufferedImage soient accessibles de là où tu as besoin d'y accèder. Dans mon code exemple, c'était le tableau image qui permettait de faire ça.
Un moyen simple, c'est que la classe ModelTerrainJeu ait une méthode getImage() .

Et, oui, c'est bien les 2 boucles qu'il faut supprimer : en laissant ces boucles, tu affiches au même endroit la même image (ni id, ni i, ni ii, ne changent, pendant l'exécution des 2 boucles ), mais autant de fois qu'il y a de case. Si tu as 10x10 cases, tu redessines 100 fois la même image au même endroit, alors qu'une seule fois par appel est suffisante ; comme tu as forcément cette double boucle ailleurs qui appelle cette méthode pour chaque case du terrain (tu n'as pas mis tout le code du JPanel, mais elle est forcément quelque part, peut être directement dans la méthode paint()), tu vas faire cette double boucle pour chaque case du tableau : donc en fait tu redessiner 10000 images au lieu de 100). En plus tu recalcules x et y à chaque fois : ça dure pas longtemps ce genre de calcul, si on le fait qu'une fois. Mais le répéter inutilement peux faire que le redessin de ton appli perde un peu en fluidité, et en réactivité. Comme c'est le même thread qui gère l'affichage et l'interaction (souris, clavier, etc..), tout temps perdu dans l'un des deux, se ressent un petit peu. Le cumul de tous ces temps perdus peut avoir un effet désagréable sur la fluidité et la réactivité de l'application. Et quand c'est facile d'éviter ces pertes de temps, autant le faire.

[LeMarseillais78]

Je ne vois pas la méthode qu'il faut utiliser pour charger les images.

[joel.drigo]

Bah exactement la même que tu utilises déjà, mais le faire soit dans la classe ModelTerrainJeu, doit passer l'mage en paramètre du constructeur de cette classe. Je n'ai pas le code de cette classe, mais je suppose que c'est quelque chose comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ModelTerrainJeu {
 
      private String id;
 
      public ModelTerrainJeu(String id) {
           this.id=id;
      }
 
      public String getIdentifant() {
          return id;
      }
 
}

donc tu peux faire, 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
public class ModelTerrainJeu {
 
      private String id;
      private Image image;
 
      public ModelTerrainJeu(String id, Image image) {
           this.id=id;
           this.image=image;
      }
 
      public String getIdentifant() {
          return id;
      }
 
      public Image getImage() {
          return image;
      }
 
}

Et quand tu créés tes instances :

Code :

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

new ModelTerrainJeu("terrain", new ImageIcon("vert.jpg").getImage());

et

Code :

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

new ModelTerrainJeu("mer", new ImageIcon("bleu.jpg").getImage());

[LeMarseillais78]

Et pour dessiner la grille dans création grille sa se passera comment sans les deux boucles for?

[LeMarseillais78]

Et si je veux donner une action à une image et à une autre je fais comment? Je commence a être perdu...

[joel.drigo]

C'est ce que je te disais : il faut les 2 boucles for pour afficher toutes les cases, mais pas à l'endroit ou tu les avait mises. Ta méthode prend en paramètres (i et ii) les coordonnées d'une case : donc elle ne dessine qu'une case. Mais cette méthode doit être appelée dans la double boucle pour dessiner toutes les cases. Cette double boucle est soit dans une méthode chargée de dessiner toutes la grille soit directement dans la méthode paint() du JPanel (dans la redéfinition de la méthode).

Mais excuses-moi, je n'avais pas vu que tu utilisais les mêmes variables en argument et comme indices des boucles : on fait jamais ça, justement pour éviter les confusions. En plus du coup, ta méthode dessinais le même terrain sur l'ensemble de la carte.

Donc, en résumé, tu peux écrire ta méthode comme ça :

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
 
	public void grilleGraphique(Graphics g){
		CaseTerrain[][]  caseTerrains = grille.getGrille();
 
		int width = getWidth();
		int height = getHeight();
		int largeur = width / grille.getAbcisseMax();
		int hauteur = height / grille.getOrdonneeMax();
		for(int i = 0 ; i < grille.getAbcisseMax();i++){
			for(int ii = 0; ii < grille.getOrdonneeMax(); ii++){ // ici tu peux mettre j au lieu de ii, pour plus de lisibilité
				int x = ii * largeur;
				int y = i * hauteur;
                               ModelTerrainJeu terrain = caseTerrains[i][ii].getTerrain();
 
                                g.drawImage(terain.getImage(), x, y, largeur, hauteur, this); 
 
				}
			}
		}
	}

[joel.drigo]

Et si je veux donner une action à une image et à une autre je fais comment? Je commence a être perdu...

Comme tu as une classe ModelTerrainJeu, ne raisonnes plus en termes d'images, mais de type de terrain : c'est en partie à ça que servent les classes : rendre plus abstrait le raisonnement.

Dans l'exemple suivant, que je t'ai donné :

Code :

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

1
2
3
4
5
6
7
8
9
grille.addImageClicker(new CodeGrille.ImageClicker() {
 
			@Override
			public void click(CaseTerrain caseTerrain) {
				ModelTerrainJeu terrain = caseTerrain.getTerrain();
                                if ( "mer".equals(terrain.getIdentifiant()) {
                                     // faire l'action qu'on veut quand on clique sur une case mer
                                }
			}

Bon, ici, au risque de rajouter une couche qui risque de te perdre un petit peu plus, je n'utiliserais pas personnellement de String "mer". Au pire, j'utiliserais une constante, pour éviter le risque de faute de frappe, ou d'avoir à me souvenir du mot exacte que j'ai utilisé (ou d'avoir à changer à plein d'endroit, si je veux changer le mot parce que je fais évolue le programme). Au mieux j'utiliserais une enum, ce qui rend plus facile les tests, plus lisible, et permet en plus de bénéficier de la complétion dans l'IDE, pour pas se tromper.

Si je reprends mon précédent 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
public class ModelTerrainJeu {
 
      public enum TypeTerrain {
            MER, TERRAIN;
      }
 
      private TypeTerrain type;
      private Image image;
 
      public ModelTerrainJeu(TypeTerrain type, Image image) {
           this.type=type;
           this.image=image;
      }
 
      public TypeTerrain getType() {
          return id;
      }
 
      public Image getImage() {
          return image;
      }
 
}

et l'écouteur devient :

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
grille.addImageClicker(new CodeGrille.ImageClicker() {
 
			@Override
			public void click(CaseTerrain caseTerrain) {
				ModelTerrainJeu terrain = caseTerrain.getTerrain();  
                                switch( terrain.getType() ) {
                                       MER:
                                           // faire l'action qu'on veut quand on clique sur une case mer
                                           break;
                                       TERRAIN:
                                           // faire l'action qu'on veut quand on clique sur une case terrain
                                           break;
                                       default;
                                }
			}

[LeMarseillais78]

D'accord merci et excuse moi mais pour la classe CreationGrille pour les méthodes là je suis totalement perdu mais totalement.. Si tu pourrais juste me la montrer compléte avec les dessins de la grille stp sa serait sympa...

[joel.drigo]

Je vais pas refaire tout ton code non plus, mais si on assemble tout ce que j'ai dit :

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
 
 
 
public class CreationGrille extends JPanel {
 
        // ça je touche pas, je ne sais pas tout ce que tu cherches à faire, et tu verras les erreurs dedans plus tard (j'en vois 2 au moins)
	GenerateurCarte generateurCarte = new GenerateurCarte();//mon generateur de carte qui va me permettre de generer la carte
	JoueurHumain joueurHumain = new JoueurHumain("joueur1");
	JoueurHumain joueurHumain2 = new JoueurHumain("joueur2");
	ArrayList<ModelJoueur> joueurs = new ArrayList<ModelJoueur>();
	GrilleJeu grille = new GrilleJeu();
 
       // je sais pas ou tu appelles initialisation, mais il pourrait être appelé dans le constructeur 
       public CreationGrille() {
            initialisation();
       }
 
	public  void initialisation(){
		joueurs.add(joueurHumain);//j ajoute 2 joueurs humains
		joueurs.add(joueurHumain2);
		GrilleJeu grilleJeu = generateurCarte.genererCarte(5, 5,ConstanteCarte.VALEUR_MAX_GENERATEUR/5, new ArrayList<ModelJoueur>());//je genere ma carte de la grille de jeu
	}
        // jusque là j'ai  pas touché
 
        // maintenant pour dessiner dans un panel, il faut au moins redéfinir paint :
        public void paint(Graphics g) {
             super.paint(g);
             // et appeler le code qui dessiner ce qu'on veut...
             grilleGraphique(g);
        } 
 
	public void grilleGraphique(Graphics g){
		CaseTerrain[][]  caseTerrains = grille.getGrille();
 
		int width = getWidth();
		int height = getHeight();
		int largeur = width / grille.getAbcisseMax();
		int hauteur = height / grille.getOrdonneeMax();
                                // la y'a un truc bizarre : les abscisses c'est en x, et les ordonnées en y d'habitudes, mais bon je touche pas, peut être que c'est inversé dans grille.
		for(int i = 0 ; i < grille.getAbcisseMax();i++){
			for(int j = 0; j < grille.getOrdonneeMax(); j++){ // ici tu peux mettre j au lieu de ii, pour plus de lisibilité
				int x = j * largeur;
				int y = i * hauteur;
                               ModelTerrainJeu terrain = caseTerrains[i][j].getTerrain();
 
                                g.drawImage(terain.getImage(), x, y, largeur, hauteur, this); 
 
				}
			}
		}
	}
 
        // en ensuite vient l'aspect clic (on pourrait faire mieux, mais ça va te suffire)
        public void addImageClicker(final ImageClicker imageClicker) {
                // en encapsule le faux listener dans le vrai listener de souris (ici un MouseAdapter, une implémentation de MouseListener qui ne t'oblige pas à implémenter toutes ses méthodes (parce qu'elles le sont déjà)
		addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(MouseEvent e) {
                                // comme je l'ai dit, on calcule la hauteur et la largeur de la m^me manière qu'on la fait pour dessiner
				int width = getWidth();
				int height = getHeight();
				int largeur = width / grille.getAbcisseMax();
				int hauteur = height / grille.getOrdonneeMax();
                                // on détermine la colonne et la ligne dans la grille
				int colonne = e.getX()/largeur;
				int ligne = e.getY()/hauteur;
                                // on transmet les informations au faux listener, de manière à ce qu'on puisse réagir avec quand on l'utilise
				imageClicker.click(grille.getGrille()[colonne][ligne]);
				imageClicker.click(grille, colonne, ligne);
			}
		});
	}
 
public static abstract class ImageClicker {
 
		public ImageClicker() {
		}
 
                // tu n'est pas obligé de mettre les 2, la première peux suffire à tout faire
                // la seconde peut simplifier certains traitements qui ne concernent que la case seule
                // si tu ne mets qu'une seule méthode, au lieu d'une classe abstraite, ImageClicker peut être une interface
		public void click(GrilleJeu source, int colonne, int ligne) {
                }
		public void click(CaseTerrain caseTerrain) {
                }
 
 
	}

[LeMarseillais78]

Et maintenant si je veux faire la classe de test de tout sa j’instancie les images de ModelTerrainJeu?

[LeMarseillais78]

Aidez moi svp ..

[joel.drigo]

T'aider à quoi ?

[LeMarseillais78]

J ai repris ton code pour le faire sur mes classes à moi et j y suis arriver a sa :

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
 
 
public class CreationGrille extends JPanel {
 
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
	// ça je touche pas, je ne sais pas tout ce que tu cherches à faire, et tu
	// verras les erreurs dedans plus tard (j'en vois 2 au moins)
	GenerateurCarte generateurCarte = new GenerateurCarte();// mon generateur de
															// carte qui va me
															// permettre de
															// generer la carte
	JoueurHumain joueurHumain = new JoueurHumain("joueur1");
	JoueurHumain joueurHumain2 = new JoueurHumain("joueur2");
	ArrayList<ModelJoueur> joueurs = new ArrayList<ModelJoueur>();
	HashMap<TypesTerrains, Image> images = new HashMap<TypesTerrains,Image>();
	TypesTerrains grilleType[][] = new TypesTerrains[5][5];
	// je sais pas ou tu appelles initialisation, mais il pourrait être appelé
	// dans le constructeur
	public CreationGrille(GrilleJeu grilleJeu) {
		int xMax = grilleJeu.getAbcisseMax();
		int yMax = grilleJeu.getOrdonneeMax();
		images.put(TypesTerrains.MER, lireImage("images/bleu.jpg"));
		images.put(TypesTerrains.PLAINE,lireImage("images/vert.jpg"));
		grilleType = new TypesTerrains[xMax][yMax];
 
		for (int i = 0; i < xMax; i++) {
			for (int j = 0; j < yMax; j++) {
				grilleType[i][j] = grilleJeu.getGrille()[i][j].getTerrain().getTerrainsJeu();
			}
		}
	}
 
	public void initialisation(GrilleJeu grilleJeu) {
	}
 
	// jusque là j'ai pas touché
 
	// maintenant pour dessiner dans un panel, il faut au moins redéfinir paint
	// :
	public void paint(Graphics g,GrilleJeu grilleJeu) {
		super.paint(g);
		// et appeler le code qui dessiner ce qu'on veut...
		grilleGraphique(g, grilleJeu);
	}
 
	private Image lireImage(String string) {
 
		try {
 
			return ImageIO.read(new File(string));
 
		} catch (IOException e1) {
			e1.printStackTrace();
			return null;
		}
 
	}
 
	public void grilleGraphique(Graphics g, GrilleJeu grilleJeu) {
		CaseTerrain[][] caseTerrains = grilleJeu.getGrille();
 
		int width = getWidth();
		int height = getHeight();
		int largeur = width / grilleJeu.getAbcisseMax();
		int hauteur = height / grilleJeu.getOrdonneeMax();
 
		// la y'a un truc bizarre : les abscisses c'est en x, et les ordonnées
		// en y d'habitudes, mais bon je touche pas, peut être que c'est inversé
		// dans grille.
		for (int i = 0; i < grilleJeu.getAbcisseMax(); i++) {
			for (int j = 0; j < grilleJeu.getOrdonneeMax(); j++) {
				int x = j * largeur;
				int y = i * hauteur;
				//caseGraphique(g, caseTerrains, i, j, largeur, hauteur);
				g.drawImage(images.get(grilleType[i][j]), x,
						y, largeur, hauteur, this);
 
 
			}
		}
		g.setColor(Color.BLACK); // par exemple pour dessiner la grille en blanc
 
        for (int i = 0; i <= width; i += largeur) {  
            g.drawLine(i, 0, i, height);  
        } 
 
        for (int i = 0; i <= height; i+=hauteur) { 
           g.drawLine(0, i, width, i); 
        } 
	}
 
	/*private void caseGraphique(Graphics g, CaseTerrain[][] caseTerrains, int i,
			int j, int largeur, int hauteur) {
		int x = j * largeur;
		int y = i * hauteur;
 
 
		 * pour les images : aller dans la classe TypeGraphique et ajouter au
		 * case corespondant image = 'image coresponant au type';
 
		g.drawImage(images.get(grilleType[i][j]), x,
				y, largeur, hauteur, this);
	}*/
 
	// en ensuite vient l'aspect clic (on pourrait faire mieux, mais ça va te
	// suffire)
	public void addImageClicker(final ImageClicker imageClicker, final GrilleJeu grilleJeu) {
		// en encapsule le faux listener dans le vrai listener de souris (ici un
		// MouseAdapter, une implémentation de MouseListener qui ne t'oblige pas
		// à implémenter toutes ses méthodes (parce qu'elles le sont déjà)
		addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(MouseEvent e) {
				// comme je l'ai dit, on calcule la hauteur et la largeur de la
				// m^me manière qu'on la fait pour dessiner
				int width = getWidth();
				int height = getHeight();
				int largeur = width / grilleJeu.getAbcisseMax();
				int hauteur = height / grilleJeu.getOrdonneeMax();
				// on détermine la colonne et la ligne dans la grille
				int colonne = e.getX() / largeur;
				int ligne = e.getY() / hauteur;
				// on transmet les informations au faux listener, de manière à
				// ce qu'on puisse réagir avec quand on l'utilise
				imageClicker.click(grilleJeu.getGrille()[colonne][ligne]);
				imageClicker.click(grilleJeu, colonne, ligne);
			}
		});
	}
 
	public static abstract class ImageClicker {
 
		public ImageClicker() {
		}
 
		// tu n'est pas obligé de mettre les 2, la première peux suffire à tout
		// faire
		// la seconde peut simplifier certains traitements qui ne concernent que
		// la case seule
		// si tu ne mets qu'une seule méthode, au lieu d'une classe abstraite,
		// ImageClicker peut être une interface
		public void click(GrilleJeu source, int colonne, int ligne) {
		}
 
		public void click(CaseTerrain caseTerrain) {
		}
 
	}
}

Mais mon JFrame n affiche rien...

[joel.drigo]

Si tu comptes sur cette méthode

Code :

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

1
2
3
4
5
public void paint(Graphics g,GrilleJeu grilleJeu) {
		super.paint(g);
		// et appeler le code qui dessiner ce qu'on veut...
		grilleGraphique(g, grilleJeu);
	}

pour que le panel se dessine, ça ne risque pas de fonctionner. D'autant plus que l'instance de GrilleJeu est bien passée en argument du constructeur, mais pas mémorisée dans une variable de la classe !

Lorsqu'on redéfinit une méthode, à fortiori une méthode appelée par un autre "programme" que le tiens (ici SWING), on n'ajoute pas des paramètres dans la signature (on en enlève pas non plus d'ailleurs), sinon on ne redéfinit pas : on créé une nouvelle méthode qui n'est appelée que si tu l'appelles explicitement quelque part dans ton code.

Dans l'exemple sur lequel on a travaillé, l'instance de GrilleJeu était référencée par une variable interne (grille) de la classe CreationGrille et donc la redéfinition de la méthode paint(Graphics g) de JPanel était bien :

Code :

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

1
2
3
4
5
public void paint(Graphics g) {
		super.paint(g);
		// et appeler le code qui dessiner ce qu'on veut...
		grilleGraphique(g, grille); 
	}

Parce que le principe, dans SWING, et que le dessin du composant est fait par l'appel de la méthode paint(Graphics g) par l'EDT (le thread de SWING) directement ou indirectement, certes, mais certainement pas par l'appel d'une méthode que tu créés toi même avec les paramètres que tu veux, sauf si cette méthode est elle-même appelée par paint(Graphics g), directement ou indirectement (je veux dire que paint(Graphics) peut appeler une méthode intermédiaire qui appelle ta méthode...).

Donc tu n'as qu'a remettre cette variable grille dans la classe, lui donner la valeur de l'argument grilleJeu que tu passes en argument du constructeur, et rédéfinir paint(Graphics) comme ci-dessus.

Pourquoi ajouter systématiquement un argument de type GrilleJeu dans des méthodes public de ta classe ? Ta classe doit maintenir une variable de type GrilleJeu, et les méthodes qui en ont besoin l'utilise (je parle de addimageClicker(...) 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
public class CreationGrille extends JPanel {
 
    private GrilleJeu grilleJeu; // cette variable permet au panel de connaitre la GrilleJeu, de la dessiner, de s'interfacer avec, de la manipuler, etc.
 
    ...
 
    public CreationGrille(GrillJeux grille) {
              grilleJeu=grille; // on passe la grille en paramètre (c'est une solution parmi d'autres) et on l'affecte à la variable de classe, ce qui permet d'avoir une référence dessus pour en faire ce qu'on a besoin
    }
 
    public void paint(Graphics g) {
          super.paint(g); 
		grilleGraphique(g);
    }
 
     /*public : le panel se dessine de lui même : pas besoin donc de pouvoir appeler cette méthode de l'extérieur */ private void grilleGraphique(Graphics g/* inutile la classe connait la grille qu'elle affiche, GrilleJeu grilleJeu*/) {
 
             CaseTerrain[][] caseTerrains = grilleJeu.getGrille();
 
              ...
 
 
      }
 
 
       public void addImageClicker(final ImageClicker imageClicker/* inutile (même raison que citée ci-dessus), final GrilleJeu grilleJeu*/) {
 
                ...
 
       }
 
 
 }

PS : les commentaires que je mets dans le code, c'est pour te donner des précisions. Ils ont 2 vocations : la première est d'être lus. La seconde est d'être enlevés immédiatement après avoir été lu, ou au moins dans le code que tu repostes, en particulier si tu le modifies.

[LeMarseillais78]

Voila maintenant sa m'affiche la grille mais pas les images..
Excuse moi pour les commentaires

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
 
 
public class CreationGrille extends JPanel {
 
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
 
 
	GenerateurCarte generateurCarte = new GenerateurCarte();
	JoueurHumain joueurHumain = new JoueurHumain("joueur1");
	JoueurHumain joueurHumain2 = new JoueurHumain("joueur2");
	ArrayList<ModelJoueur> joueurs = new ArrayList<ModelJoueur>();
	HashMap<TypesTerrains, Image> images = new HashMap<TypesTerrains,Image>();
	TypesTerrains grilleType[][] = new TypesTerrains[5][5];
	GrilleJeu grille = new GrilleJeu();
 
	public CreationGrille(GrilleJeu grilleJeu) {
		grilleJeu = grille;
		int xMax = grilleJeu.getAbcisseMax();
		int yMax = grilleJeu.getOrdonneeMax();
		images.put(TypesTerrains.MER, lireImage("images/bleu.jpg"));
		images.put(TypesTerrains.PLAINE,lireImage("images/vert.jpg"));
		grilleType = new TypesTerrains[xMax][yMax];
 
		for (int i = 0; i < xMax; i++) {
			for (int j = 0; j < yMax; j++) {
				grilleType[i][j] = grilleJeu.getGrille()[i][j].getTerrain().getTerrainsJeu();
			}
		}
	}
 
	public void initialisation(GrilleJeu grilleJeu) {
	}
 
 
	public void paint(Graphics g) {
		super.paint(g);
		grilleGraphique(g);
	}
 
	private Image lireImage(String string) {
 
		try {
 
			return ImageIO.read(new File(string));
 
		} catch (IOException e1) {
			e1.printStackTrace();
			return null;
		}
 
	}
 
	public void grilleGraphique(Graphics g) {
		CaseTerrain[][] caseTerrains = grille.getGrille();
 
		int width = getWidth();
		int height = getHeight();
		int largeur = width / grille.getAbcisseMax();
		int hauteur = height / grille.getOrdonneeMax();
 
 
		for (int i = 0; i < grille.getAbcisseMax(); i++) {
			for (int j = 0; j < grille.getOrdonneeMax(); j++) {
				int x = j * largeur;
				int y = i * hauteur;
				//caseGraphique(g, caseTerrains, i, j, largeur, hauteur);
				g.drawImage(images.get(grilleType[i][j]), x,
						y, largeur, hauteur, this);
 
 
			}
		}
		g.setColor(Color.BLACK); 
 
        for (int i = 0; i <= width; i += largeur) {  
            g.drawLine(i, 0, i, height);  
        } 
 
        for (int i = 0; i <= height; i+=hauteur) { 
           g.drawLine(0, i, width, i); 
        } 
	}
 
	/*private void caseGraphique(Graphics g, CaseTerrain[][] caseTerrains, int i,
			int j, int largeur, int hauteur) {
		int x = j * largeur;
		int y = i * hauteur;
 
 
		 * pour les images : aller dans la classe TypeGraphique et ajouter au
		 * case corespondant image = 'image coresponant au type';
 
		g.drawImage(images.get(grilleType[i][j]), x,
				y, largeur, hauteur, this);
	}*/
 
 
	public void addImageClicker(final ImageClicker imageClicker) {
 
		addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(MouseEvent e) {
 
				int width = getWidth();
				int height = getHeight();
				int largeur = width / grille.getAbcisseMax();
				int hauteur = height / grille.getOrdonneeMax();
 
				int colonne = e.getX() / largeur;
				int ligne = e.getY() / hauteur;
 
				imageClicker.click(grille.getGrille()[colonne][ligne]);
				imageClicker.click(grille, colonne, ligne);
			}
		});
	}
 
	public static abstract class ImageClicker {
 
		public ImageClicker() {
		}
 
 
		public void click(GrilleJeu source, int colonne, int ligne) {
		}
 
		public void click(CaseTerrain caseTerrain) {
		}
 
	}
}