Une question revient souvent. Comment insérer une pause dans un script ? La méthode la plus courante et la plus simple à mon avis d'utiliser setInterval.


Principe :
setInterval s'utilise avec une fonction. Si vous n'avez pas de notion sur les fonctions, je vous recommande de lire mon précédent article à ce sujet
Le principe est simple : vous définissez une série d'action que vous incorporez dans une fonction.
Cette fonction va être appelée par la méthode setInterval, à un interval régulier que vous définissez.

Syntaxe :
function nom_fonction(paramètres){
     commandes;
}

setInterval (nom_fonction, temporisation);

nom_fonction : le nom de votre fonction
paramètres : optionnel, permet d'inclure une variable qui sera définie à l'appel de la fonction
commandes : toutes les lignes de commandes que vous voulez que votre fonction execute
temporisation : l'interval d'execution entre vos fonctions en millisecondes.

Attention : avec cette méthode, vous ne pouvez pas arrêter la fonction.

Exemple :
Nous allons créer un compteur qui va s'incrémenter toutes les secondes.
Sur votre scène, créez un champ de texte dynamique et nommé le "compteur".
Sur la première image de votre animation, placez ce script :

compteur=0; // On initialise le compteur
function compte(){
   compteur+=1; // le fonction incrémente le compteur de 1
}

setInterval (compte, 1000);

setInterval avec arrêt de la fonction :

Pour arrêter un setInterval, il faut utiliser, par exemple dans la fonction qui est appelée, la commande clearInterval.
On va définir ici la fonction setInterval comme variable.

Syntaxe :
function nom_fonction(paramètres){
      commandes;
      if (condition pour continuer la boucle) {
        clearInterval (nom_interval)
      }
}

var nom interval = setInterval (nom_fonction, temporisation);

Exemple :
Nous reprenons ici notre exemple de compteur. Si le compteur arrive au chiffre 100, nous arrêtons la fonction setInterval

compte=0;
function compteur(){
  compte +=1;
  if (compte == 100){ // condition d'arrêt du setInterval
     clearInterval (mon_interval);
  }
}

var mon_interval = setInterval (compteur, 1000);

Voilà, n'hésitez pas à poser vos questions ou à signaler des points qui nécessitent plus d'explications.

Principe :

La fonction est un des outils indispensable du petit programmateur. Il vous est peut-être arrivé de devoir utiliser à différents endroits de votre animation les mêmes lignes de codes. Dans ce cas, vous utilisez le copiez/collez. Avec les fonctions, vous définissez une fois pour le code que vous devez appeler, vous le nommer, et vous le réutilisez partout en appelant le nom de votre fonction.

Voici la syntaxe de création d'une fonction :
Le mieux est de placer vos fonctions sur la première image de votre animation sur un calque dédié.

function nom_fonction(paramètres){
     commandes;
}

nom_fonction : le nom de votre fonction
paramètres : optionnel, permet d'inclure une variable qui sera définie à l'appel de la fonction
commandes : toutes les lignes de commandes que vous voulez que votre fonction execute

Voici la syntaxe d'appel d'une fonction :

nom_fonction(paramètres);

Exemple sans passage de paramétres :

Création de la fonction :

function ma_fonction(){
  trace(mavariable1);
  trace(mavariable1);
  trace(mavariable1);
  trace(mavariable1);
}

 Appel de la fonction :

ma_fonction();

Exemple avec passage de paramétres :

Création de la fonction :
Cette fonction dépalce en x et en y l'occurence bonhomme sur la scène du nombre de pixel définit par la variable "pas".

function ma_fonction(pas){
  bonhomme._x+=pas;
  bonhomme._y+=pas;
}

 Appel de la fonction :
La variable "pas" prend ici la valeur 5.

ma_fonction(5);

Voilà, n'hésitez pas à poser vos questions ou à signaler des points qui nécessitent plus d'explications.

Principe

Les boucles sont faites pour répeter plusieurs fois une action similaire. Elles permettent de gagner beaucoup de temps en développement, mais aussi d'alléger énormément son code. Elles sont utilisées dans tous les langages de programmation. En effet, c'est un outil très puisssant, quand vous l'aurez essayé, vous ne pourrez plus vous en passer. En flash, vous pouvez utiliser une boucle pour répeter un maximum de 200.000 opérations.

Dans un script, lorque la boucle est lue, elle continue à tourner sur elle même jusqu'à la condition de sortie. Le script se trouvant sous la boucle est alors lu.

Exemple :
Voici un exemple simple qui va vous permettre de comprendre l'efficacité d'une boucle. Le script peut vous sembler compliqué, ne vous en faites pas, il est juste là pour vous montrer qu'en 3 ligne, on peut éviter d'en écrire 100.
Imaginons que vous avez sur votre scène 100 champs de texte dynamiques, nommés  chacun champ1, champ2, champ3, ... , champ 100, auquels vous voulez donner la valeur 1.
Si vous n'utilisez pas de boucle, vous devez faire ceci, soit 100 lignes de codes !

champ1=1;
champ2=1;
champ3=1;
....
champ100=1;

Avec une boucle, votre code se résumerait à ceci :

for (i=1; i<=100 ; i++){
    this.["champ"+i]=1;
}

Plus simple, non ?

Les différents types de boucles :

La boucle "for" :
C'est la boucle la plus utilisée, celle qu'on trouve dans tous les langages de prog. Elle est disponibles dans Flash depuis la version 5. L'aide Flash défini son utilité comme ceci : "Pour répéter une action en utilsant un compteur intégré". Pour faire simple, votre boucle s'executera autant de fois que vous lui demanderez , en suivant un nombre de départ et un nombre d'arrivé.
Voici sa synthaxe :

for (init; condition; mode); {
   instructions;
}


Init : valeur de départ de la boucle. Cette valeur peut être un nombre ou une variable (numérique). La boucle commencera à compter ses passages à partir de cette valeur.
condition : Valeur d'arrêt de la boucle. Quand la boucle atteint cette valeur, elle arrête de fonctionner.
Mode : le pas d'évolution de notre compteur à chaque passage de la boucle. Cela peut être une incrémentation ou une décrémentation..

Exemple :
Cet exemple, (peu réaliste mais très simple) permet à chaque passage de la boucle une incrémentation de la variable "test" :

test =0; // on définit la variable test à 0
for ( i=0, i<100; i++){
 test+=1; // on incrémente de 1 la variable test
}

La boucle for ...in

La boucle for ... in est utilisée uniquement avec les array (où variables inclues dans un tableau).
La boucle se fera tant qu'il ya des objets dans le tableau.

exemple :

monArray = {"fruit","légume","viande"}; // on définit ici un tableau qui comprend trois valeures
for (i in monArray){
   trace (i); // Cette commande affichera en trace toutes les variables contenu dans le tableau
}

La boucle while

La boucle est while est gérée par une conditon. Tant que la condition est vraie, elle continue à tourner.
Elle prend la forme :
while (conditions){
    instruction;
}

exemple :

i=0;
while (i<100){ // temps que i est inférieur à 100
i+=1; // incrémentation de i
}

La boucle do...while
Cette boucle est identique à la boucle while, la commande est simplement organisée différemment. Le test est effectué en fin de boucle, donc, elle fera au moins un tour (contrairement à la boucle while où le test est effectué en début de structure).

Elle prend la forme :
do { instruction;
}
while (conditions);

exemple :

do { i+=1;//incrémentation de i
}
while (i<100);// temps que i est inférieur à 100

Voilà, n'hésitez pas à poser vos questions ou à signaler des points qui nécessitent plus d'explications.

Ce petit article est un résumé de la technote de Macromedia disponible ici

Nombre de frames maximum d'une animation : 16.000
Boucles : maximum de 200.000 opérations
Int. et Random : 2 milliards de chiffres
Application avec des composants AS2 : maximum de 125 composants recommandés
Une variable créée en AS2 prend au minimum 12 bytes

En résumé, il y a quand même de la marge non ;-)

Connaissez-vous les équations de Robert Penner ?
Elles vous permettent de réaliser des effets d'élasticité, tout en action script. Exemples, codes sources, AS2, AS1, tout y est !
Vous trouverez tout cela ici

Dans une animation, vous avez peut-être déjà voulu changer votre curseur par un autre. Cette méthode très simple va vous permettre de réaliser cela très rapidement. Elle a aussi l'avantage par rapport à une autre méthode ou l'on emploi le "start drag" de ne pas rentrer en conflit avec les composants qui utilisent la méthode "drag".

Commencer par créer un nouveau clip dans lequel vous placerez une image ou dessinerez votre nouveau curseur.  Placez une occurence de clip sur la scène et nommez là (ici, je l'ai appelé curseur)

Sur la première image de votre time-line, ajoutez ce code :

// on cache le curseur actuel de la souris
Mouse.hide();

// On crée une fonction nommée "suiveur" qui va faire suivre au clip "curseur" les mouvements de la souris
suiveur=function()
{
curseur._x=_root._xmouse; // curseur suit la position en abscisses de la souris
curseur._y=_root._ymouse;// curseur suit la position en ordonnée de la souris
}

// set interval va appeler toutes les 5 millisecondes la fonction suiveur pour raffrachir la position de la souris. 84 est ici proposé pour un framerate de 12fps
setInterval (suiveur,84);

Si vous souhaitez faire réapparaitre le curseur normal et faire disparraitre votre curseur, placez ce code :

On affiche le curseur normal :
Mouse.show;
On fait disparaite notre curseur :
_root.curseur._visible=false;

Et si vous voulez faire de nouveau apparaitre votre curseur :

On masque le curseur normal :
Mouse.hide;
On fait apparaitre notre curseur :
_root.curseur._visible=true;