with Simon ;
use Simon ;
-- Il y a déjà un problème de logique générale du programme : en effet, si la séquence est la suivante : {HD, BG, BD, BG}
-- Le jeu doit d'abord afficher {HD}, le joueur doit appuyer sur HD
-- Le jeu doit ensuite afficher {HD, BG}, le joueur doit appuyer d'abord sur HD, ensuite sur BG
-- Le jeu doit ensuite afficher {HD, BG, BD}, le joueur doit appuyer sur HD, BG puis BD
-- Le jeu doit ensuite afficher {HD, BG, BD, BG}, le joueur doit appuyer sur HD, BG, BD puis BG
-- et là on a gagné.
-- Dans votre cas , voici ce que vous faites (ou ce que ca aurait fait si il n'y avait pas eu le souci mentionné plus bas):
-- Le jeu doit d'abord afficher {HD}, le joueur doit appuyer sur HD
-- Le jeu doit ensuite afficher {HD, BG}, le joueur doit appuyer sur BG
-- Le jeu doit ensuite afficher {HD, BG, BD}, le joueur doit appuyer sur BD
-- Le jeu doit ensuite afficher {HD, BG, BD, BG}, le joueur doit appuyer sur BG

-- Ici, vous ne vérifiez à chaque accroissement de la séquence par le jeu que la dernière direction entrée.
-- Il vous faut un second compteur X, similaire à J mais qui correspondra à la position actuelle de l'utilisateur
-- dans la séquence, et vérifier non pas que Dir = S(J), mais que Dir = S(X), si c'est bon X s'incrémente,on refait, etc ...
-- jusqu'à ce que X = J.
-- Grossièrement, cela donnerait quelque chose dans ce style :
--  __________________________
-- |   Générer la séquence    |
-- |__________________________|
--   ___|_____________________________________________            ______________________________
--  /  Tant qu'on a pas perdu et que J < Seq'Length   \_____sinon____|Afficher Game Over ou Victoire|
--  \_________________________________________________/          |______________________________|
--  |
--  ____|_____________________
-- |   X:=0; J := J + 1;      |
-- |__________________________|
--  |
--   ___|_____________________________________________
--  /  Tant qu'on a pas perdu et que X < J            \<____________________________
--  \_________________________________________________/                 |
--  |                                       |
--  ____|____________________________                           |
-- |   Dir := DetecterDirection      |                          |
-- |_________________________________|                          |
--  |                                       |
--  ____|____________________________          _________________            |
-- |   Est ce que Dir = Seq(X) ?     |__non___| Perdu := True   |           |
-- |_________________________________|        |_________________|           |
--  |                                       |
--  oui                                     |
--  |                                       |
--  ____|____________________________                           |
-- |   X := X + 1            |                          |
-- |_________________________________|                          |
--  |___________________________________________________________________________|
--
-- Il est également nécessaire de gérer le retour au centre : s'assurer qu'on est bien revenu à Immobile entre deux Directions.
procedure missionsimon is

   -- Evitez d'utiliser des noms de variables à une seule lettre, ce n'est pas très explicite. L'idéal
   -- reste que le code se documente lui même. IndiceJeu aurait été préférable à la place de J par exemple.
   N : Integer;
   O : T_Direction; -- vous n'utilisez pas O dans le code, est ce normal ?
   J : Integer := 0;
   Test : Boolean := False;


   procedure Affichage (Dir : T_Direction) is
   begin
      case Dir is
     when Haut_Droit =>
        DessinerPave(Dir, True);
        EcrireEcran(1,1,"Bleu");

     when Haut_Gauche=>
        DessinerPave(Dir, True);
        EcrireEcran(1,1,"Jaune");
     when Bas_Droit =>
        DessinerPave(Dir, True);
        EcrireEcran(1,1,"Vert");
     when Bas_Gauche=>
        DessinerPave(Dir, True);
        EcrireEcran(1,1,"Rouge");
     when Immobile => EcrireEcran(1,1, "Immobile");

      end case;

   end Affichage;

    procedure Mort (S : T_Sequence; Dir : T_Direction; J : Integer) is
   begin

      if Dir = S(J) then
     Affichage(Dir);
      elsif Dir = Immobile then
     -- Je pense que le problème vient d'ici :
     -- Imaginons que DetecterDirection renvoie Immobile car vous n'avez pas encore eu le temps de changer la direction
     -- Vous allez tomber dans ce elsif, qui ne fait rien, et donc votre fonction Mort va terminer.
     -- On arrivera donc à la fin de l'itération de votre boucle, et on est reparti pour un tour avec J qui s'incrémente, etc.
     -- Ca se reproduit ainsi jusqu'à la fin de la séquence, du coup votre condition J < Seq'Last deviens fausse et vous
     -- sortez de la boucle et "gagnez" le jeu (et oui, car Test vaut toujours False).
     -- Il faudrait encapsuler votre if ... elsif ... else dans une boucle While, afin que la condition se répete tant
     -- qu'aucune vraie direction n'a été entrée.
     null;
      else
     Test := True;
      end if;

   end Mort;




begin
   while True loop
      AttendreToucheA;
      EffacerEcran;

      N := SaisirLongueurSequence;

      declare
     Seq : T_Sequence(1..N);

      begin
     GenererSequence(Seq);
     AfficherSimon;

     --Affiche Seq en entier
     --AfficherSequence(Seq);
-- PetitePause;

     --Affiche Seq entre 2 bornes
     -- AfficherSequence(Seq(Seq'Last-2..Seq'Last));
     -- PetitePause;

     while Test = False and J < Seq'Length  loop
        J := J+1;
        -- Ici vous faites une supposition hasardeuse : que les bornes commencent à 1
        -- en ADA, ce n'est pas une certitude, il est tout à fait possible que Seq commence à 2, 3, etc .
        -- il faudrait donc utiliser non pas Seq(Seq'First..J), mais plutot Seq(Seq'First .. Seq'First + J - 1)
        -- Ici cependant ça fonctionne car Sequence commence effectivement à 1
        AfficherSequence(Seq(Seq'First..J));
        PetitePause;
        Mort(Seq, DetecterDirection, J);

     end loop;

        if Test = False then
           AfficherGagne;
           EffaceEcranFinDuJeu;
        else
           AfficherGameOver;
           EffaceEcranFinDuJeu;
        end if;

      end;

   end loop;

end missionsimon ;