La classe Paysage

La classe Paysage représente le cadre dans lequel les Ovnis vont se déplacer. Elle aura à gérer l'affichage d'un paysage (photo) et des Ovnis en utilisant un double buffering. Elle gèrera aussi le processus de déplacement des Ovnis. Elle permettra enfin d'ajouter les Ovnis choisis par l'applet qui la contiendra.

Déclarations et constructeur

La classe Paysage sera une classe dérivée de la classe Canvas; elle implémente l'inteface Runnable pour gérer le processus de déplacement.

Les variables suivantes seront nécessaires :

• image de fond
• tableau contenant les Ovnis
• nombre d'Ovnis gérés
• image mémoire pour le double buffering
• contexte graphique associé à l'image mémoire
• processus de déplacement des Ovnis

Ceci nous donne le code suivant:

    import java.awt.*;
    import java.applet.*;
 
    public class Paysage extends Canvas implements Runnable {
 
     int maxObjs=500;      //nombre maxi d'Ovnis       
     int nbObjs=0;         //nombre d'Ovnis utilisés
     Ovni[] table;         //tableau des Ovnis 
     Image photo;          //image de fond
     Image mem;            //image mémoire
     Graphics gmem;        //contexte graphique de mem
     int hauteur, largeur; //dimensions
     private Thread processus=null;
     int speed=50;         //pause entre deux déplacements
  
     Paysage(Image img) {
      table=new Ovni[maxObjs];
      mem=null;
      photo=img;
     }

Le constructeur reçoit l'image de fond en paramètre,crée le tableau contenant les Ovnis et initialise la variable mem à null. Celle-ci sera initialisée avec les autres variables dans la méthode paint, lors du premier affichage.

Gestion du processus de déplacement

Nous aurons besoin de méthodes de démarrage et d'arrêt du processus, puis nous écrirons la méthode run qui gère les déplacements.

     public void startAnim() {
      if (processus==null) {
       processus=new Thread(this);
       processus.start();
      }
     }
 
     public void stopAnim() {
      processus=null;
     }
 
     public void run() {
      while (processus!=null) {
       //modifications du dessin
       repaint();
       try {
	if (mem!=null) 
	 for (int i=0; i<nbObjs; i++) table[i].bouge(largeur, hauteur);    
	processus.sleep(speed);
       } catch (InterruptedException e){}
      }
      processus=null;
     }

Le déplacement se fait en utilisant la méthode bouge des Ovnis.

Dessin

Le dessin se fera dans l'image mémoire qui sera ensuite transférée au contexte graphique fourni par la méthode paint. Lors du premier affichage, une initialisation des variables est nécessaire. Enfin nous redéfinissons la méthode update pour éviter les clignotements dus à l'effacement.

On obtient le code suivant :

     public void paint(Graphics g) {
      //initialisation des variables d'affichage
      if (mem==null) {
       largeur=getSize().width;
       hauteur=getSize().height;
       mem=createImage(largeur,hauteur);
       gmem=mem.getGraphics();
      }
      //afficher le fond
      gmem.drawImage(photo,0,0,this);
      //afficher les Ovnis
      for (int i=0; i<nbObjs; i++) table[i].dessine(gmem);
      //transférer l'image mémoire
      g.drawImage(mem,0,0,this);
     }
 
     public void update(Graphics g) {
     //supprimer l'effacement
      paint(g);
     }

Gestion des Ovnis

Nous ajouterons enfin deux méthodes permettant de gérer le tableau contenant les Ovnis. La méthode resetObjs enlève tous les objets existants. La méthode ajouteObjet permet d'ajouter un Ovni.

Ceci nous donne :

     public void ajouteObjet(Ovni obj) {
      table[nbObjs]=obj;
      //il y a un objet de plus
      nbObjs++;
     }
 
     public void resetObjs() {
      //on enlève tous les objets
      nbObjs=0;
     }

Suite...

Le paysage est prêt à fonctionner. Il nous reste à l'inclure dans l'applet qui contiendra aussi les boutons de choix des Ovnis.