{ JDVIE. Programme elementaire de simulation a evenements discrets,
  de la classe des automates cellulaires (Von Neumann, 1939).

  1. Les regles d'evolution sont celles de J. Conway (1970).

  2. Il est possible d'introduire une part d'alea en liant les evenements
  a des probabilites, auquel cas il devient une simulation aleatoire a
  evenements discrets.

  D'un point de vue technique le noyau de la simulation [Kernel]
  (partie principale et procedure parcours) comporte une approche processus
  (un seul processus : vie /mort/reproduction des cellules toutes identiques) et
  et une gestion du temps dite guidee par horloge. Sous sa forme elementaire
  ce programme ne gere pas les problemes de parallelisme.

  UE 10, MASTER 11/04
}

program JDVIE;

Uses Crt, graph, graph2D;

var
                           {Le tableau en memoire des cellules}
   tab : array[1..25,1..25] of shortint;

                           {ceci pour une utilisation ulterieure}
   tab_ancien : array[1..25,1..25] of shortint;

   Fichini,
   Fichres    : text;                 {les deux fichiers}

   I , J      : integer;              {coordonnees du tableau}

   temps      : integer;              {compteur de temps}

{---------------------------------------------------------}
Procedure Graphiques;

begin
   EcranGraphique;             {initialisation graphique}
   Fenetre (0, 30, 0, 30);
   Cloture (100, 400, 100, 400);
end;


{---------------------------------------------------------}
procedure affiche_cellule(I,J : integer);
{         remplit une cellule en rouge                    }
var
   k :integer;

begin

    setcolor(red);

    for k:=1 to 9 do
      begin
         DeplaceEn(I+0.1 * k, J + 0.1);
         Tracevers(I+0.1 * k, J + 0.9);
      end;
end;

{---------------------------------------------------------}
procedure efface_cellule(I,J : integer);
{        efface une cellule. Il suffit de colorer en noir }

var
  k : integer;

begin
    setcolor(black);

    for k:=1 to 9 do
      begin
        DeplaceEn(I+0.1 * k, J + 0.1);
        Tracevers(I+0.1 * k, J + 0.9);
      end;
end;

{---------------------------------------------------------}
function Vivante(K,L : integer) : integer;
{    Renvoie 0 ou 1                                       }
{    Ici on a opte pour un univers limite. Pas de bordure }
{    particuliere. En dehors des limites du tableau, tout }
{    est mort.                                            }

begin
    If (K <= 0) OR (K >=26)
        then
           vivante := 0
        else
          if(L <= 0) OR (L >=26)
            then
              vivante := 0
            else vivante:=tab[K,L];
end;


{---------------------------------------------------------}
function voisinage(I,J : integer) : integer;
{ Renvoie le nombre de Cell. vivantes parmi les 8 voisines}


var
nombre : integer;

begin
     nombre := 0;
                       {  Coin superieur gauche }
     nombre := nombre + Vivante(I-1, J-1);
                       {  Case superieure       }
     nombre := nombre + Vivante(I-1, J);
                       {  Coin superieur droit  }
     nombre := nombre + Vivante(I-1, J+1);
                       {  Case droite           }
     nombre := nombre + Vivante(I, J+1);
                       {  Coin inferieur droit  }
     nombre := nombre + Vivante(I+1, J+1);
                       {  Case inferieure       }
     nombre := nombre + Vivante(I+1, J);
                       {  Coin inferieur gauche }
     nombre := nombre + Vivante(I+1, J-1);
                       {  Case gauche           }
     nombre := nombre + Vivante(I, J-1);

     voisinage := nombre;
end;


{---------------------------------------------------------}
procedure parcours;
{   parcour  l'automate et applique les rŠgles du jeu     }

var
etat,
voisins : integer;

begin

  for I:=1 to 25 do
    for J:= 1 to 25 do

      begin
         etat := tab[I,J];           {etat de la cellule : 0 ou 1}
         voisins := voisinage(I,J);  {nombre de voisinnes vivantes}

         If etat = 1 then            {si elle est vivante}

            case voisins of

                 0 , 1 : begin           {elle meurt}
                           tab[I,J]:=0;
                           efface_cellule(I,J);
                         end;

                 2 , 3 : begin           {elle survit}
                         end;

                else
                         begin           {elle meurt}
                           tab[I,J]:=0;
                           efface_cellule(I,J);
                         end
                end;

                         {reproduction}

         If ( (etat = 0) and (voisins >=3) ) then
            begin
               tab[I,J] := 1;
               affiche_cellule(I,J);
            end;
      end;
end;

{---------------------------------------------------------}
procedure trace_grille;
{  affichage graphique de l'automate cellulaire           }

begin

   ClearDevice; {on commence par effacer l'ecran}

   J:=1;

   for I := 1 to 26 do     {26 lignes horizontales}
       begin
         DeplaceEn(I,J);
         tracevers(I,26);
       end;

   I:=1;

   for J := 1 to 26 do     {26 lignes verticales}
       begin
         DeplaceEn(I,J);
         tracevers(26,J);
       end;

   for I:=1 to 25 do       {25 X 25 cellules}
     for J:=1 to 25 do
        if (tab[I,J] = 1) then affiche_cellule(I,J);

   readln;
end;

{---------------------------------------------------------}
procedure initialise;

var valeur : shortint;

begin
                  {lecture du fichier initial}
{$I-}
   assign(fichini,'C:\TP\mesprog\JDVIE.ini');
   reset(fichini);
{$I+}
   if (IoResult <> 0) then
     begin
        writeln('impossible d''ouvrir le fichier d''initialisation...abandon');
        EcranTexte;
        Halt(0);
     end;

                  {mise en m‚moire du contenu du fichier}

   for I:=1 to 25 do
     begin
       for J:=1 to 25 do
         begin
           read(fichini,valeur);
           tab[I,J] := valeur;
         end;
       readln(fichini);  {passe a la ligne suivante}
     end;
   close(fichini);
end;

{--------------------------------------------------------}
procedure gere_temps;
{   gere le temps (guide par horloge)                    }

begin
   temps := temps +1;         { on l'incremente          }
end;

{--------------------------------------------------------}
procedure Cree_fichier;
{ Creation du fichier des resultats exploitable par Excel}

begin

{$I-}                         { cr‚ation du fichier resultat}
   assign(fichres,'c:\stat\JDVIE.res');
   rewrite(fichres);
{$I+}
   if (IoResult <> 0) then
     begin
        writeln('impossible de creer le fichier resultat...abandon');
        EcranTexte;
        Halt(0);
     end;
end;

{---------------------------------------------------------}
Procedure Enregistre;

{explore l'automate pour compter le nbre de cell. vivantes}
{   puis enregistre dans le fichier "Fichres"             }

var
  compte :  integer;    {pour compter...}

begin
   compte := 0;

   for I:=1 to 25 do
      for J:= 1 to 25 do
         compte := compte + tab[I,J];

   write(Fichres,compte,'  ');
end;

{---------------------------------------------------------}
{                  PRINCIPAL                              }
{ En cas d'introduction de probabilites, il faudra operer }
{ ici de serieuses modif. pour effectuer des replications }
{---------------------------------------------------------}

begin
   Graphiques;
   initialise;
   Cree_fichier;
   trace_grille;

   temps := 1;

   While (temps <= 10) do   {boucle de simulation}
      begin
        parcours;
        enregistre;
        gere_temps;
        Delay(1000);
      end;

{necessaire ulterieurement si l'on fait des replications:}

   writeln(fichres);
   close(fichres);
end.

{------------EOF-------------------}