Mettre des images aléatoirement dans une grille

Version imprimable

Voir 40 message(s) de cette discussion en une page

08/04/2014, 19h10
LeMarseillais78

Et je ne sais pas ou est mon soucis...

Je commencerais pas vérifier que les fichiers sont bien chargés, en ajoutant temporairement, par exemple, une trace (un System.out.println("Images : " + images) juste après ça :
Code:

1 2 images.put(TypesTerrains.MER, lireImage("images/bleu.jpg")); images.put(TypesTerrains.PLAINE,lireImage("images/vert.jpg"));
Ensuite, tu te compliques la vie en utilisant un tableau intermédiaire

Code:

TypesTerrains grilleType[][] = new TypesTerrains[5][5];

:

le tableau est une copie statique, donc tu te supprimes la possibilité qu'il change
ces dimensions sont statiques alors que la grille est censé avoir une taille décrite par des méthodes. modifie la taille de la grille et plus rien de marche
ça ajoute une variable supplémentaire, donc de la confusion supplémentaire
Pourquoi stocker les images dans une map, au lieu de faire comme j'avais dit (de le stocker dans les instances qui représentent le terrain) : disperser des données en rapport les unes avec les autres ne sert qu'à compliquer le programme, ajouter de la confusion, et rendre difficile la compréhension, en particulier, quand ça ne fonctionne pas

Ensuite, quand quelque chose ne fonctionne pas, on commence par analyser le code, ajouter des traces ou passer en mode debug, pour voir si on passe dans les méthodes qui sont censées être appelées. Ensuite on cherche pourquoi elles ne sont pas appelées, ou pourquoi malgré le fait qu'elles le soient, elle ne donne pas le résultat escompté (donc, pour ça, on regarde les valeurs des variables qui sont utilisées), par la même méthode (trace et debug).

Regardes bien ce que tu as fait suite à mes dernières indications, et compares le à ce que j'ai écrit. Ça devrait te sauter aux yeux.

Ce que tu as écrit :
Code:

1 2 3 4 5 6 7 8 public class CreationGrille extends JPanel { ... GrilleJeu grille = new GrilleJeu(); public CreationGrille(GrilleJeu grilleJeu) { grilleJeu = grille;
Ce que j'ai écrit :
Code:

1 2 3 4 5 6 7 8 9 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 }
Rappel : tous les caractères, leur casse, leur position, etc... ont leur importance, en java, comme dans la plupart des langages.

En fait j'ai mis le new sinon sa me fait un NPE...

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
 
 
public class GrilleJeu {
	private int abcisseMax;
	private int ordonneeMax;
	private CaseTerrain[][] grille;
	private ArrayList<CoordonneesTerrain> listeCoordonnes = new ArrayList<CoordonneesTerrain>();
	private HashMap<CoordonneesTerrain, TerrainJeu> listeTerrain = new HashMap<CoordonneesTerrain,TerrainJeu>();
 
	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, TerrainJeu> getListeTerrain() {
		return listeTerrain;
	}
 
	public int getAbcisseMax() {
		return abcisseMax;
	}
 
	public int getOrdonneeMax() {
		return ordonneeMax;
	}
 
	public CaseTerrain[][] getGrille() {
		return grille;
	}
 
	public void setTerrainAt(CoordonneesTerrain coordonneesTerrain, TerrainJeu 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;
	}
 
}

Classe TypeTerrain:

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
 
public enum TypesTerrains {
	NON_DEFINIE("non definie",-1,-1,0),MER("Mer",1,1,-1),PLAINE("",1,1,1)/*,FORET("",1,1.5 ,2),COLINE("",1.5,2,2),MONTAGNE("",2,2,3),JUNGLE("",0.5,2,2)*/;
	private String identifiant;
	private double bonusAttaque;
	private double bonusDefense;
	private int coutMouvement;
 
	private TypesTerrains(String identifiant ,double bonusAttaque , double bonusDefense, int coutMouvement) {
 
		this.identifiant = identifiant;
		this.bonusAttaque = bonusAttaque;
		this.bonusDefense = bonusDefense;
		this.coutMouvement = coutMouvement;
	}
 
	public double getBonusAttaque() {
		return bonusAttaque;
	}
 
	public double getBonusDefense() {
		return bonusDefense;
	}
 
	public int getCoutMouvement() {
		return coutMouvement;
	}
 
	public String getIdentifiant() {
		return identifiant;
	}
 
 
}

classe GenerateurCarte:

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
 
public class GenerateurCarte {
	public GrilleJeu genererCarte(int x, int y ,int taux, ArrayList<ModelJoueur>joueurHumain,ArrayList<ModelJoueur>joueurOrdinateur){
 
		GenerateurJoueur generateurJoueur = new GenerateurJoueur();
		OrganisateurJoueur organisateurJoueur = new OrganisateurJoueur();
		GrilleJeu grille = genererMonde(x, y, taux);
		grille = generateurJoueur.genererJoueur(grille, joueurHumain, joueurOrdinateur);
		organisateurJoueur.ordreJoueur(joueurHumain, joueurOrdinateur);
 
		return grille;
	}
 
	public GrilleJeu genererCarte(int x, int y ,int taux, ArrayList<ModelJoueur>joueurHumain){
		GenerateurJoueur generateurJoueur = new GenerateurJoueur();
		OrganisateurJoueur organisateurJoueur = new OrganisateurJoueur();
		GrilleJeu grilleJeu = genererMonde(x, y, taux); 
		grilleJeu = generateurJoueur.genererJoueur(grilleJeu, joueurHumain);
		organisateurJoueur.ordreJoueur(joueurHumain);
		return grilleJeu;
	}
 
	private GrilleJeu genererMonde(int x , int y, int taux){
		GenerateurGrille generateurGrille = new GenerateurGrille();
		GenerateurRessource generateurRessource = new GenerateurRessource();
		GrilleJeu grille = generateurGrille.genererAire(x, y,taux);
		grille = generateurRessource.genererRessource(grille);
		return grille;
	}
 
 
 
 
 
 
}

08/04/2014, 19h37
joel.drigo

Citation:

Envoyé par LeMarseillais78

En fait j'ai mis le new sinon sa me fait un NPE...

Oui, ça devait faire une NPE, mais pas parce qu'il manquait un new : quand je dis comparer, et que je mets plusieurs lignes de codes, c'est toutes les lignes qu'il faut comparer, pas que la première, ou la deuxième...
08/04/2014, 19h40
LeMarseillais78

Je ne comprends pas trop ce que tu veux dire...
Le System.out.println donne ca Images : {MER=BufferedImage@1a0b53e: type = 5 ColorModel: #pixelBits = 24 numComponents = 3 color space = java.awt.color.ICC_ColorSpace@1dafb4e transparency = 1 has alpha = false isAlphaPre = false ByteInterleavedRaster: width = 233 height = 216 #numDataElements 3 dataOff[0] = 2}

Ce que je veux dire c'est que grille et grilleJeu ce n'est pas la même chose !

Si j'écris (j'ai copié ce que j'ai mis 3 ou 4 posts plus haut, juste sans les commentaires) :
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 public class CreationGrille extends JPanel { private GrilleJeu grilleJeu; ... public CreationGrille(GrillJeux grille) { grilleJeu=grille; } public void paint(Graphics g) { super.paint(g); grilleGraphique(g); } private void grilleGraphique(Graphics g) { CaseTerrain[][] caseTerrains = grilleJeu.getGrille(); ... } public void addImageClicker(final ImageClicker imageClicker) { ... } }
et que pour reporter cette proposition tu écris :
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 public class CreationGrille extends JPanel { private GrilleJeu grille; ... public CreationGrille(GrilleJeux grilleJeu) { grilleJeu=grille; } public void paint(Graphics g) { super.paint(g); grilleGraphique(g); } private void grilleGraphique(Graphics g) { CaseTerrain[][] caseTerrains = grille.getGrille(); ... } public void addImageClicker(final ImageClicker imageClicker) { ... } }
C'est normal que ça fasse une NPE : dans le constructeur tu affectes grille ( qui est null, puisque c'est la variable de classe non initialisée) à grilleJeu, qui est l'argument de la méthode. donc ça ne fait rien : lorsque le constructeur a fini de s'éxécuter, grille contient toujours null. D'ou la NPE.

Si tu changes grilleJeu en grille et grille en grilleJeu, il faut le faire partout, sinon toutes les lignes de code ne vont plus être cohérentes.

Un exemple simple, enfin, je sais pas faire plus simple :
Code:

1 2 3 double a = 10; double b = 2; System.out.println( a / b );
ça affiche 5.0, on est d'accord ?
Si tu échanges a et b que dans les 2 premières lignes :
Code:

1 2 3 double b = 10; double a = 2; System.out.println( a / b );
ça affiche plus 5.0, mais 0.2. Pour que ça affiche le même résultat, il faut faire l'échange partout :
Code:

1 2 3 double b = 10; double a = 2; System.out.println( b / a );
Avec grille et grilleJeu, c'est pareil : dans mon exemple la variable de classe s'appelle grilleJeu et l'argument du constructeur grille (en fait je voulais pas mettre le même nom (grilleJeu) pour éviter d'ajouter de la confusion, j'aurais peut être dû finalement). Toi, tu as inversé grille et grilleJeu, sauf dans l'affectation dans le constructeur, si tu veux changer les noms des variables de mon exemple, fais-le de manière cohérente, et si ça ne fonctionne pas, vérifie que tout est cohérent avec de mettre un new ou autre n'importe où. Un new n'est pas le réflexe miracle qui résout les NPE : le réflexe pour résoudre les NPE est d'initialiser ses variables avec la bonne valeur.

08/04/2014, 20h16
LeMarseillais78

C'est bon j'ai compris merci.
La maintenant sa m'affiche une image mais en fond de la grille au lieu d'afficher les terrains case par case.

Je ne vois pas comment, si tu as toujours bien ce code (le dernier que tu as publié ici) :
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 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); } }
La seule chose qui n'est pas bonne et que je t'avais déjà signalée, c'est que j ce sont les ordonnées, donc les lignes, et que là (dans la partie en rouge) tu calcules x en fonction de j. Idem pour les y qui sont calculés en fonction des colonnes. Mais ça n'explique pas pourquoi on aurait qu'une seule image.

La seule explication que je vois, c'est que les images sont uniformes, et que toutes les cases sont du même type, donc toutes les images sont les mêmes, donc tu as l'impression d'avoir qu'une seule image. Et ceci peut être dû à quelque chose que je t'ai signalé par ailleurs : le fait que tu copies le contenu de grille dans un tableau local (grilleType) : si tu affectes des types de terrains après avoir créer le panel CreationGrille,, le tableau copie lui ne changera pas (un argument supplémentaire contre l'idée de faire une copie).

Si tu remplaces dans :
Code:

1 2 g.drawImage(images.get(grilleType[i][j]), x, y, largeur, hauteur, this);
le truc en rouge par le truc en bleu, comme ça :
Code:

1 2 g.drawImage(images.get(caseTerrains[i][j].getTerrain().getTerrainsJeu()), x, y, largeur, hauteur, this);
ça fonctionne pas mieux ?

Voila ce que j'ai maintenant et si merci sa fonctionne beaucoup mais beaucoup mieu.

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
 
 
 
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[4][4];
	private GrilleJeu grilleJeu;
 
	public CreationGrille(GrilleJeu grille) {
		grilleJeu = grille;
		int xMax = grilleJeu.getAbcisseMax();
		int yMax = grilleJeu.getOrdonneeMax();
		images.put(TypesTerrains.MER, lireImage("images/bleu.jpg"));
		System.out.println("Images : " + images);
		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] = grille.getGrille()[i][j].getTerrain().getTerrainsJeu();
			}
		}
	}
 
	public void initialisation(GrilleJeu grille) {
	}
 
 
	public void paintComponent(Graphics g) {
		super.paintComponent(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 = grilleJeu.getGrille();
 
		int width = getWidth();
		int height = getHeight();
		int largeur = width / grilleJeu.getAbcisseMax();
		int hauteur = height / grilleJeu.getOrdonneeMax();
 
 
		for (int i = 0; i < grilleJeu.getAbcisseMax(); i++) {
			for (int j = 0; j < grilleJeu.getOrdonneeMax(); j++) {
				int x = i* largeur;
				int y = j * hauteur;
				//caseGraphique(g, caseTerrains, i, j, largeur, hauteur);
				g.drawImage(images.get(caseTerrains[i][j].getTerrain().getTerrainsJeu()), 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 / grilleJeu.getAbcisseMax();
				int hauteur = height / grilleJeu.getOrdonneeMax();
 
				int colonne = e.getX() / largeur;
				int ligne = e.getY() / hauteur;
 
				imageClicker.click(grilleJeu.getGrille()[colonne][ligne]);
				imageClicker.click(grilleJeu, colonne, ligne);
			}
		});
	}
 
	public static abstract class ImageClicker {
 
		public ImageClicker() {
		}
 
 
		public void click(GrilleJeu source, int colonne, int ligne) {
		}
 
		public void click(CaseTerrain caseTerrain) {
		}
 
	}
}

Voir 40 message(s) de cette discussion en une page