====== Animation ======

Un objet Animation est un objet graphique très complet : il peut prendre plusieurs apparences, se déplacer, détecter des collisions, etc.

===== Créer un objet Animation =====

  * Créer un objet Animation :

<code declick>
uneAnimation = new Animation()
</code>

  * Créer un objet Animation en chargeant une image depuis un fichier :

<code declick>
uneAnimation = new Animation("fichier.png")
</code>

{{information.png}} L'image chargée est affichée directement

===== Actions =====

==== Position et taille ====

  * Placer l’Animation :

<code declick>
uneAnimation.définirPosition(300,200)
uneAnimation.définirPositionCentre(300,200)
</code>

/*
 *uneAnimation.définirCoordonnéeX(300)
 *uneAnimation.définirCoordonnéeY(200)
 */


  * Récupérer les coordonnées de l’Animation :
<code declick>
uneAnimation.récupérerCoordonnéeX()
uneAnimation.récupérerCoordonnéeY()
</code>
/*
 *  * Changer la taille de l’Animation :
 *
 *uneAnimation.définirHauteur(300);
 *uneAnimation.définirLargeur(400);
 *
 *  * Récupérer la taille de l'Animation :
 *
 *uneAnimation.récupérerHauteur();
 *uneAnimation.récupérerLargeur();
 */

  * Montrer / Cacher l’animation :

<code declick>
uneAnimation.montrer()
uneAnimation.cacher()
</code>

==== Gestion des images ====

  * Ajouter une image :

<code declick>
uneAnimation.ajouterImage("fichier.png")
</code>

  * Ajouter une image en l'assignant à un ensemble d'images :

<code declick>
uneAnimation.ajouterImage("fichier.png", "ensemble")
</code>

  * Supprimer une des images :

<code declick>
uneAnimation.supprimerImage("fichier.png")
</code>

  * Supprimer les images d'un ensemble d'images :

<code declick>
uneAnimation.supprimerImages("ensemble")
</code>


  * Afficher une des images :

<code declick>
uneAnimation.afficherImage("fichier.png")
</code>

{{information.png}} L’objet Animation prend automatiquement la taille de l’image qu’il affiche.

  * Afficher l’image suivante / l'image précédente :

<code declick>
uneAnimation.afficherImageSuivante()
uneAnimation.afficherImagePrécédente()
</code>

  * Afficher l’image suivante / l'image précédente d'un ensemble d'images :

<code declick>
uneAnimation.afficherImageSuivante("ensemble")
uneAnimation.afficherImagePrécédente("ensemble")
</code>

/*
 *  * << Boucler >> les images, c'est à dire qu'un appel à afficherImageSuivante alors que l'objet affiche la  
 * dernière image provoquera l'affichage de la première image : 
 *
 *uneAnimation.bouclerImages(true)
 *
 *  * Ne pas << boucler >> les images :
 *
 *uneAnimation.bouclerImages(false)
 */

/*
 *
 *  * Récupérer le nom de l'image affichée : 
 *
 *uneAnimation.récupérerNomImage()
 *
 */

  * Rendre une couleur	transparente :

<code declick>
uneAnimation.rendreTransparent("couleur")
</code>

{{ :objets:couleurs.png |}}

/*
 *
 *  * Définir un niveau de transparence pour toutes les couleurs :
 *
 *uneAnimation.définirTransparence(50)
 *
 * {{:objet:information.png |}}le niveau de transparence est un chiffre compris entre 0 (visible) 
 * et 100 (invisible)
 */

==== Mouvements ====

  * Faire bouger l’Animation :

<code declick>
uneAnimation.avancer(50)
uneAnimation.reculer(50)
uneAnimation.monter(50)
uneAnimation.descendre(50)
uneAnimation.allerA(0,0)
</code>

  * Faire bouger l’Animation sans s’arrêter :	

<code declick>
uneAnimation.avancer()
uneAnimation.reculer()
uneAnimation.monter()
uneAnimation.descendre()
</code>

ou

<code declick>
uneAnimation.avancerToujours()
uneAnimation.reculerToujours()
uneAnimation.monterToujours()
uneAnimation.descendreToujours()
</code>

  * Arrêter l’Animation :

<code declick>
uneAnimation.arrêter()
</code>

/*
 *  * Suspendre le mouvement de l’Animation :
 *
 *uneAnimation.suspendre();
 *
 *  * Reprendre le mouvement de l’Animation :
 *
 *uneAnimation.reprendre();
 */

  * Changer la vitesse :

<code declick>
uneAnimation.définirVitesse(100)
</code>

{{information.png}} la vitesse par défaut est de 100. Une vitesse de 0 rend l'Animation immobile.

/*
 *  * Suivre la souris :
 *
 *uneAnimation.suivreSouris(true)
 *
 *  * Ne pas suivre la souris :
 *
 *uneAnimation.suivreSouris(false)
 *
 *{{:objet:information.png |}}lorsqu'une Animation suit la souris, il suffit de cliquer dessus pour la déplacer.
 */

/*
 *  * Récupérer la direction de l’objet Animation :
 *
 *uneAnimation.récupérerDirection()
 *
 *{{:objet:information.png |}}Cette action renvoie un texte pouvant être : << haut >>, << bas >>, << droite >>, 
 *<< gauche >>, << haut gauche >>, << haut droite >>, << bas gauche >>, << bas droite >>.
 *
 */

  * Supprimer l’objet Animation :

<code declick>
uneAnimation.supprimer()
</code>

/*
=== Rotations ===

  * tourner
{{ :creer:sans_titre.gif?nolink |}}
*/


===== Gestion des événements =====

/*
 *
 *
 * Un objet Animation peut surveiller un certain nombre d'événements qui peuvent se produire : 
 *
 *  * Un **changement d'images**
 *  * Un **clic** de l'utilisateur sur l'objet Animation 
 *  * Un **arrêt de clic** de l'utilisateur sur l'objet Animation 
 *  * Un **mouvement** de l'objet Animation
 *  * Un **changement de direction** de l'objet
 *  * L'**arrêt** de l'objet
 *  * La **collision** avec d'autres objets Animation, [[Suiveur]] ou [[Promeneur]]
 *  * La **sortie de l'écran** de l'objet Animation
 */

Un objet Animation peut surveiller les collisions qui se produisent avec d'autre objets Animation, [[Promeneur]] ou [[Héros]].


==== Exécuter des commandes ====

  * Pour chaque collision, on peut dire à l'objet Animation d'exécuter des commandes :

<code declick>
uneAnimation.siCollision("commande")
</code>

  * On peut dire à l'objet Animation de n'exécuter des commandes que s'il rencontre un objet particulier, grâce à l'action :

<code declick>
uneAnimation.siCollision("commande", objet)
</code>
ou 
<code declick>
uneAnimation.siCollisionAvec(objet, "commande")
</code>

  * On peut également dire à l'objet Animation de n'exécuter des commandes que s'il rencontre une catégorie d'Animations : 

<code declick>
uneAnimation.siCollision("commande", "catégorie")
</code>
ou 
<code declick>
uneAnimation.siCollisionAvec("catégorie", "commande")
</code>

  * Définir la catégorie d'une Animation : 

<code declick>
uneAnimation.définirCatégorie("catégorie")
</code>

Si on fait plusieurs fois appel à une des actions ci-dessus, les commandes s'ajoutent. Par exemple :

<code declick>
uneAnimation.siCollision("commande1")
uneAnimation.siCollision("commande2")
</code>

L'objet Animation exécutera << commande1 >> puis << commande2 >> dès qu'il détecte une collision.

  * Désactiver / Réactiver la détection des collisions : 

<code declick>
uneAnimation.surveillerCollisions(false)
uneAnimation.surveillerCollisions(true)
</code>

{{information.png}} par défaut, la détection des collisions est activée.

/*
 *
 *==== Supprimer des commandes ====
 *
 *Pour dire à un objet Animation d'annuler l'exécution de commandes relatives à un événement, on utilise l'action :
 *
*uneAnimation.annulerCommandeEvénement("événement")
 *
 *<< événement >> peut être égal à :
 *
 *  * << changementImage >>
 *  * << clic >>
 *  * << arrêtClic >>
 *  * << mouvement >>
 *  * << changementDirection >>
 *  * << arrêt >>
 *  * << collision >>
 *  * << horsEcran >>
 *
 *{{:objet:information.png |}} si on annule les commandes associées à l'événement << collision >>, cela supprime
 *les commandes enregistrées avec les actions siCollision et siCollisionAvec.
 *
 */
/*
 *==== Afficher les commandes ====
 *
 *Par défaut, un objet Animation affiche dans la console les commandes qu'il exécute quand un événement se
 *produit. Ce comportement peut être modifié : 
 *
 *  * Afficher les commandes dans la console :
 *
*uneAnimation.afficherCommandes(true)
 *
 *  * Ne pas afficher les commandes dans la console : 
 *
*uneAnimation.afficherCommandes(false)
 */
/*==== Les témoins ====
 *
 *Dans certains cas, on peut vouloir récupérer des informations sur les événements qui se sont produits. Pour 
 *cela, on peut utiliser des objets [[Témoin]]. Il suffit pour cela de les passer en paramètre des actions d'ajout 
 *de commande : 
 *
 *  unTémoin = new Témoin();
*uneAnimation.siChangementImage("commande", unTémoin);
*uneAnimation.siClic("commande", unTémoin);
*uneAnimation.siMouvement("commande", unTémoin);
*uneAnimation.siChangementDirection("commande", unTémoin);
*uneAnimation.siArrêt("commande", unTémoin);
*uneAnimation.siCollision("commande", unTémoin);
*uneAnimation.siCollisionAvec(objet, "commande", unTémoin);
*uneAnimation.siCollisionAvec(liste, "commande", unTémoin);
*uneAnimation.siHorsEcran("commande", unTémoin);
 *
 *Pour les événements de Collision, de Changement de direction ou de Changement d'image, on peut aussi utiliser
 *des objets [[TémoinCollision]], [[TémoinChangementDirection]] et [[TémoinChangementImage]].
 *
 *==== Témoins embarqués ====
 *
 *Les objets Animation contiennent eux-mêmes un objet [[TémoinCollision]] et un [[TémoinChangementDirection]], ce 
 *qui permet d'accéder à des informations sur une collision ou un changement de direction ayant eu lieu.
 *
 *  * Récupérer l'objet ayant provoqué une collision : 
 *
*uneAnimation.récupérerObjetRencontré()
 *
 *  * Récupérer les coordonnées de la collision :
 *
*uneAnimation.récupérerCoordonnéeCollisionX()
*uneAnimation.récupérerCoordonnéeCollisionY()
 *
 *  * Récupérer la direction précédente, en cas de changement de direction :
 *
*uneAnimation.récupérerDirectionPrécédente()
 *
 *===== Zone de collision =====
 *
 *Pour détecter les collisions, un objet Animation se base sur une zone de collision : seuls les objets croisant 
 *cette zone seront détectés. Par défaut, cette zone a la même taille que l'objet, mais elle peut être modifiée.
 *
 *  * Définir une zone de collision à partir de marges :
 *
*uneAnimation.définirMarges(5,10,20,30);
 *
 *La zone de collision sera un rectangle dont le bord haut sera à 5 pixels du haut de l'image, le bord bas sera à  
 *10 pixels du bas de l'objet, le bord gauche à 20 pixels de la gauche de l'objet, le bord droit à 30 pixels à  
 *droite de l'objet.
 *
 *  * Afficher les marges : 
 *
*uneAnimation.afficherMarges(true);
 *
 *  * Cacher les marges : 
 *
*uneAnimation.afficherMarges(false);
 *
 *  * Définir une zone de collision rectangulaire : 
 *
*uneAnimation.définirRectangleCollision(0,0,100,200)
 *
 *La zone de collision sera formée par un rectangle dont le sommet est situé au point de coordonnées (0,0), dont  
 *la largeur est de 100 pixels, et la hauteur de 200 pixels. Les coordonnées du sommet sont exprimées dans le 
 *repère de l'objet : (0,0) correspond au coin en haut à gauche de l'objet.
 *
 *  * Définir une zone de collision elliptique : 
 *
*uneAnimation.définirEllipseCollision(150,250,100,200)
 *
 *La zone de collision sera formée par une ellipse dont le centre est situé au point de coordonnées (150,250), 
 *dont la largeur est de 100 pixels, et la hauteur de 200 pixels. Les coordonnées du centre sont exprimées dans le 
 *repère de l'objet : (0,0) correspond au coin en haut à gauche de l'objet.
 *
 *  * Afficher la zone de collision :
 *
*uneAnimation.afficherZoneCollision(true)
 *
 *{{:objet:information.png |}}Cette action est équivalente à **uneAnimation.afficherMarges(true)**.
 *
 *  * Cacher la zone de collision :
 *
*uneAnimation.afficherZoneCollision(false)
 *
 *{{:objet:information.png |}}Cette action est équivalente à **uneAnimation.afficherMarges(false)**.
 *
 * * Récupérer la liste des objets ([[Animation]], [[Suiveur]] ou [[Promeneur]]) présents dans la zone de 
 *collision :
 *
*uneAnimation.récupérerObjetsChevauchés(uneListe)
 *
 *Cette action prend en paramètre un objet [[Liste]] qui va être rempli avec la liste des objets détectés.
 */