import fr.jussieu.script.*;

class Point
{
      int abs, ord;
      char nom;

      // Contructeurs. Remarquer que les suites des types des paramètres
      // sont toutes distinctes 2 à 2 (suite vide pour C1, (char) pour C2,
      // (int, int) pour C3, etc.).
      
      /**
       * Constructeur 1 : crée un point dont l'abscisse et l'ordonnée sont
       * initialisées à 0 (par défaut) et dont le nom est initialisé à 'a'.
       */
      Point()
      {
         nom = 'a';
      }

      /**
       * Constructeur 2 : crée un point dont l'abscisse et l'ordonnée
       * sont initialisées à 0 (par défaut) et dont le nom est donné.
       * @param c le nom du point à créér.
       */
      Point(char c)
      {
         nom = c;
      }

      /**
       * Constructeur 3 : crée un point dont l'abscisse et l'ordonnée sont
       * données et dont le nom est initialisé à 'a'.
       * @param x l'abscisse du point à créér.
       * @param y l'ordonnée du point à créér.
       */
      Point(int x, int y)
      {
         abs = x;
         ord = y;
      }
      
      /**
       * Constructeur 4 : crée un point dont l'abscisse, l'ordonnée et le
       * nom sont donnés.
       * @param x l'abscisse du point à créér.
       * @param y l'ordonnée du point à créér.
       * @param c le nom du point à créér.
       */
      Point(int x, int y, char c)
      {
         abs = x;
         ord = y;
         nom = c;
      }
      
      /**
       * Constructeur 5 (hors polycopié) : crée un point dont l'abscisse et
       * le nom sont donnés.
       * @param x l'abscisse du point à créér.
       * @param c le nom du point à créér.
       */
      Point(int x, char c)
      {
         abs = x;
         nom = c;
      }

      /**
       * Constructeur 6 (hors polycopié) : crée un point dont l'ordonnée et
       * le nom sont donnés.
       * @param y l'ordonnée du point à créér.
       * @param c le nom du point à créér.
       */
      // Observer que pour avoir une suite de types différents du
      // précédent constructeur, on donne le nom d'abord et ensuite
      // seulement l'ordonnée Ainsi, la suite de types est (char, int), au
      // lieu de (int, char) dans le constructeur précédent. Cet exemple
      // est peu pratique à utiliser et artificiel, il est ici uniquement ici à
      // titre de test.
      Point(char c, int y)
      {
         ord = y;
         nom = c;
      }

      /**
       * Constructeur 7, exercice page 20, polycopié 4 : crée un point dont
       * les caractéristiques sont données par un point déjà existant.
       * @param a le point que l'on veut dupliquer par le constructeur.
       */
      Point(Point a)
      {
         abs = a.abs;
         ord = a.ord;
         nom = a.nom;
      }
}

/**
 *  Exercice 1, page 24, polycopié 4.
 */
class Cercle
{
      Point centre;
      int rayon;

      Cercle(Point p)
      {
         centre = new Point(p);
      }
}

/**
 * Exercice 2, page 24, polycopié 4.
 */
class Segment
{
      Point debut;
      Point fin;

      Segment(int x0, int y0, char c0, int x1, int y1, char c1)
      {
         debut = new Point (x0, y0, c0);
         fin = new Point (x1, y1, c1);
      }      
}

/**
 * Exercices page 27, polycopié 4.
 */
class Test
{
      static void dessinerCourbe (Point [] t)
      {
         for (int i=0; i <= t.length-2; i++)
            Deug.drawLine(t[i].abs, t[i].ord, t[i+1].abs, t[i+1].ord);
      }

      static Point lirePoint ()
      {
         int x, y;
         char c;
         Deug.print("\tEntrez l'abscisse du point ");
         x = Deug.readInt();

         Deug.print("\tEntrez l'ordonnée du point ");
         y = Deug.readInt();

         Deug.print("\tEntrez le nom du point ");
         c = Deug.readChar();
         Deug.readChar(); // Élimination du \n

         return new Point(x,y,c);
      }

      // Comparer cette méthode avec readTableauInt écrite lors du TD du
      // 07/12/04, permettant la saisie d'un tableau d'entiers.
      static Point [] lireCourbe(int n)
      {
         Point [] t = new Point [n];

         for (int i = 0; i < n; i++)
         {
            Deug.println("Point " + i);
            t[i] = lirePoint();
         }
         return t;      
      }
      
      public static void main (String [] args) 
      {
         int n;
         do
         {
            Deug.print("Entrez le nombre de points (positif) : ");
            n = Deug.readInt();
         }
         while (n <= 0);
         
         Deug.println("Coordonnees entre 0 et 499 SVP\n");
         Point [] t = lireCourbe(n);
         Deug.startDrawings(500,500);
         dessinerCourbe(t);
         // Ligne suivante commentée pour voir le résultat.
         // Deug.stopDrawings();
      }
}