Étape 8 : Récupérer les informations XML

le 6 septembre 2011 • Flash • par Dawlin

Parce que c'est bien joli, on a fait une map qui pouvait s'utiliser si elle était en Array, maintenant un éditeur qui la fabrique en XML, à quoi ça sert ?.

Eh bien c'est plus facile de modifier le premier code pour qu'il lise le XML plutôt que de le créer directement

Avant de commencer, assurons-nous d'avoir tout bien préparé : vous avez bien généré une map grâce à votre éditeur fraîchement codé, et en avez fait un fichier nommé "map.xml" déposé dans le même dossier que le jeu

Lecture du XML

Pour commencer, on va charger le XML, allons dans jeu.fla

Le code pour l'instant commence comme ceci :


#include "Scripts/constantes.as"
#include "Scripts/interrupteurs.as"
#include "Scripts/map.as"
#include "Scripts/mechantsMobiles.as"
#include "Scripts/missiles.as"
#include "Scripts/apparaitre.as"

...

Et ensuite il y a le code pour le déplacement.

Ce qu'on veut maintenant c'est que tout ça ne se lance que si on a fini de charger "map.xml".

Donc au début on va mettre :


var leXML:XML = new XML();
leXML.ignoreWhite = true;
leXML.onLoad = function(success) {

(pour plus d'informations sur les XML, se référer au tuto qui en parle, et à celui-làaussi)

Et à la toute fin du code, ceci :


};
leXML.load("map.xml");

Cela va avoir pour effets de charger map.xml, de le stocker dans la variable "leXML", puis de lancer le jeu

Mais ! Puisque la boucle onEnterFrame se retrouve dans le XML, il va falloire remplacer

this.onEnterFrame = function(){

par

_root.onEnterFrame = function(){

Récupérer la map

Au secours, au secours ! Notre map est détenue dans le XML ! (oui au bout de 8h sur le même tutoriel je craque un peu ), on va donc pouvoir ouvrir map.as et s'occupper de découper parcimonieusement la map pour en refaire une array.

Euh ... Pourquoi on l'a pas laissée en Array ? o_O

Tout simplement parce que charger un fichier XML c'est simple, et que ça nous permettra à terme de gérer plusieurs fichiers comme "niveau1.xml", "niveau2.xml"... Pour avoir un jeu entier composé de plusieurs maps !

Ok, dans map.as, vous avez le code de la map, qui ressemble à ça :


var myMap:Array = [[3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3],
				   [3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,3],
				   [3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,3,3],
				   [3,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3],
				   [3,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3],
				   [3,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3],
				   [3,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3],
				   [3,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,3],
				   [3,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,3],
				   [3,0,0,0,1,0,0,0,0,3,3,3,3,3,3,3,3,3,3,3],
				   [3,0,0,0,1,0,0,0,0,3,2,2,2,2,2,2,2,2,2,3],
				   [3,0,0,0,1,0,0,0,0,3,2,2,2,2,2,2,2,2,2,3],
				   [3,0,0,0,20,0,0,0,0,3,2,2,2,2,2,2,2,2,2,3],
				   [3,0,0,0,0,0,0,0,0,3,2,2,2,2,2,2,2,2,2,3],
				   [3,0,0,0,0,0,0,0,0,3,2,2,2,2,2,2,2,2,2,3],
				   [3,0,0,0,0,0,0,0,0,3,2,2,2,2,2,2,2,2,2,3],
				   [3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3]];

C'est ici que la map est définie. Nous on veut la définir par une autre méthode (leXML), donc vous pouvez virer ça. Oui, le virer !... Bon ok, laissez-le en commentaire si vous préférez !

Vous vous souvenez quand on a écrit le XML ? On a fait une double boucle ! et bien on va faire la même chose, mais à l'envers pour le lire !

Note : si vous galérez avec l'histoire des firstChild, childNodes etc, relisez les tutos sur le XML


//On définit la map :
var myMap:Array = new Array();
//Puis on lance la lecture du XML
for(i=0;i<leXML.firstChild.firstChild.childNodes.length;i++){
	//On crée une array spéciale pour la ligne, elle est provisoire
	var arrProvisoire:Array = new Array();
	for(j=0;j<leXML.firstChild.firstChild.childNodes[i].childNodes.length;j++){
		//On applique la valeur de la case du XML dans l'array provisoire
		arrProvisoire[j] = leXML.firstChild.firstChild.childNodes[i].childNodes[j].firstChild.nodeValue;
		//trace(arrProvisoire[j]);
	}
	//Puis, à chaque ligne on rajoute cette array dans myMap
	myMap[i] = arrProvisoire;
}

Et voilà, notre map se charge et s'affiche ! Elle est pas belle la vie ?

Les interrupteurs

Bon, maintenant il faut récupérer les paramètres des interrupteurs. Allons voir dans interrupteurs.as

Trouvez le code suivant :


var interruptArray:Array = new Array();
// Sur notre map nous n'avons que l"interrupteur 20, on aura donc
// Le premier 0 signifiant le type d'interrupteur (pour l'instant il n'y en a qu'un)
interruptArray[20] = [0,9,14,1];

Virez-le. Oui. Encore.

Nous allons maintenant recréer interruptArray grâce au XML :


var interruptArray:Array = new Array();

//La liste des interrupteurs se trouve sur leXML.firstChild.childNodes[1].childNodes, donc
for(n=0;n<leXML.firstChild.childNodes[1].childNodes.length;n++){
	//on récupère les informations
	numero = leXML.firstChild.childNodes[1].childNodes[n].childNodes[0].firstChild.nodeValue;
	type = leXML.firstChild.childNodes[1].childNodes[n].childNodes[1].firstChild.nodeValue;
	cX = leXML.firstChild.childNodes[1].childNodes[n].childNodes[2].firstChild.nodeValue;
	cY = leXML.firstChild.childNodes[1].childNodes[n].childNodes[3].firstChild.nodeValue;
	rt = leXML.firstChild.childNodes[1].childNodes[n].childNodes[4].firstChild.nodeValue;
	
	//puis on les applique en créant une nouvelle entrée
	interruptArray[numero] = [type,cY,cX,rt];
}

Et voilà, nos interrupteurs sont fonctionnels !

Récupérer le nombre de méchants

Ouvrons le fichier de constantes "constantes.as"

Trouvez la ligne :

nombreMechants = 2;

remplacez la par

nombreMechants = leXML.firstChild.childNodes[2].firstChild.nodeValue;

Comme vous l'aurez compris ça charge la valeur depuis le XML

Notre jeu est maintenant entièrement paramétré par notre XML ! ça c'est super ! Je vous l'avais bien dit que c'était plus facile une fois tout programmé !

Voilà les sources de tous les codes jusqu'ici (comprenant un chouette exemple de map )

Allez, il est temps de conclure

Étape 9 : Conclusions, Améliorations, ... »