Introduction à Flash
Interface du logiciel
Manipulation du texte
Manipulation des formes
Symboles & Occurrences

Gestion du scénario (la Timeline)
Interpolations

Masques et guide de mouvement

Téléchargements
  - www.lexplicateur.com (flas)
  - Archives de .flas (MX)
  - PDF


# Niveau III : Fonctions avancées

[11-04-02]

- Créer un prototype
- Temporiser une animation
   . onEnterFrame
   . setInterval()
- Surveiller les actions liées au clavier et à la souris

Pour consulter de nombreux exemples supplémentaires, consultez également Lexplicateur.com.


PAGES EN COURS... de travaux...

 

Créer un prototype

Qu'est-ce qu'un prototype ?

Lorsque vous utilisez des commandes comme startDrag(), loadMovie(), duplicateMovieClip(), getBytesLoaded() et bien d'autres, vous ne vous souciez pas de la "façon" dont procède Flash pour exécuter ce que vous lui demandez. Et pourtant, sans essayer de savoir quel code se cache derrière ces "mots", ne serait-il pas intéressant de créer ses propres "commandes" ? C'est ce que proposent les prototypes. Pour être précis, on ne parle pas de "commandes" mais de "méthodes".

Afin d'essayer de mieux comprendre le fonctionnement des méthodes et des prototypes, commençons par répondre à cette question : Quels sont les deux points communs aux méthodes énoncées ci-dessus (startDrag(), loadMovie()...) ?

- Toutes ces commandes sont suivies des parenthèses "( )".
- Elles s'appliquent à des occurrences de clip.

Les parenthèses :

La notion de "fonction" en programmation utilise ces parenthèses pour suffixer un mot que représente la fonction elle-même.

function jouer() {
   ligne d'instruction
   ligne d'instruction
}

Remarque : Rappelons qu'une fonction en Flash peut aussi être créée ainsi :

jouer = function () {
   ligne d'instruction
   ligne d'instruction
}

Occurrence de type clip :

Vous ne le savez peut-être pas encore, mais en regardant l'aide de Flash, vous découvrirez que pour obtenir des informations sur les commandes énoncées ci-dessus vous devez regarder à la lettre M comme MovieClip. En effet, vous utilisez sans le savoir des méthodes de l'objet MovieClip lorsque vous utilisez startDrag(), loadMovie(), etc.

A partir de ces 2 constats, ne pourrait-on pas associer une fonction à l'objet MovieClip ? Et bien si ! C'est le "terme" "prototype" qui va faire le lien entre la fonction et l'objet MovieClip.

Exemple 1 :

La commande zoomAvant() (fonction que nous allons créer) va faire grossir un clip. A chaque clic sur le bouton contenant le script ci-dessous, l'occurrence de type clip placée sur la scène qui s'intitule "carte" va augmenter de taille (de + 5%).

on (press) {
   carte.zoomAvant()
}

Comment a été créée cette méthode ?

Sur l'image clé, le script ci-dessous a été saisi :

MovieClip.prototype.zoomAvant = function() {
   this._xscale += 5;
   this._yscale += 5;
};

Explications :

Nous associons la fonction qui contient les deux lignes d'instructions (qui permettent d'augmenter la taille d'une occurrence de 5%) à l'objet MovieClip grâce au "trait d'union" représenté par "prototype.zoomAvant".

zoomAvant est le nom de la méthode à utiliser avec les occurrences de type clip. Elle même (la méthode) fait référence à la fonction qui lui est assignée grâce au signe "=".

Voici à quoi ressemble obligatoirement toutes les méthodes que vous créez.

MovieClip.prototype.nomdelamethode = function() {
   voslignesd'instructions
   voslignesd'instructions

};

Comme vous pouvez le constater, seuls le nom de la méthode et vos lignes d'instructions vont changer d'un prototype à un autre.

Pour faire référence à l'occurrence qui utilisera (fera appel à) la méthode que vous vous apprêtez à créer, vous devez utiliser le mot clé this.

MovieClip.prototype.avancer = function() {
   this._x+=10
};

Dans ce cas, lorsque l'utilisateur saisit l'instruction ci-dessous, cela signifie que l'occurrence intitulée "perso" doit avancer de 10 pixels vers la droite.

perso.avancer()

Nous aurions également pu ajouter un paramètre afin de préciser la valeur du pas de déplacement :

MovieClip.prototype.avancer = function(pas) {
   this._x+=pas
};

Il faudrait alors saisir le script ci-dessous :

perso.avancer(10)

Exemple 2 :

Dans l'exemple 1 présenté ci-dessus, nous venons de créer un prototype chargé de faire grossir une occurrence. Vous avez peut-être remarqué qu'il faut effectuer de multiples clics pour augmenter progressivement la taille de l'occurrence.

Nous allons donc voir comment il est possible de modifier notre première fonction afin de faire grossir en continu (tant que le bouton de la souris est enfoncé) le clip concerné.


MovieClip.prototype.zoomAvant = function() {
   this.onEnterFrame = function() {
      this._xscale += 3;
      this._yscale += 3;
   };
};

Nous venons d'ajouter dans notre script, le gestionnaire d'évènement onEnterFrame qui permet d'exécuter en boucle le code qu'il contient. L'exemple ci-dessous correspondant au code qu'il faudrait saisir sur l'image clé afin de déplacer en continu une occurrence intitulée "perso" (localisée sur la scène).

_root.onEnterFrame = function() {
   perso._x += 3;
};

Pour revenir à notre développement, le fait de placer ce gestionnaire...

this.onEnterFrame = function() {
   this._xscale += 3;
   this._yscale += 3;
};

... dans notre prototype...

MovieClip.prototype.zoomAvant = function() {

};

...permet d'exécuter en continu le code ci-dessous :

this._xscale += 3;
this._yscale += 3;

Résultat : Si vous saisissez le script ci-dessous sur l'occurrence d'un bouton, l'occurrence de type clip intitulé "perso" (localisée sur la scène) va grossir en continu de 5% en 5%.

on(Press) {
   perso.zoomAvant()
}

Au moment où vous relâchez le bouton de votre souris, vous pouvez constater que le grossissement ne s'arrête pas. Vous ne lui avez pas demandé, c'est donc normal. Voilà ce que vous devez ajouter afin que le grossissement s' interrompe lorsque vous relâchez le bouton de votre souris :

this.onMouseUp = function() {
   delete this.onEnterFrame;
};

Vous obtenez ainsi le script complet ci-dessous sur la première image clé de votre timeline.

MovieClip.prototype.plusGrand = function() {
   this.onEnterFrame = function() {
      this._xscale += 3;
      this._yscale += 3;
   };
   this.onMouseUp = function() {
      delete this.onEnterFrame;
   };
};

Exemple 3 :

Dans cet exemple, nous allons définir la méthode qui consiste à reproduire l'effet de gravité sur une occurrence.

Script placé sur l'image clé :

MovieClip.prototype.gravite = function(seuil, vitesse, rebond) {
   var coefy = 0;
   this._y=40
   this.onEnterFrame = function() {
      coefy += vitesse;
      this._y += coefy;
      if (this.hitTest(seuil)) {
         this._y = seuil._y;
         coefy *= -1;
         vitesse += rebond;
      }
      if (this._y>seuil._y) {
         delete this.onEnterFrame;
         this._y = seuil._y;
      }
   };
};

Script placé sur un bouton (ou à la suite du script ci-dessus dans l'image clé en retirant le gestionnaire on(press)) :

on (press) {
   balle.gravite(_root.sol, 0.1, 0.1);
   balle2.gravite(_root.sol, 0.9, 0.9);
   balle3.gravite(_root.sol, 0.9, 0.1);
   balle4.gravite(_root.sol, 0.1, 0.9);
}

Précisons que vous devez placer un clip sur la scène qui teste la collision avec le clip qui subit la gravité. Ce dernier doit être nommé (ex. sol).

Temporiser une animation

Il existe plusieurs techniques qui permettent de temporiser une animation mais commençons tout d'abord par expliquer la raison pour laquelle vous aurez parfois besoin de faire appel à une telle technique.

Que doit-on entendre par "temporiser une animation ?

Si vous souhaitez exécuter une ou plusieurs lignes d'instructions à intervalle régulier (ex. toutes les 5 secondes), vous devez faire appel à la fonction setInterval().

Si vous souhaitez exécuter une ou plusieurs lignes d'instructions durant un laps de temps ((ex. durant 30 secondes), vous devez faire appel à la fonction setInterval(). Vous pouvez aussi utiliser le gestionnaire onEnterFrame.

Certains développeurs utilisent la fonction getTimer() de Flash mais sa gestion est moins souple même si elle est plus simple.

onEnterFrame

L'utilisation de ce gestionnaire permet d'exécuter en boucle les instructions qu'il contient. Vous devez rattacher ce gestionnaire à la scène ou à l'occurrence d'un clip. La rapidité d'execution du code dépend de la cadence de l'animation. Si vous ne détruisez pas ce gestionnaire, l'execution se fera sans fin, même si vous changez d'image (ou d'image clé).

 

> Méthodologie N° 1: Utilisation du gestionnaire d'évènement onEnterFrame rattaché à la scène.
1. Placez le script ci-dessous sur une image clé de la timeline

_root.onEnterFrame = function() {
   aig._rotation += 5;
};

Dans l'exemple ci-dessus, l'occurrence d'un clip intitulée "aig" tourne sans fin de 5° à raison de 30 fois par secondes (tout dépend de la puissance de l'ordinateur qui lit le swf) car la cadence de l'animation est de 30 ips (30 fps).

Si vous souhaitez annuler (arrêter) l'execution de ce gestionnaire, vous devez utiliser la commande "delete". Placez alors ce script sur l'occurrence d'un bouton (ou ailleurs sans le gestionnaire on(press)).

on (press) {
   delete _root.onEnterFrame;
}

Remarque : Vous pouvez aussi rattacher ce gestionnaire à l'occurrence d'un clip ou à this, vous n'êtes pas obligés de faire référence à _root.

setInterval()

Le principe consiste à créer une fonction qui va être appelée par setInterval() à intervalle régulier (exprimé en millième de secondes).

L'utilisation de cette fonction est très simple à mettre en oeuvre, cependant, pour un contrôle total de cette technique de temporisation, il vous faudra certaines connaissances plus approfondies de la programmation en général.

> Méthodologie N° 1: Utilisation simplifiée de la fonction setInterval().
Placez le script ci-dessous sur une image clé de la timeline
1. Rédigez la fonction ci-dessous :

function grandir() {
   barre._xscale += 2;
}

2. Ajoutez à la suite de votre fonction ou dans un autre script, le code ci-dessous :

setInterval(grandir, 5000);

Dans l'exemple ci-dessus, la fonction grandir est appelée (exécutée) toutes les 5 secondes.

L 'inconvénient de cette méthode réside dans le fait que vous ne pouvez pas arrêter l'execution de cette fonction. Vous devez alors opter pour la méthode numéro 2.

> Méthodologie N° 2: Utilisation complète de la fonction setInterval().
Placez le script ci-dessous sur une image clé de la timeline
1. Rédigez la fonction ci-dessous :

function agrandir(occu) {
   if (occu._xscale<96) {
      occu._xscale += 2;
   } else {
      clearInterval(lancer);
      delete lancer
   }
}

2. Ajoutez à la suite de votre fonction ou dans un autre script, le code ci-dessous :

if (!lancer) {
lancer = setInterval(agrandir, 100, barre2);
}

Dans l'exemple ci-dessus, la fonction agrandir est appelée toutes les 10eme de secondes (1 seconde valant 1000). Elle contient un test qui arrêtera automatiquement son exécution bouclée grâce à clearInterval(). Cette dernière commande nécessite un paramètre ("lancer" dans notre exemple) qui est un identifiant associé à setInterval(). D'où l' association de ce "mot" à la fonction setInterval(). Afin de ne pas exécuter plusieurs fois la fonction setInterval() (au cas où cette ligne d'instruction serait placé dans un gestionnaire associé à un bouton), on doit tester son existence.

Remarque : Si vous deviez ajouter un paramètre à la fonction (comme dans la méthodologie N°2 avec "occu"), pour le préciser au moment de son appel avec la commande setInterval(), ajoutez le à la suite de l'intervalle.

function grandir(pas) {
   barre._xscale += pas;
}
setInterval(grandir, 5000,2);

 

Surveiller les actions liées au clavier et à la souris

Lorsque vous devez placer de l'interactivité au sein de vos animations, vous pouvez alors demander à l'utilisateur de contrôler le swf avec le clavier ou la souris. Plusieurs techniques sont possibles mais celle des listeners présente l'avantage de limiter l'activité du microprocesseur. Une structure if() dans un _root.onEnterFrame ralentit considérablement votre animation. Vous pouvez alors définir un listener (un objet d'écoute) en dehors du gestionnaire _root.onEnterFrame.

> Méthodologie : Surveiller si la touche "Flèche Droite" du clavier est enfoncée.
1. Placez le script ci-dessous sur une image clé de la timeline

ecouteur = new Object();
ecouteur.onKeyDown = function() {
   laTouche = Key.getCode();
   if (laTouche==39) {
   direction=1
}
Key.addListener(ecouteur);

Analysons ensemble ce script :

- Pour commencer, vous devez toujours choisir un nom d'instance de la classe Object(). Dans l'exemple ci-dessus nous avons choisi ecouteur mais nous aurions pu retenir mouchard, oeil, oreille, toto, titi, etc. N'importe quel mot peut convenir à partir du moment où il ne contient ni espace ni caractères accentués.
- Vous attribuez ensuite à ce nom d'instance un évènement (Tout dépend de l'objet que vous voulez surveiller (le clavier (Key), la souris (Mouse), la scène (Stage)). Vous pouvez choisir ... à suivre.

Dans l'exemple ci-dessous, lorsqu'une touche du clavier est enfoncée, un test vérifie s'il s'agit de l'une des 4 touches fléchées.

ecouteur = new Object();
ecouteur.onKeyDown = function() {
   laTouche = Key.getCode();
   switch (laTouche) {
   case 37 :
      bete.pasH = -1;
      bete.pasV = 0;
      break;
   case 38 :
      bete.pasH = 0;
      bete.pasV = -1;
      break;
   case 39 :
      bete.pasH = 1;
      bete.pasV = 0;
      break;
   case 40 :
      bete.pasH = 0;
      bete.pasV = 1;
}
ecouteur.onKeyUp = function() {
   bete.boost = 1;
};
Key.addListener(ecouteur);