420-KBB-LG – Programmation orientée objet avancée

// ...
// remplir le catalogue
const char SYMBOLE_MÉTAL = '%';
Catalogue.Get.Associer(SYMBOLE_MÉTAL, Catégorie.Métal);
// préparer la surface d'affichage
const int HAUTEUR = 10,
          LARGEUR = 20;
Surface surf = new(HAUTEUR, LARGEUR);
// préparer le cadre de la surface
Cadre cadre = new(HAUTEUR, LARGEUR, ConsoleColor.Cyan);

// préparer la zone de messagerie
Messagerie messagerie = new(new(0, HAUTEUR));

// positionner Wallyd
Point2D centre = new(3, 3);
Robot wallyd = new("Wallyd", centre);
wallyd.Équiper(new DétecteurMétal(wallyd, 1.0f));
surf.Ajouter(wallyd);

// placer les déchets sur la surface
const int NB_DÉCHETS = 3;
Random dé = new();
List<Déchet> déchets = new();
var libres = surf.TrouverSi
(
   cadre.Exclure,
   c => c == default || c == ' '
);
if (libres.Count < NB_DÉCHETS)
   throw new SurfacePleineException();
for (int i = 0; i != NB_DÉCHETS; ++i)
{
   int n = dé.Next(libres.Count);
   déchets.Add(new(SYMBOLE_MÉTAL, Catégorie.Métal, libres[n]));
   libres.RemoveAt(n);
}
surf.Ajouter(déchets.ToArray());

while (surf.TrouverSi(c => c == SYMBOLE_MÉTAL).Count > 0)
{
   bool trouvé = false;
   do
   {
      PipelineAffichage pipeline = new();
      pipeline.Ajouter(Appliquer(cadre));
      pipeline.Appliquer
      (
         GénérerHalo(wallyd.Zone, surf.Dupliquer())
      );
      var pts = wallyd.Détecter(surf, Catégorie.Métal);
      if (pts.Count > 0)
      {
         trouvé = true;
         if (pts[0] == wallyd.Pos)
         {
            messagerie.Effacer();
            messagerie.Afficher
            (
               $"Déchet collecté à la position {pts[0]}"
            );
         }
         else
         {
            messagerie.Afficher
            (
               $"Trouvé {pts.Count} déchet(s)",
               $"Déplacement vers {pts[0]}"
            );
            surf.Retirer(wallyd);
            wallyd.DéplacerVers(pts[0]);
            surf.Ajouter(wallyd);
            wallyd.RéinitialiserPuissance();
         }
      }
      else
      {
         wallyd.AugmenterPuissance();
         messagerie.Effacer();
      }
      Thread.Sleep(500);
   }
   while (!trouvé);
   wallyd.RéinitialiserPuissance();
}
{
   PipelineAffichage pipeline = new();
   pipeline.Ajouter(Appliquer(cadre));
   pipeline.Appliquer
   (
      GénérerHalo(wallyd.Zone, surf.Dupliquer())
   );
}

static Mutable GénérerHalo(Cercle c, Mutable p)
{
   Mutable res = p.Dupliquer();
   for (int ligne = 0; ligne != res.Hauteur; ++ligne)
      for (int col = 0; col != res.Largeur; ++col)
      {
         Point2D pt = new(col, ligne);
         if (c.Centre.Distance(pt) <= c.Rayon)
            res[pt] = new(res[pt].Symbole, res[pt].Avant, ConsoleColor.Green);
      }
   return res;
}

static Func<Mutable, Mutable> Appliquer(Cadre p)
{
   return m =>
   {
      Mutable res = m.Dupliquer();
      for (int i = 0; i != p.Hauteur; ++i)
         for (int j = 0; j != p.Largeur; ++j)
         {
            var c = p[i, j];
            if (c.Symbole != default)
               res[i, j] = c;
         }
      return res;
   };
}
static Func<Mutable, Mutable> AppliquerSurface(Surface surf)
{
   return m =>
   {
      Mutable res = m.Dupliquer();
      for (int i = 0; i != surf.Hauteur; ++i)
         for (int j = 0; j != surf.Largeur; ++j)
         {
            var c = surf[i, j];
            if (c.Symbole != default)
               res[i, j] = c;
         }
      return res;
   };
}

class SurfacePleineException : Exception { }

// ...
      public List<Point2D> TrouverSi
      (
         Func<Point2D, bool> exclure,
         Func<char, bool> pred
      )
      {
         List<Point2D> pts = new();
         for (int ligne = 0; ligne != Hauteur; ++ligne)
            for (int col = 0; col != Largeur; ++col)
            {
               Point2D pt = new(col, ligne);
               if (!exclure(pt) && pred(this[pt].Symbole))
                  pts.Add(pt);
            }
         return pts;
      }
      public List<Point2D> TrouverSi(Func<char, bool> pred) =>
         TrouverSi(pt => false, pred);
// ...

// ...
   internal class PipelineAffichage
   {
      List<Func<Mutable, Mutable>> Transfos = new();
      public void Ajouter(Func<Mutable, Mutable> transfo) =>
         Transfos.Add(transfo);
      public IProjetable Appliquer(Point2D pos, Mutable p)
      {
         foreach (var transfo in Transfos)
            p = transfo(p);
         return Afficher(pos, p);
      }
      public IProjetable Appliquer(Mutable p) =>
         Appliquer(new(), p);
// ...

// ...
RobotInfo[] robotsInfo =
{
   new(null, 0, "Wallyd", ConsoleColor.Magenta, Catégorie.Métal),
   new(null, 1, "Bart", ConsoleColor.Blue, Catégorie.Plastique),
   new(null, 2, "Charles", ConsoleColor.Yellow, Catégorie.Organique),
   new(null, 3, "Lisa", ConsoleColor.Green, Catégorie.Nucléaire)
};

(char sym, Catégorie cat)[] symCatégorie =
{
    ('%', Catégorie.Métal),
    ('*', Catégorie.Plastique),
    ('&', Catégorie.Plastique),
    ('/', Catégorie.Organique),
    ('?', Catégorie.Nucléaire),
};
foreach (var symCat in symCatégorie)
    Catalogue.Get.Associer(symCat.sym, symCat.cat);

// préparer la surface d'affichage
const int HAUTEUR = 20,
          LARGEUR = 40;
Surface surf = new(HAUTEUR, LARGEUR);
// préparer le cadre de la surface
Cadre cadre = new(HAUTEUR, LARGEUR, ConsoleColor.Cyan);

// préparer la zone de messagerie
Messagerie messagerie = new(new(LARGEUR, 0), HAUTEUR);
// préparer la zone d'informations
Messagerie information = new(new(0, HAUTEUR), 2);


Random dé = new();
List<(Robot r, Catégorie c)> robots =
   CréerRobots(robotsInfo, dé, surf, cadre.Exclure);

// placer les déchets sur la surface
const int NB_DÉCHETS = 3;
List<Déchet> déchets =
   CréerPollution(symCatégorie, dé, NB_DÉCHETS, surf, cadre.Exclure);
surf.Ajouter(déchets.ToArray());

CanalComm canal = new(robotsInfo.Length);

PipelineAffichage pipe = new (surf, cadre, canal, messagerie, information);

pipe.Démarrer();

CancellationTokenSource src = new();
Thread[] cueilleurs =
   CréerCueilleurs
   (
      robotsInfo, surf, canal, messagerie, information, src.Token
   );
Thread lireTouche = new(() =>
{
   Console.ReadKey(true);
   src.Cancel();
});
lireTouche.Start();
foreach (var c in cueilleurs) c.Start();
foreach (var c in cueilleurs) c.Join();
lireTouche.Join();
pipe.Arrêter();

static List<(Robot robot, Catégorie cat)>
   CréerRobots(RobotInfo [] robotsInfo, Random dé, Surface surf, Func<Point2D, bool> exclure)
{
   List<(Robot r, Catégorie c)> robots = new();
   // Trouver les cases libres
   var libres = surf.TrouverSi(exclure,c => c == default || c == ' ');
   for (int r = 0; r < robotsInfo.Length; r++)
   {
      RobotInfo info = robotsInfo[r];
      int n = dé.Next(libres.Count);
      Robot robot =
         CréerRobot(info.nom, libres[n], info.couleur, info.catégorie);
      info.robot = robot;
      libres.RemoveAt(n);
   }
   return robots;
}
static Robot
   CréerRobot(string nom, Point2D pos, ConsoleColor couleur, Catégorie cat)
{
   Robot robot = new(nom, pos, couleur);
   robot.Équiper(new Détecteur(robot, 1, cat));
   return robot;
}

static List<Déchet>
   CréerPollution((char sym, Catégorie cat)[] symCatégorie, Random dé,
                  int nbDéchets,
                  Surface surf, Func<Point2D, bool> exclure)
{
   List<Déchet> déchets = new();
   var libres = surf.TrouverSi(exclure, c => c == default || c == ' ');
   if (libres.Count < nbDéchets * symCatégorie.Length)
      throw new SurfacePleineException();
   foreach (var symCat in symCatégorie)
   {
      for (int d = 0; d != nbDéchets; ++d)
      {
         int n = dé.Next(libres.Count);
         déchets.Add(new(symCat.sym, symCat.cat, libres[n]));
         libres.RemoveAt(n);
      }
   }
   return déchets;
}

static Thread[] CréerCueilleurs
   (RobotInfo[] robotsInfo, Surface surf, CanalComm canal,
    Messagerie messagerie, Messagerie information, CancellationToken jeton)
{
   Dictionary<char, int> collectés = new();
   var cueilleurs = new Thread[robotsInfo.Length];
   for (int r = 0; r < robotsInfo.Length; r++)
   {
      var (robot, noPort, _, _, cat) = robotsInfo[r];
      var catalogue = Catalogue.Get;
      cueilleurs[r] = new (() =>
      {
         // tant qu'il reste des déchets à ramasser
         while (!jeton.IsCancellationRequested &&
                surf.TrouverSi(c => catalogue.Est(c, cat)).Count > 0)
         {
            bool trouvé = false;
            // Trouver et ramasser le déchet
            do
            {
               canal.PublierSur(noPort, new(robot.Zone, robot.Couleur, robot.Symbole));
               var pts = robot.Détecter(surf, cat);
               if (pts.Count > 0)
               {
                  trouvé = true;
                  if (pts[0] == robot.Position)
                  {
                     char c = surf[pts[0]].Symbole;
                     lock (collectés)
                        if (collectés.ContainsKey(c))
                           collectés[c]++;
                        else
                           collectés.Add(c, 1);
                     var pos = robot.Position;
                     messagerie.Ajouter
                     (
                        robot.Couleur,
                        $"Déchet collecté à la position {pos}"
                     );
                     surf.Retirer(pos);
                  }
                  else
                  {
                     messagerie.Ajouter
                     (
                        robot.Couleur,
                        $"Trouvé {pts.Count} déchet(s)",
                        $"Déplacement vers {pts[0]}"
                     );
                     robot.DéplacerVers(pts[0]);
                     robot.RéinitialiserPuissance();
                  }
                  string s = "Collectés : ";
                  lock (collectés)
                  {
                     foreach (var (sym, n) in collectés)
                        s += $"{sym} x {n}; ";
                     information.Ajouter(ConsoleColor.White, s, "Pressez une touche pour terminer");
                  }
               }
               else
               {
                  robot.AugmenterPuissance();
               }
               Thread.Sleep(500);
            }
            while (!trouvé);
            robot.RéinitialiserPuissance();
         }
      });
   }
   return cueilleurs;
}

class RobotInfo
{
   public Robot? robot;
   public int noPort;
   public string nom;
   public ConsoleColor couleur;
   public Catégorie catégorie;
   public RobotInfo(Robot? robot, int noPort, string nom,
                    ConsoleColor couleur, Catégorie catégorie)
   {
      this.robot = robot;
      this.noPort = noPort;
      this.nom = nom;
      this.couleur = couleur;
      this.catégorie = catégorie;
   }
   public void Deconstruct(out Robot? robot, out int noPort,
                           out string nom, out ConsoleColor couleur,
                           out Catégorie catégorie)
   {
      robot = this.robot;
      noPort = this.noPort;
      nom = this.nom;
      couleur = this.couleur;
      catégorie = this.catégorie;
   }
}

class SurfacePleineException : Exception;

// ...
RobotInfo[] robotsInfo =
{
   new(null, 0, "Wallyd", ConsoleColor.Magenta, Catégorie.Métal),
   new(null, 1, "Bart", ConsoleColor.Blue, Catégorie.Plastique),
   new(null, 2, "Charles", ConsoleColor.Yellow, Catégorie.Organique),
   new(null, 3, "Lisa", ConsoleColor.Green, Catégorie.Nucléaire)
};

(char sym, Catégorie cat)[] symCatégorie =
{
    ('%', Catégorie.Métal),
    ('*', Catégorie.Plastique),
    ('&', Catégorie.Plastique),
    ('/', Catégorie.Organique),
    ('?', Catégorie.Nucléaire),
    ('*', Catégorie.Recyclable),
};
foreach (var symCat in symCatégorie)
   Catalogue.Get.Associer(symCat.sym, symCat.cat);

// préparer la surface d'affichage
const int HAUTEUR = 20,
          LARGEUR = 40;
Surface surf = new(HAUTEUR, LARGEUR);
// préparer le cadre de la surface
Cadre cadre = new(HAUTEUR, LARGEUR, ConsoleColor.Cyan);
// préparer la zone de messagerie
Messagerie messagerie = new(new(LARGEUR, 0), HAUTEUR);
// préparer la zone d'informations
Messagerie information = new(new(0, HAUTEUR), 2);

Random dé = new();
List<(Robot r, Catégorie c)> robots =
   CréerRobots(robotsInfo, dé, surf, cadre.Exclure);

// placer les déchets sur la surface
const int NB_DÉCHETS = 10;
List<Déchet> déchets =
   CréerPollution(symCatégorie, dé, NB_DÉCHETS, surf, cadre.Exclure);
surf.Ajouter(déchets.ToArray());

CanalComm<InfoCanalComm> canal = new(robotsInfo.Length);
PipelineAffichage pipe = new(surf, cadre, canal);

CancellationTokenSource cts0 = new();
CancellationTokenSource cts1 = new();

Task collectes =  Task.WhenAny
(
   ExécuterCollecteAsync
   (
      robotsInfo, surf, canal, messagerie, information, cts0.Token, cts1
   ), ArrêterAsync(cts0)
);

while (!cts1.Token.IsCancellationRequested)
{
   pipe.Rafraichir();
   messagerie.Afficher();
   information.Afficher();
}
pipe.Rafraichir();
messagerie.Afficher();
information.Afficher();

// Ici la méthode ExécuterCollecteAsync

// Ici la méthode ArrêterAsync


static List<(Robot robot, Catégorie cat)>
   CréerRobots(RobotInfo[] robotsInfo, Random dé, Surface surf, Func<Point2D, bool> exclure)   
{
   List<(Robot r, Catégorie c)> robots = new();
   // Trouver les cases libres
   var libres = surf.TrouverSi(exclure, c => c == default || c == ' ');
   for (int r = 0; r < robotsInfo.Length; r++)
   {
      RobotInfo info = robotsInfo[r];
      int n = dé.Next(libres.Count);
      Robot robot =
         CréerRobot(info.nom, libres[n], info.couleur, info.catégorie); 
      info.robot = robot;
      libres.RemoveAt(n);
   }
   return robots;
}
static Robot
   CréerRobot(string nom, Point2D pos, ConsoleColor couleur, Catégorie cat)
{
   Robot robot = new(nom, pos, couleur);
   robot.Équiper(new Détecteur(robot, 1, cat));
   return robot;
}
static List<Déchet>
   CréerPollution((char sym, Catégorie cat)[] symCatégorie, Random dé,
                  int nbDéchets,
                  Surface surf, Func<Point2D, bool> exclure)
{
   List<Déchet> déchets = new();
   var libres = surf.TrouverSi(exclure, c => c == default || c == ' ');
   if (libres.Count < nbDéchets * symCatégorie.Length)
      throw new SurfacePleineException();
   foreach (var symCat in symCatégorie)
   {
      for (int d = 0; d != nbDéchets; ++d)
      {
         int n = dé.Next(libres.Count);
         déchets.Add(new(symCat.sym, symCat.cat, libres[n]));
         libres.RemoveAt(n);
      }
   }
   return déchets;
}
class RobotInfo
{
   public Robot? robot;
   public int noPort;
   public string nom;
   public ConsoleColor couleur;
   public Catégorie catégorie;
   public RobotInfo(Robot? robot, int noPort, string nom,
                    ConsoleColor couleur, Catégorie catégorie)
   {
      this.robot = robot;
      this.noPort = noPort;
      this.nom = nom;
      this.couleur = couleur;
      this.catégorie = catégorie;
   }
   public void Deconstruct(out Robot? robot, out int noPort,
                           out string nom, out ConsoleColor couleur,
                           out Catégorie catégorie)
   {
      robot = this.robot;
      noPort = this.noPort;
      nom = this.nom;
      couleur = this.couleur;
      catégorie = this.catégorie;
   }
}
class SurfacePleineException : Exception { }
// ...