NyrOS

icones.xml

Ce fichier XML est le premier fichier lu par l'application. Il permet de définir le nom de l'animation, l'image utilisé, le nom du fichier swf et la taille de l'animation swf. Il ressemble à cela :

Bureau.as

C'est la classe principale de l'application, car toutes les autres dépendent d'elle, mis à part menu (mais cette dernière effectue des actions sur le bureau)

Dans cette classe, on a besoin des classe 'Delegate' et 'Alert' fourni avec Flash. La 1ère est utilisé pour faire passer des événements (onLoad, onRelease etc...) comme s'ils étaients exécutés au sein même de l'objet en cours, et non sur la scène; ceci est utile pour pouvoir notamment garder un accès sur les variables privées de la classe et l'accès aux fonctions de cette classe. la 2nde sert à afficher des alertes, composant de Flash

On crée ici véritablement notre classe, et on y déclare toutes les variables utilisé dedans. 'scene' est la référence à l'endroit où est appelé notre classe (élément passé en paramètre au constructeur de la classe), 'monShare' est mon ShareObject contenant les préférences enregistré de l'utilisateur, 'buro' est la référence au clip qui contient tous les éléments de notre application, 'fondCl' est le clip utilisé pour le filtre coloré du fond d'écran, 'fondImg' est le clip dans lequel on charge l'image du fond d'écran, 'param' est l'objet qui contient les préférences actuelles de l'utilisateur, 'mesIcones' est l'objet XML qui chargera le fichier icones.xml précédement documenté, 'img' est une chaîne de caratères utilisé pour ne pas rechargé l'image de fond s'il s'agit de celle en cours, 'FENETREPROF' est utilisé par la classe Icone pour savoir sur quelle profondeur crée une nouvelle fenêtre, 'ESPACEICONE' est un paramètre utilisé pour la création des icones qui correpont à l'espace entre 2 icones, 'TAILLEICONE' est aussi un paramètre qui indique la taille de l'icone et 'NOMBRECOL' indique le nombre d'icone maximum par colone.

Il s'agit ici du constructeur (en effet, il a le même nom que la classe et est 'public'). On commence par attribuer des valeurs à un maximum de variable, à savoir scene (variable passé en paramètre à notre constructeur), monShare que l'on initialise sur le nom de cookie à "nyros", l'objet des paramètres 'param' : si des paramètres existent dans le shareObject "nyros" alors on les réaplique, sinon, on applique des valeurs par défaut. On applique ici les 4 seuls paramètres que l'on peut changer dans l'application, c'est à dire la couleur du filtre coloré, son alpha, l'image de fond et la différence de date. Le paramètrage de ses éléments se fait dans paramBureau et paramDate vu plus bas.
S'il s'agit de la première visite de l'utilisateur (si le shareObject a la valeur dejavu non défini) alors on affiche une alerte, grace au composant précompilé de Flash pour lui indiqué comment il doit/peut utiliser l'application. On défini aussi la la variable dejavu du shareObject pour qu'il n'est plus cette alert les prochianes fois et on écrit tout de suite notre cookie (flush).
Ensuite, on crée nos éléments graphique : on commence par créer notre clip vide bureau qui contiendra tout le reste. on défini la variable buro après sa création avec 'eval' pour ensuite le positionner tout en haut à gauche. Ensuite, on crée dans 'buro' le clip vide pour contenir l'image de fond. Ensuite, on dessine et charge l'image de fond suivant l'objet 'param' dans la fonction changefond() que l'on appelle ici. Cette fonction est aussi utilisé lors du changement par l'utilisateur des paramètres d'affichage.
Pour finir, on charge le fichier xml des icones dans mesIcones. On dit ici que l'onLoad de cet objet est en fait la fonction chargementIcones de notre objet, via Delegate.create();
Enfin, on crée notre objet 'Sound' 'sonClic', on charge le mp3 que l'on veut, on définit le son au maximum et on donne la référence au son à la variable 'sonClic' public static de la classe 'Icone'.

Cette fonction commence par appliquer la couleur de l'objet 'param' au themeColor global de l'application pour avoir toujours la même couleur dans les composants de toutes les animations. Puis la fonction crée dans 'buro' un clip vide qui contient le filtre coloré et ensuite, remplis ce clip avec la couleur et l'alpha qui sont actutellement dans l'objet 'param'. Ensuite, si l'image actuelle est différente de celle de l'objet 'param', alors on lance un loadMovie pour la changer, et on change notre variable 'img' pour pouvoir faire notre test la prochaine fois correctement.

Cette fonction (appelé lors de l'onLoad du XML des icones grace à Delegate.create()) vérifie d'abord si le fichier xml est bien chargé puis si c'est le cas, crée autant de clip qu'il y a d'élément dans le xml. Elle les crée dans le 'buro', en les nommant 'icone'+N, N commençant à 0. Quand les clips sont créés, on initialise l'icone en appelant la fonction 'init' de la classe Icone, en donnant en paramètre le nom, l'adresse de l'image, l'adresse du swf, la hauteur et la taille de l'animation. C'est véritablement cette fonction 'init' qui se charge de l'affichage des icones.
Dasn cette fonction, on fait bien attention à ne pas dépasser le nombre maximal d'icone par colonne, grace au test sur le modulo de i par rapport au nombre d'icone maxi par colonne.
Enfin on affecte la profondeur 'FENETREPROF' de début pour les fenêtres.

Les 3 dernière fonctions sont 'public' car elles sont appelés par d'autres animations swf de l'appli.

Fonction appelé lors d'un changement de paramètre actuel : on passe en paramètres tous les nouvelles propriétés, on les applique à notre objet 'param', puis on appelle la fonction 'changeFond' qui redessine correctement le fond d'écran.

Fonction appelé lors du changement des préférences de date de l'application, on donne en paramètres juste le décalage du temps par rapport à la date réelle et on enregistre dans notre objet 'param'.

Fonction qui applique au shareObject les paramètres actuels contenu dans 'param' et qui écrit le shareObject tout de suite.

Icone.as

Cette classe est appliquée au clip 'icone' de l'animation NyrOS.fla; elle est utilisée pour afficher l'icone et créer les actions au survol de la souris et au clic.

Comme pour la classe précédente, on a besoin de la classe 'Delegate' de Flash, donc on l'iporte avec la création de la classe.Ce phénomène ne sera plus expliqué pour les prochaines classes et importations suivantes.

On crée la classe 'Icone'. On l'a fait héritée de la classe MovieClip car on aura besoin de modifier son scale, son alpha son onRollOver, son onRollOut et son onRelease pour créer les différentes actions sur l'icone.
On définit aussi les variables de l'objet : 'iconeI' pour chargé l'image de l'icone, 'nom_txt' pour afficher le texte de l'icone, 'fenetreact' pour charger l'animation lors du clic et 'monMCL' pour faire le MovieClipLoader lors du clic.
Les variables static sont utilisé pour définir les paramètres fixes des icones et des fenêtres de l'application, que l'on utilisera lors du clic sur l'icone : 'ALPHA' définit l'aplpha de l'icone quand elle est inactive, 'SCALE' définit la proportion de l'icone quand elle est inactive, 'HAUTBAR' définit la hauteur de la barre des fenêtres.
Enfin, on a la variable public static 'sonClic' qui est la référence au son que l'on jouera lors du clic sur une icone, qui est définit par la classe 'Bureau'.

Cette fonction est en fait la fonction constructeur de la classe, appelée par Bureau.as lorsqu'il trouve une nouvelle icone dans le fichier xml.
Elle crée ici la clip pour charger l'image et la charge, affiche le texte de l'icone en lui appliquant un format de texte, définit les actions sur le bouton qui permetront de faire l'animation lors du survol (onRollOver) et de remettre les propriétés lorsque la souris s'en va (onRollOut).
On crée aussi l'action lors du clic sur l'icone qui applera la fonction creerFenetre de cette même classe, vu juste après, en passant en paramètres les mêmes que ceux passés à la classe 'init' qui définissent, dans l'ordre, le nom de l'animation, l'adresse de l'icone, l'adresse du swf, la hauteur de l'animation et la largeur de l'animation.
Ensuite, on vérifie que le son est complètement chargé et, si c'est le cas, on le joue une fois.

Cette classe est appelée lors du clic sur l'icone. Elle permet de créer la fenêtre avec les paramètres qui lui sont passés, ceux décris juste avant, en récupérant la profondeur à laquelle il doit créer la fenêtre, en incrémentant la valeur de la classe 'Bureau'.
Elle commence par attacher le clip 'fenetre' de la bibliothèque de l'animation principale et attribue à 'fenetreact' l'adresse de ce clip dans l'animation et ajoute le bouton de la fenêtre dans la barre de l'application. Puis on centre la nouvelle fenêtre sur l'animation. Ensuite, on redimensionne les boutons fermer et cacher de la barre suivant la largeur de la fenêtre. Une fois la fenêtre crée, on appelle la fonction 'init' de la classe 'Fenetre', qui lui ai associé.
Enfin, on crée le MovieClipLoader, on lance le chargement de l'animation et on crée son ecouteur pour pouvoir enlever le clip loading une fois l'animation chargé. C'est ici qu'on utilise le 'Delegate.create' pour appler la fonction 'finiCharger'.

Cette fonction sert simplement à enlever le clip 'loading' une fois que l'animation est chargée.

Fenetre.as

Cette classe est appliquée au clip 'fenetre' de l'animation NyrOS.fla; elle est utilisée pour gérer les différentes action de la barre : la fermeture, le cachage et le déplacement.

On crée la classe 'Fenetre'. On l'a fait héritée de la classe MovieClip car on aura besoin de modifier son alpha lors du déplacement de la fenêtre et sa profondeur (depth) et aussi faire le déplacement.
On définit aussi les variable de l'objet : 'icone' qui est la référence à l'icone qui l'a créée, 'clip' qui est la référence au clip dans lequel on a chargé l'animation, 'barre_mc' qui est la référence à la barre de l'animation, 'fermer_btn' qui est la référence au bouton fermer de la fenêtre, 'cacher_btn' qui est la référence au bouton cacher de la fenêtre et la variable static 'ALPHA' qui définit l'alpha qu'on attribue à la fenêtre lors de son déplacement.

Cette fonction est en fait la fonction constructeur de la classe, applée par Icones.as lors du clic sur l'icone, juste après la création de la fenêtre.
On appelle la fonction 'dessus' de cette même classe pour mettre la fenêtre au 1er plan. Ensuite, on définit toutes les actions de notre barre : le 'onPress' pour commencer le déplacement, le 'onRelease' pour l'arrêter. On définit aussi les actions sur les 2 boutons de la barre pour fermer l'application et la cacher.
Toutes les actions sont des appels à des fonctions de la classe donc définies juste après, sauf le 'onRelease' de la barre, qui arrête le drag (stopDrag();) et remet l'alpha de l'animation à 100%.

Cette fonction sert à placer la fenêtre au 1er plan de l'application. On commence par récupérer la plus haute profondeur et la profondeur actuelle de la fenêtre. Si le niveau maximal actuel est strictement supérieur à celui actuel, alors on intervertit les 2 profondeur. Ainsi on obtient un vrai système qui, lorsqu'on clique sur une fenêtre, la mets au 1er plan.

Cette fonction appelée lorsqu'on presse sur la barre. Elle démarre simplement de drag, change l'alpha de la fenêtre et appelle la fonction 'dessus' pour remettre au 1er plan.

Cette fonction est appelée lorsqu'on clique sur le bouton fermer de la barre de la fenêtre. Avant de détruire le clip, on vérifie si une fonction 'detruire' n'est pas définie dans le clip et si c'est le cas, on l'appelle. Ceci sert à faire comme si dans notre animation on avait un destructeur (ca n'existe pas encore dans les classe Flash). J'ai été obligé de l'utiliser dans 2 animations, le sokoban et la vidéo; plus de détail le moment venu.
Ensuite, on enleve le bouton de la barre de l'application et on détruit notre clip charger en passant par le MovieClipLoader qui l'a chargé, et enfin, on détruit notre objet fenêtre.

Cette fonction sert juste à inverser le '_visible' du clip chargé, lorsqu'on clique sur le bouton cacher de la fenêtre.

Menu.as

Cette classe est appelée, au même titre que 'Bureau', directement sur NyrOs.fla. Elle sert à redéfinir le menu contextuel de l'application.

On crée la classe 'Menu' et son constructeur, qui prend en paramètre la référence à l'endroit où est appelé la classe.
Le constructeur crée un nouvel objet et y ajoute les 3 éléments du menu de l'application, qui appeleront les fonctions de cette même classe. Enfin, on applique véritablement le menu à la scene.

Cette fonction est appelé lors du clic sur 'Propriétés d'Affichage' du menu contextuel que l'on a défini dans le constructeur. Son effet et d'appler la fonction 'creerFenetre' de la 1ère icone du 'bureau' présent sur la scene. On lui passe en paramètres les mêmes que l'on aurait mis dans le fichier 'icones.xml'

Cette fonction est une jumelle de la précédente, sauf qu'elle sert lors du clic sur 'Propriétés de Date et Heure' du menu contextuel.

Cette fonction, appelée par le clic sur 'Enregistrer les propriétés' du menu contextuel, appele la fonction 'saveParam' de l'objet Bureau sur la scene.

Barre.as

Cette classe est appelée, au même titre que 'Bureau' et 'Menu', directement sur NyrOs.fla. Elle sert à afficher les boutons en bas de l'application.

On importe le classe 'Button' car on s'en sert au sein de la classe. Ensuite, on crée notre classe 'Barre', puis on crée nos variables : 'scene' qui est une référence à l'endroit où est appelé la classe, 'barre_mc' qui est le clip dans lequel on place nos boutons, 'mesBouts' est un tableau qui contiendra tous les boutons (nom et adresse du clip), 'HAUTEUR' qui est la configuration de la hauteur des boutons et 'LIMITELARG' qui est la configuration de la largeur maximale des boutons.
Ensuite, la fonction constructeur qui applique le paramètre passé à la variable 'scene'.

Cette fonction est appelée par la classe 'Icone' lors de la création d'une nouvelle fenêtre. Elle sert à ajouter dans le tabeau mesBouts un objet contenant le nom de la fenêtre et la référence au clip de la fenêtre. Puis, on appelle 'affBoutons' pour regénérer l'affichage de la barre.

Cette fonction est simple, on crée un clip vide 'barre_mc' que l'on place en bas de l'application. Puis on crée un objet pour initialiser les boutons : le x, y, la hauteur et la largeur seront tous identiques.
Ensuite, on fait une boucle sur notre tableau mesBouts et on crée nos boutons, en décalant à chaque fois le x de la largeur d'un bouton.
A noter aussi que l'on crée un ecouteur 'monEcouteur' qui écoute tous les click de tous les boutons et qui exécute la fonction 'clicBouton' de notre classe.

Cette classe est éxécuter lors d'un clic sur un bouton : elle inverse la propriété '_visible' de la fenêtre et si on la rend visible, on la remet au 1er plan en appelant la fonction 'dessus' de la classe 'Fenetre'

Cette fonction est appelée apr la classe 'Fenetre' lorsqu'une fenêtre est fermée : on parcourt le tableau 'mesBouts' et quand on est sur le bouton qui appelle la fenêtre passé en paramètre, alors on enlève l'entrée du tableau et on sort de la boucle.Ensuite, on appelle 'affBoutons' pour refaire l'affichage de la barre.

fonds.xml

Ce fichier xml permetr de savoir quels sont les fonds d'écran disponibles, en donnant un tritre, une adresse pour le fond et une adresse pour la vignette à chaque fond disponible. Il ressemble à cela :

ParamBureau.as

C'est la classe qui permet d'afficher tous les éléments dont l'utilisateur a besoin pour faire les changements d'affichage du bureau et les appliquer.

On commence par importer la classe 'Delegate' et 'Button' puisqu'on en a besoin dans la classe. Ensuite on crée la classe 'ParamBureau' et on définit les variables qu'elle utilisera : 'scene' qui est une référence à l'endroit où est appelé la classe, 'clActuelle' pour savoir avec quelle couleur on est arrivé sur la classe, 'alphaActuel' pour savoir avec quel alpha on est arrivé sur la classe, 'fondActuel' pour savoir avec quelle image de fond on est arrivé sur la classe et 'loadImages' qui nous permettra de charger fonds.xml.

Il s'agit ici de la classe constructeur, qui prend en paramètres ceux donnés et décrits dans 'paramBureau.fla'; on les récupère et on affecte les variable de la classe avec ces valeurs là. Ensuite, on appelle la fonction 'creerElementFixe' décrite juste après.

Cette fonction (découpée en plusieurs morceaux pour les explications) commence par crée un clip vide pour le fond gris, et dessine ce fond gris (beginFill). Ensuite, on crée un champ texte pour écrire 'Choix de la couleur de filtre :' qui est non sélectionnable avec une couleur blanche. Puis, on crée le bouton qui permettra d'afficher un colorChooser : il s'agit en fait d'un clip vide que l'on remplis de la couleur actuelle du fond et auquel on met un 'onRelease'. Lors du clic sur ce bouton, on crée d'abord un clip vide 'choix' dans lequel la classe 'ChxCouleur' détaillée plus bas dessinera tous les élements pour le choix de la couleur.
A noter aussi la création de l'écouteur de l'événement 'choix' qui sera diffusé par la classe 'ChxCouleur' lorsque l'utilisateur aura fait son choix de couleur. Cet évenement appellera la fonction 'newColor' de la classe 'ParamBureau', grace à 'Delegate.create', déjà vu plus haut.

Ensuite, on passe à la création du texte pour le choix de l'alpha du filtre coloré, de la même manière que le 1er texte. Puis, on crée un 'NumericStepper' avec un attachMovie, car le composant se trouve dans la bibliothèque avec l'identifiant de liaison 'NumericStepper'. On crée un écouteur se ce dernier qui, lorsqu'on changera sa valeur, appelera la fonction 'newAlpha', vie 'Delegate.create'.

Toujours de la même façon, on crée un champ texte pour afficher 'Choix de l'image de fond :' et on crée un composant 'List', toujours importé depuis la bibliothèque. On lui applique aussi un écouteur, via 'Delegate.create' qui appelera la fonction 'newImage'.
Ensuite, on charge le fichier xml (en ignorant les espaces blancs), et lorsqu'il sera fini de charger, la fonction 'chargeXML'sera appelée.
Puis, on crée notre clip pour charger l'image du cadre de prévisualisation et un autre clip vide pour charger la vignette du fond sélectionné. Et on peut appeller la fonction 'traceFiltre' qui se chargera de l'affichage de la prévisualisation.

Ici, on crée simplement nos 3boutons de l'animation : annuler, appliquer et ok, avec chacun une fonction qui lui est attribuer lors de son clic.

Cette fonction, appelée lors du choix d'une nouvelle couleur, attribue la nouvelle couleur à la variable de la classe, puis appelle la fonction 'traceFiltre' pour refaire la prévisualisation et le bouton pour choisir la couleur.

Idem que newColor sauf qu'elle réagit au changement de l'alpha.

Cette fonction sert à redessiner le filtre coloré, avec la couleur et l'alpha actuellement sélectionné; on fait cela grâce aux méthodes de dessin traditionnels d'un MovieClip.

Cette fonction est appelé lorsque l'on sélectionne un autre fond d'écran dans la liste. Elle redéfinie simplement la variable 'fondActuel' avec le nouveau fond sélectionné et appelle la fonction 'affVign' pour afficher la vignette, en passant en paramètre, l'adresse de la vignette à affciher.

Cete fonction crée un clip vide 'image_mc' dans 'apercu_mc' pour ensuite chargée dedans la nouvelle vignette, qu'on lui a passée en paramètre.

Cette fonction est appelée lorsque 'fonds.xml' est fini de charger. Elle permet de remplir la liste des fond disponibles, en parcourant ligne par ligne le fichier xml. A chaque ligne de la liste, on donne le 'label' (ce qu'on affiche dans la liste) et 2 autres paramètres personnalisés qui permettre de connaitre les adresses de l'image et de la vignette : 'img' et 'vign'.
Si on voit que la ligne qu'on parcourt est celle qui correspond à 'fondActuel' (donc le fond d'écran actuel de l'application), alors on appelle la fonction 'affVign' pour afficher la vignette correspondante.

Cette fonction, appelée lors du clic sur le bouton annuler, exécute le 'onRelease' du bouton 'fermer_btn' de la fenêtre qui contient l'application, ce qui aura donc pour effet final de fermer l'animation.

Cette fonction, appelée lors du clic sur le bouton appliquer, appelle la fonction 'setParam' de l'objet 'monBureau' (objet créé dans 'NyrOS.fla') en passant en paramètres les paramètres sélectionnés actuellement dans la fenêtre. Ceci aura donc pour effet de changer le fond d'écran comme configurer.

Cette dernière fonction, appelée lors du clic sur le bouton ok, est en fait une combinaison des 2 dernières : on applique les paramètres et on ferme la fenêtre.

ChxCouleur.as

Cette classe est très intéressante car elle permet de dessiner et de créer toutes les actions nécessaires à un colorChooser, mais entièrement par le code. A noter que cette classe est aussi utiliser dans 'Dessin.as', et pourrait l'être dans tout autre classe ou fla.

On commence par importer les classes qui nous serviront, a savoir 'EventDispatcher' pour émettre des écouteurs personnalisés et 'Button'. Ensuite, on crée la classe 'ChxCouleur', en la faisant héritée de MovieClip pour pouvoir utilisé 'this._parent' à différents endroits. Ensuite, on crée et on type les variables qui nous seront utiles au sein de la classe : 'dispatchEvent' et 'dispatchQueue' sont des fonctions pour l'évenement personnalisé, 'addEventListener' et 'removeEventListener' pour permettre aux codes extérieurs de créer et enlever les évenements, 'scene' pour avoir une référence à l'endroit où est appelé l'objet, 'couleur' pour notre clip qui contiendra tous nos éléments du colorPicker, 'couleurs' qui contiendra tous nos carrés de choix de couleur, 'cadreCl' permettra d'afficher la couleur actuelement sélectionnée et 'clActuelle' pour savoir qu'elle est la couleur actuellement sélectionnée.
Ensuite, on définit des variables statiques qui définissent les tailles et l'affichage du colorPicker : 'TAILLE' définit la taille d'un carré de choix de couleur, 'NBLIN' définit le nombre de carrés qu'on met sur une ligne, 'HAUTVOIR' et 'LARGVOIR' définissent la hauteur et la largeur du rectangle de visualisation de la couleur sélectionnée et 'POSYVOIR' définit la position en Y par rapport au haut du rectangle de visualistaion.

C'est la fonction constructeur (découpée en plusieurs morceaux) qui prend comme paramètres dans l'ordre : la référence d'où est appelée le colorPicker, la position en X où l'on doit le placer, la position en Y où l'on doit le placer et la couleur que l'on attribue au départ.
Ensuite, la fonction initialise les événements de la classe, puis réatribue les variables passées en paramètres à celle de l'objet. Après on commence par crée le MovieClip vide 'couleur' en le plaçant comme demandé par les paramètres (on fait : "couleur.cetObjet = this" pour pouvoir retrouver dans les boutons carrés la référence à cette classe), puis on crée dans couleur le MovieClip 'couleurs' qui lui contiendra tous les carrés de choix de couleur. Enfin, on crée nos carré 1 par 1, avec 3 boucles imbriqués l'une dans l'autre pour ne donner que des couleurs web. On utilise les fonction 'formatHex' et 'traceCarre' de cette même classe, vues plus loin.

On crée ici notre champ texte de saisie en spécifiant ses aspects graphiques, ses caractères autorisés et son nombre maximal de caratères, son texte par défaut et son action lorsqu'on change son contenu, l'appel de la fonction 'chgText'.

Ici, on crée en quelques sortes des alias de fonction dans couleur, afin que les boutons carrés, le champs texte et les boutons puissent y accéder.

Ce genre de code a déjà été vu dans d'autres classes, on crée un clip vide 'cadreCl' puis on appelle la fonction 'couleur.traceVoir' pour faire l'affichage. Ensuite, on crée 2 boutons valider et annuler, avec des événement qui exécutent des fonctions de cette classe.

Cette fonction sert à transformer un nombre décimal en un nombre hexadécimal.

Cette fonction crée un clip et dessine dedans un carré dans 'couleurs' avec les paramètres qui lui sont donnés : la couleur, son emplacement et son numéro. On définit la variable 'couleur' au sein de ce clip et on applique à chaque carré la fonction 'affCl' lors du survol et la fonction 'choixClic' lors du clic.

Cette fonction est appelée quand l'utilisateur change manuellement le contenu de la zone de saisie pour la couleur. On remet tout en majuscule, puis on redessine le carré de visualisation.

Cette fonction, appelée lors du survol d'un carré de couleur, change la valeur du champ texte en mettant la sienne transformé en majuscule, puis retrace le carré de visualisation.

Cette fonction, appelée lors du clic sur un carré de couleur, appelle la fonction 'valider' de la classe pour fermer le colorPicker et renvoyer la couleur sur laquelle on a cliquée, qui est ici envoyer en paramètre.

Cette fonction sert simplement à redessiner le carré de visualisation avec les méthodes de dessin habituelles de MovieClip, en récupérant la couleur qui est indiqué dans le champ texte.

Cette fonction sert simplement à appler la fonction choisi pour indiquer que l'utilisateur à fait son choix de couleur, en envoyant en paramètre la couleur choisie.

Cette fonction fait la même chose que la précédente, mis à pat qu'elle envoie en paramètre la couleur avec laquelle on est arrivée, 'clActuelle'.

Cette fonction est celle qui va distribué l'événement 'choisi', lorsque l'utilisateur aura choisi une couleur, soit en cliquant sur le bouton valider ou sur un carré de couleur, soit en annulant pour revenir à la couleur de départ.
on crée un objet qui nous permettra de faire notre événement : le type est en fait le nom que l'écouteur devra écouter, target est une référence à l'occurrence qui émet l'événement, couleur est la couleur choisie. Ensuite, on distribue notre événement avec 'dispatchEvent'. Enfin, on détruit notre colorPicker.

ParamDate.as

C'est la classe qui permet d'afficher tous les éléments dont l'utilisateur a besoin pour faire les changements de date et heure et les appliquer.

On commence par importer les classes qui nous serviront dans la classe : 'Delegate' et 'Button', déjà commenté plus haut. Ensuite on crée notre classe 'ParamDate' et on déclare nos varibles utilisés dans la classe : 'scene' est une référence à l'endroit où est appelé la classe, 'horloge' est le clip dans lequelon affichera le cadran de l'horloge, les aiguilles et les 'NumericStepper', 'maDate' sera l'objet Date dans lequel on enregistrera la date réelle de l'utilisateur et 'diffAct' et la différence en secondes par rapport à la date réelle actuelle que l'utilisateur a paraméter.

Cette fonction est le constructeur de la classe. Elle commence par affecter les valeurs passés en paramètres aux variables de la classe, puis on appelle la fonction 'creerElementFixe' pour faire l'affichage. Ensuite, on initialise un setInterval dans l'objet actuel (this) sur la fonction 'refaireDate' toutes les secondes (1000 milisecondes). On appelle tout de suite la fonction 'refaireDate' et on affecte la date actuelle (pas celle de l'ordinateur mais celle avec les paramètres de l'utilisateur) au 'DateChooser'.

Cette fonction, bien que longue n'est faite que de choses simples, déjà vues auparavant. C'est pourquoi elle ne sera pas détaillé, il s'agit en fait que d'attachMovie avec des initObjet, des 'Delegate.create' et autre subtilité. La seule nouveauté consiste dans la paramétrage des noms des jours et des mois du 'DateChooser'.

Cette fonction est appelée toutes les secondes par un setInterval et dès que l'utilisateur redéfinie une nouvelle heure. Elle commence par remetre la date réelle à la variable 'maDate'. Ensuite, on applique la différence actuelle en secondes à notre date pour récuper le temps que l'utilisateur à de paramétrer en ce moment. Ensuite, par rapport à cette nouvelle date, on change tous les affichages relatifs aux heures, minutes et secondes. De plus, s'il on vient de changer de jour, on applique le changement au 'DateChooser'.

Cette fonction, appelée lorsque l'utilisateur change l'heure, calcule d'abord la différence en heures entre l'ancienne date et la nouvelle, puis modifie 'diffAct' suivant cette différence.

Idem que la précédente, sauf que c'est pour les minutes.

Idem que la précédente, sauf que c'est pour les secondes.

Cette fonction, appelée lors du clic sur le bouton annuler, exécute le 'onRelease' du bouton 'fermer_btn' de la fenêtre qui contient l'application, ce qui aura donc pour effet final de fermer l'animation.

Cette fonction, appelée lors du clic sur le bouton appliquer, appelle la fonction 'setParamDate' de l'objet 'monBureau' (objet créé dans 'NyrOS.fla') en passant en paramètres la différence de temps actuellement dans la fenêtre. Ceci aura donc pour effet de changer l'objet 'param' de 'monBureau'.

Cette dernière fonction, appelée lors du clic sur le bouton ok, est en fait une combinaison des 2 dernières : on applique les paramètres et on ferme la fenêtre.

Dessin.as

Cette la classe qui permet de créer toute l'interface de dessin et les actions de dessin.

On commence par importer la classe 'Delegate' car on en a besoin dans la classe. Ensuite, on crée la classe 'Dessin' et on définit les variables utilisés dans la classe : 'scene' qui est la référence à l'endroit où est appellé la classe, 'fondDessin' est la référence au clip de fond de l'animation, 'dessin' est le clip dans lequel on mettra tous les dessins de l'utilisateur, 'outils' est le clip dans lequel on mettra tous nos éléments de paramètres de dessin, 'monEcoutMode' est l'objet écouteur sur le ComboBox de choix du mode de dessin, 'monEcoutEpaiss' est l'écouteur sur le NumericStepper du choix de l'épaisseur, 'monEcoutAlpha' est l'écouteur sur le NumericStepper du choix de l'alpha de la couleur de remplissage, 'monEcoutTrait' est l'écouteur sur le choix de la couleur du trait, 'monEcoutRempl' est l'écouteur sur le choix de la couleur de remplissage, 'dessine' est l'écouteur sur la souris, 'clTrait' est la couleur actuelle du trait, 'clRempl' est la couleur actuelle de remplissage, 'alpha' est l'alpha actuel de la couleur de remplissage, 'modeDessin' est le code pour savoir le mode de Dessin actuel, 'modeDessinLast' est le mode de Dessin précédemment choisi utilisé lorsque on était en mode déplacement ou suppression, 'epaisseur' est l'épaisseur actuelle et 'nb' est le nombre de clip crée par l'utilisateur.
Ensuite on définit des variables statiques qui sont les paramètres de l'application : 'CLFOND' définit la couleur du fond, 'CLOUTILS' définit la couleur de fond de la palette d'outils, 'CLDEFTRAIT' définit la couleur par défaut des traits, 'CLDEFREMPL' définit la couleur par défaut de la couleur de remplissage et 'DEFALPHA' définit l'alpha de la couleur de remplissage par défaut.

Le constructeur de la classe, qui commence par définir la variable 'scene' avec la variable passée en paramètre, puis on appelle la fonction 'creerElements' pour créer tous les clips et composants de l'animation. Ensuite on définit l'écouter dessine sur la souris qui réagira aux évenement 'onMouseDown' et 'onMouseUp' en appellant les fonctions de la classe (via 'Delegate.create') 'debutDessin' et 'stopDessin'. Enfin, on crée la fonction 'detruire' à l'endroit où est appellé la classe pour faire un destructeur de la classe, indispensable pour détruire les écouteurs; cette fonction appellera en fait la fonction 'detruire' de la classe 'Dessin' (le 'monDessin' est indispensable pour pouvoir générer le swf, car sinon, on a une erreur, alors que le 'this' fait ici référence à l'endroit d'où est appellé la classe et non à la classe elle-même...)

Cette fonction, appellée dans le constructeur, sert simplement à créer tous les clips, composants et écouteurs dont l'animation se sert. Comme toutes les fonctions vues ici ont déjà été détaillées dans d'autres classes, je ne vais pas le refaire.

Cette fonction est appellée lorsqu'on clique sur la souris, c'est à dire au commencement d'un dessin. On commence par vérifier que l'on peut véritablement commencé le dessins en s'assurant que le mode de Dessin actuel est bien un mode de dessin et non déplacement ou suppression, que la souris ne se trouve pas sur la palette d'outils (via 'testoutils') et que la souris se trouve bien dans le cadre de l'animation (via 'testzone').
Si c'est le cas, alors on crée un nouveau clip vide dans le clip 'dessin' et on lui attribue tous les paramètres de dessin actuels : le mode de dessin, l'épaisseur du trait, la couleur du trait, la couleur de remplissage et l'alpha. Ensuite on définit un nouveau tableau 'remplir' dans ce tableau qui stockera les coordonnées de tous les points utilisées pour dessiner le clip, et on y met la 1ère valeur qui ets la position actuelle de la souris.
Enfin, on déplace la position de dessin du clip que l'on vietn de crée à alposition actuelle de la souris, on applique le style de trait actuel et on ajoute un événement à écouté à dessine, 'onMouseMove' qui sera la fonction 'dessinAct' qui dessinera le contour en suivant la souris lors de son déplacement.

Cette fonction est appelé lorsqu'on a commencé un dessin (et qu'on ne la pas terminé), lorsque la souris bouge. Elle commence par vérifier si on est bien dans sur le fondpour dessiner et, si c'est le cas, ajoute dans le tableau du clip en cours de dessin un nouveau point, puis dessine le nouveau segment vers ce nouveau point.

Cette fonction, appelée lorsque le clic est relâché, arrête le dessin, et suivant le mode de dessin actuel, ferme le contoure et/ou rempli avec les paramètres définis dans le clip. Puis on incrément la variable nb pour créer le prochain clip sur une autre profondeur, avec un autre nom d'instance. Enfin, on enlève la fonction lors du déplacement de la souris.

Cette fonction, appellée lors du changement de mode de dessin par le comboBox, vérifie d'abord dans quel mode on se place. S'il s'agit du mode déplacement, on ajoute à tous les clips de dessin déjà créés le 'onPress' et le 'onRelease' qui permettent de les déplacer. S'il s'agit du mode de suppression, on ajoute le 'onRelease' qui fera simplement la suppression du clip. Enfin s'il s'agit d'un mode de dessin véritable et que le précédent mode était déplacement ou suppression, alors on supprime les 'onPress' et 'onRelease' de tous les clips de dessin.
S'il s'agit d'un mode de dessin véritable, on attribue la valeur du comboBox à 'modeDessin', sinon (déplacement et suppression) on attribue 0 qui n'est pas un vrai mode de dessin, mais un mode d'édition en fait.

Simple fonction qui attribue la valeur choisie par l'utilisateur à l'épaisseur du trait actuel : 'epaisseur'.

Simple fonction qui attribue la valeur choisie par l'utilisateur à l'alpha de la couleur de remplissage actuel : 'alpha'.

Simple fonction qui inverse la propriété '_visible' de la palette d'outils : 'outils'.

Cette fonction dessine le carré de séléction de couleur du trait avec la couleur de trait sélectionnée.

Cette fonction dessine le carré de séléction de couleur de remplissage avec la couleur de remplissage sélectionnée.

Ces 2 fonctions sont utilisées pour afficher le colorPicker de la couleur du trait et crée l'écouteur qui va avec pour la 1ère fonction, récupérer et appliquer la nouvelle couleur pour la seconde.

Ces 2 fonctions sont utilisées pour afficher le colorPicker de la couleur de remplissage et crée l'écouteur qui va avec pour la 1ère fonction, récupérer et appliquer la nouvelle couleur pour la seconde.

Cette fonction teste si la souris se trouve au dessus de la palette d'outils. On test avec les coordonnées de la souris et non un hitTest car, de cette façon, on est sûr que la souris est (ou n'est pas) au dessus de la palette, car si elle est au dessus d'un composant, le test n'était bon.
On retourne 'true' ou 'false' suivant le cas.

Idem que précédente, sauf que l'on teste pour le fond coloré.

Cette fonction, appelé lors du clic sur le bouton 'exporter en PNG', commence par vérifier si l'utilisateur a déjà dessinée quelque chose. Si c'est le cas, on parcourt tous les clips dessinées, et on construit une variable pour envoyer au javascript de l'html d'où est appellée l'animation.
En fait, on ajoute chaque variable correspondant à chaque clip créés dans un tableau 'dessins'. Dans le contenu de ce tableau, on y met tous les paramètres du clip, séparés par un '_'. Pour faire cela, on commence par mettre tous les paramètres dans un tableau 'dessinTab', puis on transforme en chaîne séparé par '-' en utilisant la méthode 'join' du tableau. A noter aussi qu'on insére les coordonnées des points avec un 'join' du tableau 'remplir' du clip, mais séparé par '-'.
Une fois le tableau 'dessins' remplis avec tous les paramètres de tous les clips, on appelle avec 'getURL' la fonction javascript 'envForm' (décrite à peine plus loin) 2 variables : la 1ère est la couleur de fond de l'animation 'CLFOND' et la 2nde, le tableau 'dessins' que l'on vient de construire, transformé en chaîne avec 'join', séparé par des '@'.

Cette fonction, est en fait la fonction destructrice de la classe. Elle permet, lors de la fermeture de la fenêtre, de supprimer tous les écouteurs de la classe.

ChxCouleur.as

CF ChxCouleur.as, qui est la même classe.

envDessin.js

Ce fichier est intégré dans l'html qui appelle 'NyrOS.swf', et contient 2 fonctions qui permettent l'envoi des données vers un iframe.

Cette fonction, appellée dans le body de la page, sert à créer en javascript le formulaire dans lequel on mettra les données et l'iframe dans laquelle on enverra le formulaire, que l'on place plus haut que le haut de la page, pour la rendre invisible.

Cette fonction, appellée directement par l'animation flash, applique simplement les variables qui lui sont passées en paramètres aux champs du formulaire et envoi le formulaire.

dessin.php

Ce fichier php crée l'image png selon les paramètres qui lui sont envoyés par le formulaire vu juste plus haut et renvoi l'image, en proposant le téléchargement à l'utilisateur.

On définit l'endroit où l'on enregistre l'image sur le serveur.

Fonction qui retroune les valeurs Rouge, Verte et Bleue en décimal dans un tableau, d'une couleur Hexadécimal.

On commence par crée notre ressource '$image' des dimensions identique à l'animation flash.

On dessine un rectangle de la couleur de fond passé en paramètres qui prend toute la surface de l'image.

Cette partie est la plus important du script PHP puisque c'est là que l'on dessine tous les dessins. On commence par transformer la valeur reçue en paramètre en un tableau 'dessins'. Ensuite on parcourt ce tableau, et pour chaque tableau, on crée un second tableau qui contient tous les paramètres du dessin qu'on est en train de parcourir; on fait encore la même chose pour récupérer la liste de tous les points. On crée un second tableau de points, pour pouvoir le passer directement aux fonctions PHP (2 entrées du tableau = 1 point X,Y).
On compte le nombre de points que l'on a et on attribue cette valeur ) '$tout'. Si le mode de dessin du dessin que l'on parcourt, alors on dessine un polygone avec la couleur de remplissage du dessin et son alpha.
Ensuite, on change l'épaisseur du trait avec 'imagesetthickness' pour mettre celle du dessin en cours, pour ensuite dessiner le contour du polygone, en tenant compte de s'il est fermé ou non (d'après le mode de dessin).

On enregistre l'image à l'endroit indiqué au début du script et on détruit l'objet '$image' sur le serveur.

Cette partie de 'header' est utilisé pour forcé le téléchargement de l'image, pour tous les navigateurs.

On lit notre fichier image que l'on vient de créer pour l'envoyer et que l'utilisateur puisse le télécharger.

niveaux.xml

Ce fichier XML est extrait de ce site web : http://www.sourcecode.se/sokoban/levels.php. Il contient tous les niveaux du jeu. Au besoin, on peut changer ce fichier xml par un autre du site.
Il se présente sous cette forme :

Pour chaque niveau, le xml précise son nom 'Id', sa largeur 'Width' et sa hauteur 'Height'. Ensuite, on a les lignes 1 par 1, avec chaque caractère qui représente :
'#' pour un mur
' ' pour un sol ou un espace vide
'.' pour un trou
'$' pour une boule sur un sol
'*' pour une boule sur un trou
'@' pour un Héros
'+' pour un Héros sur un trou

Sokoban.as

Cette classe est celle qui crée le jeu et toutes les actions qui lui sont attribuées. Voici la création de la classe :

On importe déjà la classe 'Delegate' car on en servira dans la classe, puis on crée notre classe et on déclare toutes les variables de la classe : 'scene' est la référence à l'endroit où est appellée la classe, 'mon_fmt' est le format de texte à appliqué au texte de saisie du pseudo, 'plateau' est la référence au clip où l'on crée tous les éléments du jeu, 'mesNiveaux' est l'objet dans lequel on charge les niveaux, 'niveau' définit le niveau actuel du joueur, 'niveaux' définit l'url du fichier xml des niveaux, 'nbBoules' définit le nombre de boules dans le niveau, 'nbBoulesMises' définit le nombre de boules placées dans le niveau, 'nbCoups' définit le nombre de coup du niveau, 'nbCoupsTot' définit le nombre de coup depuis le niveau 1, 'nomNiveau' définit le nom du niveau actuel, 'tabNiveau' définit le tableau du jeu actuel, 'tabBoules' définit le tableau qui sert à identifier les références au clips des boules, 'posHerosX' définit la position en X dans le tableau du héros, 'posHerosY' définit la position en Y dans le tableau du héros, 'objAnnule' est l'objet utilisé pour enregistrer le dernier déplacement de boule (et ensuite l'annuler), 'enregistrement' pour connaître le nombre d'enregistrement restant du niveau et 'monEnvoi' est le LoadVars qui permettra l'enregisrement du score.
Ensuite, on définit les variables de paramétrages de l'animation : 'DEBUTX' est l'endroit en X où l'on commence à placer les éléments du jeu, 'DEBUTY' est l'endroit en Y où l'on commence à placer les éléments du jeu, 'TXTX' et TXTY' est la position en X,Y où l'on place le texte d'affichage, 'TXTLARG' et 'TXTHAUT' sont les largeurs et hauteurs du champ texte, 'TAILLE' est la taille des différents éléments du jeu, 'PROFHEROS' est la profondeur du héros dans l'animation, 'NOMSHARE' est le nom du ShareObject et 'CLFOND' est la couleur de fond de l'animation.

La fonction constructeur de la classe, qui applique les paramètres passés en paramètres aux variables de la classe et qui met en place le 1er écran de demande de pseudo. Il s'agit ici que de choses déjà vues dans d'autres classes, donc je ne vais pas le détaillé.

Cette fonction est utilisé pour réaffecter le style au texte de saisie du pseudo, à chaque fois que l'on change le texte, ceci car sinon le texte n'a pas le format que l'on veut, il reprend du noir.

Cette fonction, appellée lors du clic sur le bouton du 1er écran de saisi du pseudo via 'Delegate.create', commence par vérifier que le pseudo est bien rentré, puis, si c'est le cas, attribue la variable 'pseudo' avec ce qui est entré dans le champ texte, efface l'écran d'accueil (le 'removeMovieClip' ne marche pas ici...) et on lance le jeu en appellant la fonction 'jeu'.

Cette fonction crée le jeu en lui même, en commençant par charger le xml des niveaux, le 'onLoad' se faisant dans la fonction 'chargementNiveaux', on crée le plateau en appellant la fonction 'creerPlateau', on initialise le nombre de coups total et on crée l'écouteur sur le clavier et la fonction 'detruire', qui sera notre destructeur.

Cette fonction, appellée lorsque le fichier xml des niveaux a fini de charger, appelle juste la fonction 'constructionJeu' en cas de succès.

Cette fonction (découpée en partie pour plus de lisibilité) sert à crée le niveau actuel. Ici, on commence par initialiser nos variables spécifiques au niveau (les boules, les coups, le nombre d'enregistrement, l'objet d'annulation, et les différents tableaux).

Ensuite, on fait une boucle sur toutes les lignes du niveau, puis sur tous les caractère de chaque ligne. Ensuite, suivant le caractère, on crée les clips qui conviennent, suivant la codification donnée dans le fichier 'niveaux.xml', tout en créant les tableaux du jeu et des boules (ce tableau à 2 entrées x y contient les références de toutes les boules), la position du héros. Ensuite, on initialise l'affichage du texte.

Cette fonction sert à mettre à jour l'affichage, on change juste le contenu du 'text' du champ texte que l'on a crée au début.

Cette fonction sert à crée le clip vide 'plateau', le placé comme paramétré dans les variables 'static', en créant les fonction de déplacement sur le plateau, et crée le champ texte pour l'affichage.

Cette fonction (découpé en morceaux pour plus de lisibilté) est appelé lorsqu'une touche est enfoncée. On commence par définir la variable 'touche' à laquelle on donne la valeur de la touche enfoncée, puis les variables 'bgX' et 'bgY' qui sont les variables utilisées pour savoir dans quel direction le joueur veut aller. Ensuite, suivant la touche enfoncée, on appelle les fonctions correspondante, ou on change les valeurs de 'bgX' ou 'bgY'.

Ici, on regarde si c'est bien un déplacement et, si c'est le cas, on regarde vers quel type d'endroit il veut aller. S'il se dirige vers un trou ou un endroit vide, on fait le déplacement en changeant le tableau du jeu, la position du héros et on incrémente 1 coup aux variable de la classe.

Si on se dirige vers une boule (placée ou pas) alors, on regarde ce qu'il y a 1 cran plus loin que la boule. Puis si l'endroit vers lequel la bouel est censée aller, alors on pourra bouger, donc on enregistre tout de suite notre objet d'annulation dans la fonction 'enregAnnule'.
Puis on récupère la référence de la boule qu'on veut pousser et on l'a bouge.

Suivant où la boule se dirige (un endroit vide ou un trou) et l'endroit où elle était, on modifie les valeurs du tableau et les valeurs des boulesMises.

Enfin, on modifie la position de notre héros dans le tableau et dans l'affichage.

Pour finir la fonction, on vérifie si le nombre de boules mises est égal au nombre de boules du niveau, si c'est le cas, le joueur a fini le niveau, donc on en charge un autre. Et on réactualises l'affichage en appellant la fonction.

Cette fonction sert à enregistrer l'objet d'annulation de déplacement de boules. Elle est appelée avant chaque déplacement de boule. Ainsi, on enregistre les positions qui vont être déplacées dans l'objet pour pouvoir les remettre quand le joueur le souhaitera.

Cette fonction sert à annuler le dernier déplacement de boule, lorsqu'on clique sur la touche espace. On commence par vérifier si l'objet d'annulation existe bien et, si c'est le cas on remet le héros à la place où il était avant, ainsi que la boule déplacée. On fait aussi tout un tas de vérification pour remettre les bons nombre de 'boulesMises', en changeant les positions du héros et de la boule en question, ainsi que l'affichage de la boule ('gotoAndStop'). Enfin, on incrémente un coup aux variables de la classe.

Cette fonction commence par vérifié si le crédit d'enregistrement par partie n'est pas épuisé, et si il en reste, alors on enregistre dans le ShareObject toutes les variables de la classe, et on écrit le ShareObject, pour enfin retiré un enregistrement disponible.

Cette fonction sert à remettre la sauvegarde du joueur. En fait, on commence par réattribué les variables qui se trouvent dans le ShareObject, puis on fait quasiment la même chose que dans la fonction 'constructionJeu', c'est pourquoi elle ne sera pas recommentée ici.

Cette fonction sert à envoyer au fichier PHP 'enregsoko.php' les différentes variable dont il a besoin pour faire l'enregistrement. Ensuite, on définit l'onLoad de de l'objet 'monEnvoi' vers la fonction 'enregistreAction'.

Cette fonction sert à détruire la sauvegarde de jeu du joueur, puis à recommencer le jeu au début, en rappellant les fonctions 'creerPlateau' et 'constructionJeu'.

sokoscores.sql

Ce fichier sert à créer la table de donnée MySQL pour enregistrer les scores du sokoban

on a donc besoin d'un identifiant (toujours utile), du pseudo du joueur, du niveau auquel il a terminé, du nombre de coups qu'il a fait pour arriver ici et de la date de l'enregistrement.

enregsoko.php

Ce fichier, auquel on envoi le pseudo du joueur, le niveau et le nombre de coups sert à enregistrer le score dans la base de donnée.

On commence par aller cherche le fichier 'conf.php', qui contient les paramètres de connection à la base de donnée et la classe requêteur MySQL de ma création. Puis on récupères les variables envoyés en POST par l'animation Flash.

On initialise la variable '$res' de retour à 0, ensuite, on vérifie que tous les champs sont renseignés. Si c'est le cas, on fait notre requête d'ajout, et si tout se passe bien, on met la varaible de retour à 1.

Enfin, on écrit notre variable de retour pour Flash.

conf.php

Ce fichier est utilisé pour tous les scripts PHP qui auront besoin de se connecter à la base de donnée MySQL. Il paramètre l'accès à la base de donnée et en définissant l'hôte, le nom de la base de donnée, le nom d'utilisateur et le mot de passe. Ensuite on définit toute une classe 'sql' qui permet d'effectuer des requête sur la base de données, suivant les paramètres définies auparavant.
Ce fichier ne sera pas détaillé ici car ce n'est pas le sujet.

accordion.xml

Ce fichier xml définit ce que l'on va afficher dans l'animation 'sokobaide.fla'. Il se présente sous cette forme :

Chaque noeud 'text' sera affiché dans un élément de l'accordion avec comme titre 'nom'.

scores.php

Ce fichier PHP va chercher les scores dans la base de donnée et les retournes tous, sous forme d'un fichier xml.

On inclut le fichier de configuration MySQL 'conf.php' et on fait la requêtes. On commence par écrire la racine 'scores' du fichier xml.

On parcourt tous les résultats de la requête. Pour chacun d'entre eux, on transforme la date dans un format francisé et on affiche un nouveau noeud 'score' avec tous les attributs qui définissent le score.

Enfin, on ferme la racine du xml.

conf.php

CF conf.php, qui est le même fichier PHP.

Sokobaide.as

C'est la classe qui crée l'accordion et le rempli, dans sokobaide.fla.

On commence par importer les classes Flash que l'on utilisera dans la classe. 'gridclasses.DataGridColumn' est le type de donnée d'une colonne d'un DataGrid; on l'utilise pour créer dynamiquement des colonnes de DataGrid avec des largeurs spécifiques. 'Delegate' a déjà été vu et revu.
Ensuite, on crée la classe, et on définit les variable de la classe : 'scene' qui est la référence à l'endroit d'où est appellée la classe, 'monAccordion' est la référence à l'accordion crée, 'monLoadPhp' est l'objet XML dans lequel on chargera les scores, 'monXml' est l'objet XML dans lequel on chargera le contenu de l'accordion et 'monEcouteur' est l'objet qui fera l'écouteur sur l'accordion.

C'est le constructeur de la classe, qui crée l'accordion en lui donnant les dimensions de la scène, définit la fonction 'onLoad' de 'monLoadPHP' qui sera la fonction 'loadScore' de la classe, fait la même chose pour 'monXml' qui sera la fonction 'loadXml', charge le fichier xml de contenu de l'accordion, et crée l'écouteur sur le changement de l'accordion.

Cette fonction est appellée lorsque l'utilisateur change de parties dans l'accordion. On vérifie juste s'il va sur le dernier, et si c'est le cas, on recharge les scores. Ceci pour être sûr d'afficher les derniers scores disponibles sur le serveur.

Cette fonction est l'onLoad' de l'objet Xml 'monLoadPhp'. Elle vérifie juste si le fichier est bien chargé et, si c'est le cas, appelle la fonction 'afficheScores' pour insérer tous les scores dans le DataGrid.

Idem que la précendente, sauf que c'est pour 'monXml' et qu'on appelle 'ecrireAccordion' en cas de succès.

On commence par mettre dans la variable 'monNoeud' le contenu que l'on doit parcourir du fichier Xml. On le parcourt dans la boucle for, et à chaque nouvelle ligne, on ajoute une nouvelle partie ('createChild') avec comme clip attaché 'texte' (celui qui contient un champ texte) en lui donnant le nom renseigné dans le fichier xml. Puis, on paramètre la largeur du champ texte et sa propriété 'autoSize' pour que rien ne soit caché et on applique le texte html issu du fichier xml.
Ensuite, une fois le fichier xml parcourut en entier, on ajoute encore une partie, qui contient le dataGrid pour les scores et on fait les ajouts de colonne en passant par la fonction 'ajtCol' vue juste après.

Cette fonction sert à ajouter une colonne dans le DataGrid. Elle prend en paramètre : 'grille' qui est la référence au DataGrid dans lequel on doit ajouter la colonne, 'nom' qui est le nom que l'on affiche dans le titre de la colonne et 'larg' qui est la largeur de la colonne.
On crée un objet colonne de type 'DataGridColumn', on lui attribue les paramètres passés à la fonction, et on l'ajoute au DataGrid avec 'addColumn'.

Cette fonction, appellée lorsque le fichier PHP des scores est fini de charger, commence par supprimer toutes les lignes du DataGrid, puis parcourt toutes les lignes du xml et les ajoutes dans le DataGrid, en passant par un objet dont toutes les propriétés sont en fait le nom des colonnes données au DataGrid. On ajoute véritablement au DataGrid avec 'addItem'.

Il s'agit ici de la fonction destructeur de la classe, qui sera appellée lors de la fermeture de la fenêtre. Elle détruit tous les éléments de l'accordion, puis l'accordion et son écouteur. Enfin on détruit les 'onLoad' des fichiers PHP et XML, ainsi que les objets qui ont permis de les charger.

listMP3.php

Ce script PHP récupère la liste des fichier MP3 disponibles dans le dossier mp3, les tris aléatoirement et retourne un fichier xml avec chacun d'entre eux.

On récupère dans le tableau '$mp3' la liste de tous les MP3 disponibles (fichiers dans le dossier mp3 dont le nom se termine par '.mp3').

On trie aléatoirement le tableau '$mp3', après avoir initialisé le générateur de nombre aléatoire avec 'srand' pour un aléatoire plus poussé.

Enfin, on écrit notre xml en parcourant ligne par ligne le tableau '$mp3', en inscrivant à chaque fois le noeud 'track' contenant simplement l'url du fichier MP3.

Musique.as

C'est la classe qui crée le player MP3, à l'aide du composant MediaPlayback.

On importe la classe 'Delegate' puisqu'elle nous servira dans la classe, puis on crée la classe, en commençant par définir toutes les variables de la classe : 'scene' qui est la référence de l'endroit où est appellée la classe, 'mesMusiques' qui est le tableau contenant toutes les url des mp3 de la playlist, 'zikAct' qui est l'index indiquant quelle chanson l'utilisateur écoute actuellement et 'monLoadPHP' qui est l'objet XML qui permettra de charger la playlist.

C'est le constructeur de la classe, qui crée le MediaPlayback avec un 'attachMovie' sur la 'scene', initialise la chanson lue actuellement 'zikAct' à 0, paramètre et lance le chargement du fichier mp3 dans 'monLoadPHP' et crée l'écouteur de fin de chanson sur le MediaPlayback, dans la fonction 'recharge' de la classe.

C'est la fonction appellée lorsque le fichier 'listMP3.php' est fini de chargé. Si tout s'est bien passé, on place la liste des MP3 dans le tableau 'mesMusiques' et on lance la lecture en appellant la fonction 'recharge'.

On commence par vérifier si la musique qu'on est censé commencer à jouer est défini. Si ce n'est pas le cas, on réinitialiste 'zikAct' à 0. Ensuite, on attribue le fichier mp3 suivant au MediaPlaybacj avec 'setMedia', puis on lance la lecture avec 'play'. Enfin, on incrément 'zikAct' pour avancé d'une piste pour la prochaine fois.

video.flv

Ce fichier est juste la vidéo que l'on veut afficher, enregistré au format 'flv' grâce à Flash.

Vid.as

Cette classe permet d'afficher tous les éléments indispensable pour la lecture vidéo et la vidéo elle-même.

On commence par importé la classe 'Delegate' car on en a besoin dans la classe, puis on crée la classe en commençant par définir les variables de la classe : 'scene' qui est la référence à l'endroit où est appellé la classe, 'maVideo' qui sera la référence à l'objet 'MediaDisplay' et 'monCTL' qui sera la référence à l'objet 'monCTL'.

C'est le constructeur de la classe. Elle pose les 2 composants 'MediaDiplay' et 'MediaController' avec les noms 'maVideo' et 'monCTL', en paramétrant leur position dans l'animation et leur taille. On ajoute aussi un écouteur sur le 'MediaDisplay' pour appellé la fonction 'charge' lorsque la vidéo sera en cours de chargement.
On définit aussi la classe 'detruire' sur la scene qui sera le destructeur de la classe pour ne pas avoir de problème lors de la réouverture d'une fenêtre vidéo.

Cette fonction, appellée lorsque la vidéo est en cours de chargement, permet d'associer le contrôleur à la vidéo.

video.flv

Ce fichier est juste la vidéo que l'on veut afficher, enregistré au format 'flv' grâce à Flash.

vidStream.as

Cette classe permet d'afficher tous les éléments indispensable pour la lecture vidéo et la vidéo elle-même.

On commence par importer la classe 'Delegate' de Flash, car on en aura besoin. Ensuite, on définit les variable de la classe : 'scene' qui est la référence à l'endroit où est appelé la classe, 'video' est l'url de la vidéo, 'monNc' est l'objet 'NetConnection' pour le streaming, 'fluxVideoNs' est l'objet 'NetStream' pour le streaming, 'min' est le nombre de minutes de la vidéo, 'sec' est le nombre de seconde de la vidéo et 'inter' correspond au nombre attribué par le 'setInterval'.

Cette fonction est le constructeur de la classe. Elle commence par crée tous les élements à afficher (boutons, vidéo et progressBar). Noter ici que les initObjet sur les boutons ne fonctionnent pas, c'est pour cela que je le fais après leur création. Le reste a déjà été vue plusieurs fois donc n'est pas redétaillé.
Ensuite, on crée notre streaming avec les 4 ernière lignes de la fonction, en reliant 'monNc', 'fluxVideoNs' et l'affichage de la vidéo. Ensuite, on est prêt à afficher une vidéo en streaming sur notre animation.
Enfin, on définit le destructeur de la classe, qui sera appellée lors de la fermeture de la fenêtre pour arrêter le streaming.

Cette fonction est appelé par un setInterval pour mettre à jour l'affichage de la progression de la vidéo. On utilise simplement la méthode 'setProgress' du ProgressBar, en lui donnant le temps actuel et le temps total de la vidéo.

Cette fonction est appellée lors du clic sur le bouton play. Si un interval a déjà été définit, cela signifie que l'on est en pause, donc on reprend la lecture. Sinon, on lance la lecture en spécifiant l'url du fichier vidéo à streamé. Enfin, on lance le setInterval pour mettre à jour l'affichage, on rend invisible le bouton play et on affiche le bouton pause.

Cette fonction est appellée lors du clic sur le bouton pause. Elle met simplementla vidéo en pause, détruit le setInterval, rend invisible le bouton pause et réaffiche le bouton play.

Cette fonction est appellée lors du clic sur le bouton stop. Elle appelle la méthode 'close' du streaming pour arrêter la vidéo, détruit le setInterval, et remets 'inter' à 0, rend invisible le bouton pause et réaffiche le bouton play.

Webcam.as

Cette classe affiche tous les éléments nécessaire à l'affichage de la webcam et des paramètres du micro (numericStepper pour régler le volume du micro, label pour afficher la description et progressbar pour afficher le volume de sortie actuel.
En fait, cette classe n'a qu'une seule fonction, qui est son constructeur.

Pour commencer, on crée un fond gris à l'animation, puis on attache le clip camera qui est dans la bibliothèque et on crée la variable 'maVideo' qui est une référence à la vidéo contenu dans le clip. On lui affecte les dimensions que l'on souhaite pour mettre au format de l'animation.

Ici, on définit un nouvel objet 'monMic' auquel on donne les attributs du micro pour le volume, puis on atache le son du micro sur la scene, avec 'attachAudio'.

Ici on affiche le progressBar avec es valeurs que l'on veut, même chose pour le Label et le numericStepper. On affiche aussi la webcam sur le clip vidéo.

On crée l'enterFrame sur la scene pour changer la valeur du progressbar tout le temps suivant le niveau enregistré actuellement par le micro. On réaffecte aussi lors du changement du numericStepper le nouveau gain pour le Micro, avec un écouteur

livre.php

Ce fichier PHP va rechercher 10 messages disponibles dans la base de donnée, suivant les paramètres '$page' et '$nbr_ppage' qui lui sont donnés et retourne les résultats sous forme d'un XML.

On commence par inclure le fichier 'conf.php' qui est la configuration à la base de donnée et la classe de requêtes MySQL. Ensuite, on récupère les paramètres donnés par le Flash en POST, puis on vérifie si la variable '$page' est bien renseigné, et si ce n'est pas le cas, on l'initialise à 0. Enfin, on calcule la valeur de '$debut' pour la requête.

On écrit notre requête '$sqlv', en calculant, avant d'ajouter le 'LIMIT' à la requête, le nombre de messages total. Ensuite, on exécute la requête MtSQL et on l'attribueà '$req'.

On parcourt tous les résultats pour construire la variable '$retour' que l'on enverra à Flash.

Enfin, on écrit la variable retour pour Flash, en prenant soin de l'encoder en utf8 pour bien avoir les accents.

conf.php

CF conf.php, qui est le même fichier PHP.

livrestyle.css

C'est une feuille de style tout à fait normal, que l'on applique au 'TextArea' pour afficher les messages. Voici son contenu :

Livre.as

C'est la classe qui s'occupe d'afficher tous les éléments nécessaire à la visualisation du livre d'or et à l'ajout.

On commence par importé toutes les classes Flash dont on a besoin dans la classe : 'Delegate', 'Button', 'TextArea', 'textInput' et 'Alert'. Ensuite, on crée la classe et on définit les variables de la classe : 'scene' qui est la référence à l'endroit où est appellée la classe, 'action_btn' qui est la référence au bouton pour changer entre voir et ajouter, 'pageAct' est la page actuelle de visualisation, 'pageTot' est le nombre de pages total, 'loadLivre' est l'objet LoadVars de chargement des messages, 'styleCss' est l'objet dans lequel on charge la CSS, 'styleCharge' sert à savoir si le style a déjà été chargé pour ne pas le refaire, 'envoiMess' est l'objet LoadVars d'ajout de message et 'NBPAGE' paramètre le nombre de messages que l'on affiche par page.

C'est le constructeur de la classe. Il initialise les variable de la classe, appelle 'creerElementFixe' pour créer le fons gris et le bouton d'action et appelle 'traceVoir' pour afficher tous les éléments pour voir les messages et affiche la 1ère page.

Cette fonction créer tous les élements communs aux 2 interface, le fond gris et le bouton d'action.

Cette fonction est appellée lorsque l'utilisateur clique sur le bouton d'action. On regarde le 'label' du bouton, et suivant le cas, on appelle les fonctions qui permettent d'afficher ce que veut l'utilisateur et on change le 'label' du bouton vers l'autre valeur.

Cette fonction crée tous les élements pour l'affichage des messages du livre d'or : les 'TextArea' et les boutons suivant et précedent. Ensuite, si la CSS a déjà été chargée, on lance directement le chargement des messages en appellant la fonction 'chargeLivre', sinon, on charge le feuile de style, en affichant un message dans le 'TextArea' pour informer l'utilisateur de ce qui se passe.

Cette fonction est appellée lorsque la feuille de style CSS a fini de chargée ou a échoué. Selon le cas, on affiche où en est le chargement des messages dans le 'TextArea' et si c'est bien chargé, on appelle la fonction 'chargeLivre' pour lancer le chargement des messages. On met aussi la variable 'styleCharge' à true pour ne pas recharger la CSS ensuite.

Cette fonction sert à lancer le chargement des messages du livre d'or. On commence par réappliquer la feuille de style, puis on lance le chargement du PHP dans l'objet 'loadLivre', en envoyant la page que l'on veut 'pageAct' et le nombre par page 'NBPAGE'.

Cette fonction est appelée lorsque le PHP qui donne les messages de la page souhaitée à fini de chargée. Si le chargement s'est bien passé, on commence par créer un nouvel objet XML 'monLivre', auquel on donne la valeur de la variable 'loadLivre.retour' donnée par le PHP. En faisant ça, 'monLivre' va parser toute la variable 'loadLivre.retour' pour en fair un XML à part entière. Ensuite on parcourt comme un autre XML 'monLivre', en ajoutant à chaque fois la ligne à la variable 'affiche', en insérant les balises HTML que l'on veut. Une fois le parcourt du xml terminé, on applique la variable 'affiche' au champ de texte HTML.
Enfin, on fait quelques tests pour savoir s'il doit afficher les boutons suivants et précédents pour la navigation entre les pages.

Cette fonction est appellée lors du clic sur le bouton suivant. On commence par vérifier s'il y a bien une page après, et si c'est le cas, on incrémente la valeur de 'pageAct' et on appelle la fonction 'chargeLivre' qui va aller chercher les messages de la page suivante.

Idem que la fonction précédente, sauf qu'on va à la page précédente.

Cette fonction sert à créer tous les élements qui permettent l'ajout d'une signature dans le livre d'or. Comme toutes les fonctions utilisées ici ont déjà été commentées, on passe directement à la suite.

Cette fonction, appellée lors du clic sur le bouton envoyer du formulaire d'ajout de message, commence par vérifier que tous les champs ont une longueur pas trop petite. On vérifie aussi que l'email a bien un '@' et un '.' pour que l'adresse mail soit valide. Si une erreur survient, on ajoute dans le tableau 'erreur' la description de l'erreur.
Ensuite, si le tableau 'erreur' n'est pas vide, on affiche toutes les erreurs dans une 'Alert'. Sinon, on prépare l'envoi des variables dans un LoadVars 'envoiMess' en définissant toutes les variables que l'on enverra, puis on fait l'envoi vers 'ajoutLivre.php' en POST. Enfin, on appelera la fonction 'envoiLoad' lorsque le PHP sera fini de charger.

Cette fonction, appellée lorsque le fichier PHP d'envoi est fini de charger, vérifie la valeur 'res' retournée par le PHP. Si elle vaut 0, c'est qu'une erreur s'est produite; alors, on réactive le bouton d'envoi et on affiche une 'Alert'. Sinon, on remet la variable 'pageAct' à 0, puis on fait comme si l'utilisateur cliquait sur le bouton d'action pour recharger les messages. Ainsi, l'utilisateur verra directement son message, en 1er, puisque le PHP retourne les messages classés du plus récent au plus ancien.

Cette fonction, appellée lorsque le fichier PHP d'envoi est fini de charger, vérifie la valeur 'res' retournée par le PHP. Si elle vaut 0, c'est qu'une erreur s'est produite; alors, on réactive le bouton d'envoi et on affiche une 'Alert'. Sinon, on remet la variable 'pageAct' à 0, puis on fait comme si l'utilisateur cliquait sur le bouton d'action pour recharger les messages. Ainsi, l'utilisateur verra directement son message, en 1er, puisque le PHP retourne les messages classés du plus récent au plus ancien.

livreflash.sql

Ce fichier sert à créer la table de donnée MySQL pour enregistrer les messages du Livre d'or.

On a donc besoin d'un identifiant (tojours utile), du titre du message, du pseudo de la personne, du mail de la personne, de son message et de la date du message.

ajoutLivre.php

Ce fichier, auquel on envoi le pseudo du joueur, le niveau et le nombre de coups sert à enregistrer le score dans la base de donnée.

On commence par inclure le fichier de configuration pour la base de donnée et de création de la classe sqlqui permet de faire des requêtes sur la base de donnée. Puis, on récupère les variables envoyées par le Flash en POST, en les décodants. Enfin, on initalise les variables '$erreur' et '$res'.

Ensuite, on vérifie que tous les champs sont fournis. Si c'est le cas, on fait l'ajout dans la base de donnée, et si tout se passe bien, on définit la variable '$res' à 1. Si une erreur survient, on définit la variable '$erreur' avec la description de l'erreur qui est survenu pour pouvoir l'afficher dans Flash.

Enfin, on écrit les variables '$res' et $retour' pour que Flash puisses les exploiter.

Traduction.as

Cette classe affiche tous les éléments nécessaire à la traduction : 'TextArea' pour entrer le texte à traduire et un autre pour afficher le texte traduit, une 'ComboBox' pour choisir le mode de traduction, un 'Button' pour lancer la traduction et des 'Label' pour décrire les 'TextArea' et afficher l'état de la traducion.

On commence par importer la classe Delegate car on en aura besoin, puis on déclare les variables de la classe : 'scene' qui est la référence à l'endroit où est appelée la classe et 'traduc' qui décrit le mode de traduction, de la façon dont le demande BabelFish.
Ensuite, la constructeur de la classe charge les 'crossdomain.xml' de façon à ce que le Player Flash (à partir de la version 7) aie les autorisations pour charger les différentes choses dont le WSDL se servira pour traduire.
Puis, on appelle la fonction 'creerElementFixe' qui affichera tous les éléments de l'animation.

Quasiment rien de nouveau dans cette classe, elle fait juste des attachMovie sur le composants et les pose sur la scene.
On le fait aussi pour le composant 'WebServiceConnector' qui est invisible, mais sert à appeler le WSDL. on lui renseigne en paramètre 'WSDLURL' qui est l'adresse du WSDL sur internet, et on lui applique des écouteurs lors de l'envoi 'send' et lorsque le résultat est arrivé 'result'.

Cette fonction est appellé lorsque l'utilisateur change le choix de la langue. On se contente simplement d'appliquer la valeur du type de traduction choisi à la variable d'instance 'traduc'.

Cette fonction, appelée lorsque le 'WebServiceConnector' commence à envoyer les valeurs au WSDL, affiche simplement dans le 'Label' 'etat_txt' les mots 'En cours' pour informer l'utilisateur que l'envoi de la traduction a bien commencé.

Cette fonction, appelée lorsque le 'WebServiceConnector' reçoit la réponse du WSDL, affiche le résultat dans le 'TextArea' 'traduit', puis efface le texte que l'on a mis sur le 'Label' affichant l'état de la traduction.

Cette fonction, appelée lors du clic sur le bouton traduire, réaffecte les valeurs 'sourcedata' avec le texte à traduire, 'translationmode' avec le mode de traduction sélectionné au paramètres envoyés au WSDL. On réaffecte aussi l'opération que l'on souhaite faire : 'BabelFish' (on est obliger de le refaire à chaque fois sinon le WebService ne fonctionne pas).
Enfin on lance le chargement du WebService avec la méthode 'trigger' de celui-ci.

Whois.as

Cette classe affiche tous les éléments nécessaire eu Whois : 'TextInput' pour entrer le domaine dont on veut le whois et un 'TextArea' pour afficher le Whois retourné, un 'Button' pour lancer le Whois et un 'Label' pour écrire 'domaine :'.

On commence par importer la classe Delegate car on en aura besoin, puis on déclare les variables de la classe : 'scene' qui est la référence à l'endroit où est appelée la classe.
Ensuite, la constructeur de la classe charge le 'crossdomain.xml' de façon à ce que le Player Flash (à partir de la version 7) aie les autorisations pour charger les différentes choses dont le WSDL se servira pour sortir le Whois.
Puis, on appelle la fonction 'creerElementFixe' qui affichera tous les éléments de l'animation.

Quasiment rien de nouveau dans cette classe, elle fait juste des attachMovie sur le composants et les pose sur la scene, la même chose que pour la classe 'Traduction'.
On le fait aussi pour le composant 'WebServiceConnector' qui est invisible, mais sert à appeler le WSDL. on lui renseigne en paramètre 'WSDLURL' qui est l'adresse du WSDL sur internet, et on lui applique des écouteurs lors de l'envoi 'send' et lorsque le résultat est arrivé 'result'.

Cette fonction, appelée lorsque le 'WebServiceConnector' commence à envoyer les valeurs au WSDL, affiche simplement 'en cours...' dans le 'TextArea' et remet ses scrollers au début.

Cette fonction, appelée lorsque le 'WebServiceConnector' reçoit la réponse du WSDL, affiche le résultat dans le 'TextArea' 'whois_txt'

Cette fonction, appelée lors du clic sur le bouton 'Whois ?', réaffecte les valeurs 'username' et 'password' avec les identifiants sur lesite flash-db.com et 'domain' qui est en fait ce qu'a rentré l'utilisateur dans le 'TextInput'. On réaffecte aussi l'opération que l'on souhaite faire : 'doWhois' (on est obliger de le refaire à chaque fois sinon le WebService ne fonctionne pas).
Enfin on lance le chargement du WebService avec la méthode 'trigger' de celui-ci.