Bonjour tout le monde,

Je suis entrain de construire un démineur, mais j'ai quelques erreurs. J'utilise Flash CS5.

mon projet contient 4 fichiers demineur.fla, Demineur.as, Tile.as et TimeFormat.as.

J'ai une première erreur - bogue\Demineur.as, ligne 1 1037 : Les packages ne peuvent pas être imbriqués.




Demineur.fla :
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
//ajout à la display list
addChild (game);
//Création d'une instance du jeu
//comme le jeu étends la classe Sprite, il est possible de le déplacement comme un clip normal
var game:Demineur = new Demineur(9,10,25,10);
//centre le jeu
game.x = (stage.stageWidth / 2) - game.width/2;
game.y = (stage.stageHeight / 2) - game.height/2;
 
 
//on utilise une propriété du jeu qui permet d'utiliser une bouton depuis la bibliothèque
game.button = new bouton();
 
//ajout de l'écouteur pour le temps qui avance
game.addEventListener (Demineur.TIME, updateTime);
 
//fonction qui est appelé lorqu'une seconde est passée
function updateTime (e:Event):void {
	txtTime.text = game.time;
}
//ajout de l'écouteur pour le jeu mis à jour
game.addEventListener (Demineur.UPDATED, updateInfos);
//fonction qui est appelée quand le jeu est mis à jour
function updateInfos (e:Event):void {
	//on utilise le propriété bombToFind pour savoir combien de bombe il reste à trouver
	//selon le nombre marquées
	txtFlag.text = "Il reste " +game.bombRemaining+ " bombe(s) à trouver.";
}
 
//ajout de l'écouteur pour la partie terminée
game.addEventListener (Demineur.GAME_OVER, gameOver);
 
//fonction qui est appelée quand la partie est terminée
function gameOver (e:Event):void {
	txtFlag.text = "Vous avez perdu !!!";
}
//ajout de l'écouteur pour la partie gagnée
game.addEventListener (Demineur.GAME_WIN, gameWin);
//fonction qui est appelée quand la partie est gagnée
function gameWin (e:Event):void {
	txtFlag.text = "Vous avez gagné !!!";
}
//démarre le jeu de démineur
game.start ();

Dans mon fichier .fla sur l'interface j'ai un chrono qui s'appel txtTime et txtFlag.

Tile.as :

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
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
package {
 
	import flash.display.BlendMode;
	import flash.text.*;
	import flash.events.*;
	import flash.filters.*;
	import flash.ui.ContextMenu;
	import flash.ui.ContextMenuItem;
	import flash.events.ContextMenuEvent;
	public class Tile extends Sprite {
		//Variable
		//Dimension
		private var size:Number;
		//Position
		public var X:Number; // représente le x cartésien
		public var Y:Number;	// représente le y cartésien
		//État
		public var checked:Boolean = false; // tuile vérifiée ou non
		//Texte
		public var bodyText:TextField; // on affiche le nombre de bombe dans ce cham texte, ou B (pour une bombe)
		//couelur possible selon le nombre de bombes aux alentous
		private var colorArray:Array = [0x000000,0x99C68E,0x4AA02C,0x437C17,0x254117,0xD44942,0xAF4035,0xFF0000];
		//Bombes
		private var bomb:Boolean = false; //si la tuile contient une bombe, cette variable sera vrai
		private var surroundingBombNumber:Number =0; // conteitn le nombre de bombes aux alentours
		//Flag
		private  var flagged:Boolean = false; //si la tuile est marquée, cette variable est vraie
		private var flag:Sprite; // objet marquer à afficher
 
		//Menu contextuel
		private var menuItemLabel:String = "Marquer cette bombe"; // temer qui sera affiché comme option dans le menu contextuel
		private var cm:ContextMenu; // un nouveau menu contextuel sur mesure
 
		//Events
		//Ces constantes seront utilisées de l'extérieur de la classe (dans la classe démineur et dans le fichier .fla)
 
		public static  const FLAG_ADDED:String = "flagadded"; // la tuile vient d'être marquée
		public static  const FLAG_REMOVED:String = "flagremoved"; //la marque vient dëtre enlevée
		public static  const CHECKED:String = "checked"; //la tuile vient d'être vérifiée
 
		/*Constructeur Tile
		@param pSize :  dimension en pixels d'une tuile (carrée)
		*/
		public function Tile (pSize:Number = 25):void {
			//affectation des paramètres aux variables internes
			size = pSize;
 
			//on défini les propriété pour la tuile
			buttonMode = true;
			//on rempli d'une couleur de fond avec encadré
			graphics.beginFill (0xCCCCCC);
			graphics.lineStyle (1,0x000000,1);
			graphics.moveTo (0,0);
			graphics.lineTo (size,0);
			graphics.lineTo (size,size);
			graphics.lineTo (0,size);
			graphics.lineTo (0,0);
			graphics.endFill ();
 
			/*Filtres qui ajoute une face (biseau)*/
			var bevelFilter:BevelFilter = new BevelFilter(3,45,0x000000,1,0xffffff,1,2,2, 0.2,BitmapFilterQuality.HIGH,BitmapFilterType.INNER,false);
			filters = [bevelFilter];
 
			/*Champs texte dans la tuile */
			bodyText = new TextField();
			bodyText.name = "BodyText";
			bodyText.mouseEnabled = false;
			bodyText.selectable = false;
			bodyText.width = size;
			bodyText.height = size;
			bodyText.y = 3;
 
			//permet de faire un alpha sans avoir a intégrer (embed) les caractères
			bodyText.blendMode = BlendMode.LAYER;
			//on cache le texte
			bodyText.alpha = 0;
 
			//Création du textFormat pour le champ texte de la tuile
			var bodyTextFormat:TextFormat = new TextFormat();
			bodyTextFormat.align = "center";
			bodyTextFormat.size = 13;
			bodyTextFormat.font = "arial";
			bodyTextFormat.bold = true;
			bodyTextFormat.color = colorArray[surroundingBombNumber];
			bodyText.defaultTextFormat = bodyTextFormat;
 
			//on ajoute le champs texte à la display list de la tuile
			addChild (bodyText);
 
			//Création du sprite représentant un flag
			flag = new Sprite();
			flag.name = "flag";
			flag.graphics.lineStyle (1,0x000000,0);
			flag.graphics.beginFill (0xFF0000);
			flag.graphics.drawCircle (0,0,5);
			//centre dans la tuile
			flag.x = width / 2;
			flag.y = height /2;
			//pas visible par défaut
			flag.visible = false;
			//on ajoute le flag à la display list de la tuile
			addChild (flag);
 
			//On désactive les enfant de la tuile (flag, champ texte)
			mouseChildren = false;
 
			//menu contextuel sur mesure
			cm = new ContextMenu();
			//cache les options par défaut
			cm.hideBuiltInItems ();
			//cette fonction ajoute une commande au menu
			addContextItem ();
			//on spécifie quel menu doit utiliser la tuile
			contextMenu = cm;
 
			//ajout d'un écouteur afin de permettre des action au clic sur la tuile
			addEventListener (MouseEvent.MOUSE_DOWN, checkTile);
 
		}
		//*************************************************//
		//Fonction privées//
		//*************************************************//
		//#####################################################
		//EVENTS ###############################################
		/* Fonction checkTile
			Cette fonction est appelée au clic sur la tuile
			Si la tuile est marquée, on ne fait rien
		*/
		private function checkTile ():void {
			if (!flagged) {
				//destruction de l'événemtn de clic
				removeEventListener (MouseEvent.MOUSE_DOWN, checkTile);
				if (bomb) {//si la tuile contient une bombe
					//déclenchement de l'événemnt GAME_OVER au jeu
					//de plus, on spécifie le bubbling a true
					//comme cela on peut aussi le récupérer dans le fichier .fla
					dispatchEvent (new Event(Demineur.GAME_OVER,true));
				} else if (surroundingBombNumber == 0) {
					//si la tuile est vide
					//on la marque comme vérifiée
					checked = true;
					//change l'apparence
					discover ();
					// on lance la fonction récursive
					checkCircTile ();
				} else {
					//sinon elle contient un chiffre
					//marque comme vérifiée
					checked = true;
					//change l'apparence
					discover ();
					//désactive la main au survol
					buttonMode = false;
					//détruit le menu contextuel
					flushContextItem ();
				}
			}
		}
		/* Fonction menuItemSelected
			Cette fonction est appelée lorsque l'option pour marquer les bombes (flag) est utilisée
			De plus, elle déclenche un événement qui sera récupéré par le jeu
		*/
		private function menuItemSelected (e:ContextMenuEvent):void {
			flagged = !flagged;
			if (flagged) {
				dispatchEvent (new Event(Tile.FLAG_ADDED));
			} else {
				dispatchEvent (new Event(Tile.FLAG_REMOVED));
			}
			//on ffiche ou non le marqueur, selon le cas
			flag.visible = flagged;
		}
		//#####################################################
 
 
		/* Fonction checkCircTile
			Cette fonction va vérifier les tuile qui entoure la tuile courante
			Elle va les découvrir et va lancer la fonction checkCircTile sur une tuile qui n'aurait pas de bombe aux alentours
			Attention, il est important de bien s'assurer de ne pas tomber dans une BOUCLE infinie
		*/
		private function checkCircTile () :void{
 
			//à partir de la tuile courante, on trouve les tuile haut , bas ,gauche ,droite
			var upTile:Tile  = Tile(parent.getChildByName("T_"+(Y-1)+"-"+X));
			var downTile:Tile  = Tile(parent.getChildByName("T_"+(Y+1)+"-"+X));
			var leftTile:Tile  = Tile(parent.getChildByName("T_"+Y+"-"+(X-1)));
			var rightTile:Tile  = Tile(parent.getChildByName("T_"+Y+"-"+(X+1)));
 
 
			//si la tuile en haut de la tuile courante est valide et n'a pas été vérifiée
			if (upTile != null && !upTile.bomb && !upTile.checked) {
				//on marque comme vérifiée
				upTile.checked = true;
				//on change l'apparence et affiche le contenu
				upTile.discover ();
				//si elle est vide, on lance la fonction récursive
				if (upTile.surroundingBombNumber == 0) {
					upTile.checkCircTile ();
				}
			}
			//si la tuile en haut de la tuile courante est valide et n'a pas été vérifiée
			if (downTile != null && !downTile.bomb && !downTile.checked) {
				//on marque comme vérifiée
				downTile.checked = true;
				//on change l'apparence et affiche le contenu
				downTile.discover ();
				//si elle est vide, on lance la fonction récursive
				if (downTile.surroundingBombNumber ==0) {
					downTile.checkCircTile ();
				}
			}
			//si la tuile en haut de la tuile courante est valide et n'a pas été vérifiée
			if (leftTile != null && !leftTile.bomb && !leftTile.checked ) {
				//on marque comme vérifiée
				leftTile.checked = true;
				//on change l'apparence et affiche le contenu
				leftTile.discover ();
				//si elle est vide, on lance la fonction récursive
				if (leftTile.surroundingBombNumber ==0) {
					leftTile.checkCircTile ();
				}
			}
			//si la tuile en haut de la tuile courante est valide et n'a pas été vérifiée
			if (rightTile != null && !rightTile.bomb && !rightTile.checked) {
				//on marque comme vérifiée
				rightTile.checked = true;
				//on change l'apparence et affiche le contenu
				rightTile.discover ();
				//si elle est vide, on lance la fonction récursive
				if (rightTile.surroundingBombNumber ==0) {
					rightTile.checkCircTile ();
				}
			}
		}
 
		/* Fonction discover
			Cette fonction va changer l'Apparence de la tuile sur laquelle on appuie
			En plus, elle déscative ses fonctionnalités
		*/
		private function discover ():void {
			//si un marqueur se retouve sur la tuile, on l'enlève
			if (flagged) {
				flagged = false;
				//envoi  un événement au jeu
				dispatchEvent (new Event(Tile.FLAG_REMOVED));
				//cache le marqueur
				flag.visible = false;
			}
			//changemenr d'apparence, fond blanc
			graphics.beginFill (0xFFFFFF);
			graphics.lineStyle (1,0x000000,1);
			graphics.moveTo (0,0);
			graphics.lineTo (size,0);
			graphics.lineTo (size,size);
			graphics.lineTo (0,size);
			graphics.lineTo (0,0);
			graphics.endFill ();
			//Change le filtre
			var bevelFilter:BevelFilter = new BevelFilter(0,0,0x000000,1,0xffffff,1,0,0,0,BitmapFilterQuality.HIGH,BitmapFilterType.INNER,false);
			filters = [bevelFilter];
			//si un chiffre doit être affiché
			//on affiche le champ texte
			if (surroundingBombNumber > 0) {
				bodyText.alpha = 1;
			}
			//enlève le curseur de main au survol
			buttonMode = false;
			//destrcution de l'écouteur
			removeEventListener (MouseEvent.MOUSE_DOWN, checkTile);
			//on envoi un événement au jeu comme quoi cette tuile vient d'être vérifiée
			dispatchEvent (new Event(Tile.CHECKED));
			//on détruit le menu contextuel
			flushContextItem ();
		}
		//*************************************************//
		//getter & setter//
		//*************************************************//
		/*Fonction get isFlagged
			Permet de savoir si la tuile est marquée ou non
			Retour : String
		*/
		public function get isFlagged ():Boolean{
			return flagged;
		}
		/*Fonction get isBomb
			Permet de savoir si la tuile une bombe ou non
			Retour : String
		*/
		public function get isBomb ():Boolean{
			return bomb;
		}
		/*Fonction set isBomb
			Permet de définir si la tuile est une bombe ou non
			Retour : String
		*/
		public function set isBomb (b:Boolean):void{
			bomb = b;
		}
		//*************************************************//
		//Fonction publiques//
		//*************************************************//
		/* Fonction addBombNum
			Cette fonction est appelée  par le jeu pour ajouter 1 au nombre de bombes entourant la tuile
		*/
		public function addBombNum () {
 
			surroundingBombNumber++;
			//met à jour le nombre de bombe trouvées
			bodyText.text = String(surroundingBombNumber);
 
			var bodyTextFormat:TextFormat = new TextFormat();
			bodyTextFormat.align = "center";
			bodyTextFormat.size = 13;
			bodyTextFormat.font = "arial";
			//selon le nombre, la couleur du texte change
			bodyTextFormat.color = colorArray[surroundingBombNumber];
			//affecte le champ texte du nouveau format
			bodyText.defaultTextFormat = bodyTextFormat;
 
		}
		/* Fonction deactivate
			Cette fonction est appelée par le jeu pour désactiver la tuile une fois la partie terminée, victoire ou défaite
		*/
		public function deactivate():void{
			//si la tuile contient une bombe
			if (bomb) {
				//on affiche la bombe
				bodyText.alpha = 1;
				//on cache le flag
				flag.visible = false;
			}
			//enlève la main au survol de la tuile
			buttonMode = false;
			//destruction de l'écouteur
			removeEventListener (MouseEvent.MOUSE_DOWN, checkTile);
			//appel de la fonction qui va enlever l'option du flag pour le menu contextuel de la tuile
			flushContextItem();
		}
		/* Fonction flushContextItem
			Cette fonction est appelée pour désactiver l'option de marquer la tuile avec le menu contextuel
		*/
		public function flushContextItem ():void {
			cm.customItems = [];
		}
		/* Fonction addContextItem
			Cette fonction est appelée pour ajouter l'option de maruqer une tuile dans menu contextuel
		*/
		public function addContextItem ():void {
			var cmi:ContextMenuItem = new ContextMenuItem(menuItemLabel);
			cmi.addEventListener (ContextMenuEvent.MENU_ITEM_SELECT, menuItemSelected);
			cm.customItems.push (cmi);
		}
	}
}

TimeFormat :

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
package com.utils{
	public class TimeFormat {
		//Variable permettant d'afficher (ou non)
		//un ou des zéros devant les chiffres
		public var leadingZero:Boolean = true;
 
		//Variables regExp et String du format demandé
		private var pattern:RegExp;
		private var formatString:String;
 
		//Variables String des différentes parties (heures, secondes, etc.)
		private var tStr:String;
		private var secStr:String;
		private var minStr:String;
		private var hourStr:String;
 
		/* Constructeur ***************************************************/
		// @param = format:String
		// String représentant le format à afficher (Ex: h:m:s, m-s-i, etc.)
		// h = heures, m = minutres, s = secondes, i = millisecondes
		public function TimeFormat(format:String) {
			formatString = format;
			pattern = /([a-z]{1,2})+/g;
		}
		/* Fonction qui affiche le temps selon le format demandé **********/
		// @param = t:Number
		// Number représentant le temps à formatter
		// @param = type:String
		// Représente le type de donnée temporelle (i = millisecondes, s = secondes)
		public function render(t:Number, type:String = 'i'):String {
			var sec:Number = 0;
			//est ce qu'on formatte , secondes (s) ou millisecondes (i) ?
			switch (type) {
				case 'i' :
					sec = Math.floor(t/1000);
					break;
				case 's' :
					sec = Math.floor(t);
					break;
			}
			//définition des minutes et heures
			var min:Number = Math.floor(sec/60);
			var hour:Number = Math.floor(min/60);
 
			var secRegEx:RegExp = /s/;
			var minRegEx:RegExp = /m/;
			var hourRegEx:RegExp = /h/;
 
			//Si on détecte des secondes, les millisecondes ne dépasseront pas 999
			//Si on détecte des minutes, les secondes ne dépasseront pas 59
			//Si on détecte des heures, les minutes ne dépasseront pas 59
			if (secRegEx.exec(formatString)) {
				t = t % 1000;
			}
			if (minRegEx.test(formatString)) {
				sec = sec % 60;
			}
			if (hourRegEx.test(formatString)) {
				min = min % 60;
			}
			//Affiche, le cas échéant, un ou des zéros devant les nombres
			tStr = (t < 100 && t > 9 && leadingZero)? "0" + t : String(t);
			tStr = (t < 10 && leadingZero)? "00" + t : String(tStr);
			secStr = (sec < 10 && leadingZero) ? "0" + sec : String(sec);
			minStr = (min < 10 && leadingZero) ? "0" + min : String(min);
			hourStr = (hour < 10 && leadingZero) ? "0" + hour : String(hour);
 
			//retourne le temps en chageant les sigles (h,m,s,i) par leur valeur respective
			return formatString.replace(pattern,detectFormat);
 
		}
		/* Fonction qui retourne la valeur correspondat à l'élément demandé **********/
		// @param = matchedSubstring:String
		// La partie correspondante de la chaîne.
		// @param = capturedMatch:String
		// Tout groupe entre parenthèses capturé correspondant est spécifié en tant qu’arguments suivants.
		// Le nombre d’arguments transmis de cette façon varie selon le nombre de correspondances entre parenthèses.
		// Pour déterminer le nombre de correspondances entre parenthèses, vérifiez arguments.length - 3 dans le code de la fonction.
		// @param = index:int
		// La position d’index dans la chaîne où débute la correspondance. 
		// @param = completeString:String
		// La chaîne complète. 
		private function detectFormat(matchedSubstring:String,capturedMatch:String,index:int,completeString:String) {
			switch (capturedMatch) {
				case "h" :
					return hourStr;
					break;
				case "m" :
					return minStr;
					break;
				case "s" :
					return secStr;
					break;
				case "i" :
					return tStr;
					break;
			}
		}
	}
}

Merci