Alex Romero Pau G06-08

-A continuación explicare los modulos y caracteristicas del programa que he realizado.
Para una mejor comprensión he copiado textualmente el programa.
Nota: Para mejorar esteticamente el juego he realizado "clscr" en alguna ocasion para
limpiar la pantalla y he utilizado una serie de colores puramente estéticos.



PROGRAM ElJuegoDeLaVida;
   USES
    crt; {Para poder usar la uncion RANDOM y TEXTCOLOR}

   TYPE  {Definire un tipo vector binomial para el programa,
          el cual representara las fichas de tablero}

    tpv=array[1..20,1..20]of integer;

{Inicio de la definicion de PROCEDURES a utilizar en el programa}

   PROCEDURE vivasmuertas(var tablero:tpv;lado:integer;probU:real);
{Procedimiento usado para la creacion del mundo aleatorio}

-Este procedimiento consta de una serie de variables utilizadas para la creación del mundo
aleatorio. Estará compuesto por un FOR cuya función será ir desplazandose por el tablero
desde uno hasta "lado" y colocando en cada posición una ficha viva o muerta según el porcentaje
que obtenga de la función RANDOM.Al final el tablero resultante lo asociara al tablero que se
utilizara en el programa (por eso ponemos "tablero" por referencia).

    VAR  {Variables locales del procedimiento}
      tablero2:tpv;
      porc:real;
      i,j:integer;
    BEGIN
     tablero2:=tablero;
       FOR i:=2 TO (lado-1) DO
        FOR j:=2 TO (lado-1) DO
           BEGIN
             porc:=random(11)/10; {Calculo del porcentaje para cada ficha}
              IF (porc<=probU) THEN  {Comparacion con el porcentaje dado por el usuario}
                tablero2[i][j]:=1
              ELSE
                tablero2[i][j]:=0;
           END;

     tablero:=tablero2;
    END;

   PROCEDURE muestratablero (tablero:tpv; lado:integer);
{Procedimiento de muestra de tablero por pantalla}

-La unica función de este procedimiento es mostrar por pantalla el tablero o mundo.
Esto lo hemos conseguido mediante la estructura FOR.

     VAR   {Variables locales del procedimiento}
       i,j:integer;

     BEGIN
      FOR i:=1 TO lado DO
         BEGIN
           writeln;
            FOR j:=1 TO lado DO
             begin
               IF (tablero[i][j]=0) THEN
                 textcolor(8)    {Color designado segun tipo de ficha}
               ELSE
                 textcolor(9);
             write(tablero[i][j]);
                 textcolor(white);
             end;

         END;

   END;

   PROCEDURE Cvivasmuertas (VAR tablero:tpv;X,Y,Z,lado:integer);
{Procedimiento que realiza la operacion de matar o dejar vivir a las fichas}

-Este procedimiento nos calculara las fichas que mueran o vivan despues de haber seleccionado
el usuario las condiciones correspondientes. Este proceso a sido conseguido gracias a un FOR
que nos recorrera el tablero y un IF que nos ira colocando en un tablero nuevo las fichas vivas
o muertas.

     VAR     {Variables locales del procedimiento}
      i,j:integer;
      contvivas,a,b:integer;
      tablero4,tablero3:tpv;
     BEGIN
       tablero3:=tablero;
       tablero4:=tablero;
        FOR i:=2 TO (lado-1) DO
         FOR j:=2 TO (lado-1) DO
          BEGIN
            contvivas:=0;
               FOR a:=i-1 TO i+1 DO
                FOR b:=j-1 TO j+1 DO
                 BEGIN
                   IF (tablero[a][b]=1) THEN
                    contvivas:=contvivas+1;
                 END;
        IF (tablero[i][j]=1) THEN
          contvivas:=contvivas - 1;
{Proceso de matar o dejar vivir las "fichas"}
        IF Y<Z THEN
          BEGIN
           IF (tablero[i][j]=1) AND ((contvivas>=Y)OR(contvivas<=Z)) THEN
            tablero4[a][b]:=1
           ELSE
            tablero4[a][b]:=0;
           END;
        IF (tablero[i][j]=0) AND (contvivas=X) THEN
             tablero4[a][b]:=1
        ELSE
             tablero4[a][b]:=0;
        IF Y>Z THEN
          BEGIN
           IF (tablero[i][j]=1) AND ((contvivas<=Y)OR(contvivas>=Z)) THEN
             tablero4[a][b]:=1
           ELSE
             tablero4[a][b]:=0
          END;
        END;
    tablero:=tablero4;
   END;

{........................................................................}
{PROCEDIMIENTO DE CARGAR MUNDO NO REALIZADO}
{   FUNCTION cargar_mundo(nombreFich: string): string;
 

-Esta función no he podido lograr que funcionara asi que en la proxima entrega lo completaré.
         var
              fichero:text;
              linea:string;
              mundo:String[200];
          begin
           assign(fichero,nombreFich);
           Reset(fichero);
           mundo:='';
            while not eof(fichero) do
             begin
               Readln(fichero,linea);
               mundo:=mundo+linea+'|';
             end;

              cargar_mundo:=mundo;
            end;}
{........................................................................}

-Aquí comenzaría el programa principal. Primero definire las variables necesarias y
a continuación empezare a realizar los procedimientos necesarios.

{VARIABLES DEL PROGRAMA PRINCIPAL}
   VAR
    tablero:tpv;
    selecc,modo,lado,t,i,j,turno,regla,X,Y,Z:integer;
    probU:real;
    mund:boolean;
    mundo:string;  {No usado}
{COMIENZO DEL PROGRAMA PRINCIPAL}
   BEGIN
      clrscr;
      randomize;
      gotoxy(22,8);
      textcolor(15);
      writeln('---------------------------------------');
      gotoxy(22,10);
      write('              Bienvenido a...');
      writeln;
      gotoxy(22,12);
      textcolor(9);
      writeln('          EL JUEGO DE LA VIDA');
      gotoxy(22,14);
      textcolor(15);
      writeln('---------------------------------------');
      readln;

-A la hora de seleccionar la opción lo he regulado mediante un REPEAT que solo dejara
de ejecutarse cuando el usuario pulse 4 (fin del juego).

   REPEAT
      clrscr;
      writeln('Seleccione una opci¢n:');
      writeln('1. Generaci¢n de mundo aleatorio.');
      writeln('2. Ejecuci¢n.');
      writeln('3. Cargar Estado Inicial.'); {.txt}
      writeln('4. Salir.');
      writeln;
      write('Seleccion: ');
      readln(selecc);

-Utilizare un CASE para reflejar la opcion seleccionada del usuario. Segun la seleccion del 
usuario ocurrirá una cosa u otra.

    CASE selecc OF   {Segun la opcion seleccionada por el usuario...}

-En el caso 1 el programa pedirá al usuario tanto el lado como la probabilidad de vida y los
almacenará en sus variables correspondientes.

     1: BEGIN  {Pedida de datos para el mundo aleatorio}
         clrscr;
         writeln('A seleccionado la generaci¢n de un mundo aleatorio.');
         {$I-}
         {$r-}
         REPEAT
          BEGIN
           writeln('Digame el lado del tablero:');
           writeln;
           write('Lado: ');
           readln(lado);
            WHILE IOResult<>0 DO
            begin
            writeln('Valor erroneo, repita porfavor');
            writeln('El lado tiene que estar entre 4 y 20');
            end;
          END;
         UNTIL (lado<21) AND (lado>3);
         {$I+}
         {$r+}
         writeln;
         writeln('Gracias');

         writeln('Escriba la probabilidad de vivas (Entre 0 y 1)');
         {$I-}
         {$r-}
         REPEAT
          BEGIN
           writeln('Digame la probabilidad de muertas o vivas:');
           writeln;
           write('Probabilidad: ');
           readln(probU);
            WHILE IOResult<>0 DO
            writeln('Valor erroneo, repita porfavor');
            {writeln('La probabilidad debe ser entre 0 y 1');}
          END;
         UNTIL (probU<=1) AND (probU>0);
         {$I+}
         {$r+}
         writeln;
         writeln('Gracias');

       FOR i:=1 TO lado DO
           FOR j:=1 TO lado DO
               tablero[i][j]:=0;

       vivasmuertas(tablero,lado,probU);
       readln;
       writeln('Veamos la disposicion del tablero');
       readln;
       clrscr;
       writeln('Tablero: ');
       muestratablero(tablero,lado);
       mund:=TRUE;
       readln;
       END;

-Dentro caso 2 (modo ejecución) se pedirá al usuario tanto los turnos como el tipo de juego para
almacenarse en su correspondiente variable y así poder ser utilizados cuando hagamos el 
llamamiento a los procedimientos necesarios. Este proceso solo se iniciará si la variable
llamada "mund" que nos define la existencia de un mundo o no este activada.

     2:BEGIN
       IF mund=TRUE THEN
        BEGIN  {Inicio de la ejecucion}
         clrscr;
         writeln('Ha seleccionado el comando ejecucion,');
         writeln('seleccione el numero de turnos');
         writeln;
         write('Turnos: ');
         readln(turno);
         writeln('Elija las reglas del juego');
         writeln('1.Por defecto (X=3,Y=2 y Z=3)');
         writeln('2.Establecidas por Usuario');
         writeln;
         write('Regla: ');
         readln(regla);
          CASE regla OF
           1: BEGIN
              X:=3;
              Y:=2;
              Z:=3;
              END;

           2: BEGIN
               REPEAT
                writeln('Digame el valor de la X');
                writeln;
                write('X: ');
                readln(X);
                writeln('Ahora digame el valor de la Y');
                writeln;
                write('Y: ');
                readln(Y);
                writeln('Por ultimo digame el valor de la Z');
                writeln;
                write('Z: ');
                readln(Z);
               UNTIL (X<>Y) AND (Z>Y) AND (Y<7) AND (Z<9) AND (X<9)
              END;
           END;

         readln;
{Seleccion de ejecucion paso a paso o directo}
         writeln('A continuaci¢n digame como prefiere el juego:');
         writeln('1. Paso a paso');
         writeln('2. Principio y fin');
         writeln('Modo de juego: ');
         readln(modo);
         writeln('Comienza el juego');
         readln;
          IF modo=2 THEN
           BEGIN
           writeln('Tablero inicial:');
           muestratablero(tablero,lado);
           readln;
           t:=0;
            REPEAT
             t:=t+1;
             Cvivasmuertas(tablero,X,Y,Z,lado);
            UNTIL t=turno;
           writeln('Tablero finalizado');
           muestratablero(tablero,lado);
           readln;
            END;
          IF modo=1 THEN
            BEGIN
            writeln('Tablero inicial:');
            muestratablero(tablero,lado);
            readln;
            t:=0;
             REPEAT
              t:=t+1;
              Cvivasmuertas(tablero,X,Y,Z,lado);
              clrscr;
              writeln('Turno ',t);
              muestratablero(tablero,lado);
              readln;
             UNTIL t=turno;
            clrscr;
            writeln('Tablero final:');
            muestratablero(tablero,lado);
            readln;
            END;
       mund:=FALSE;
         END
         ELSE
          begin
        writeln('No hay mundo creado, creelo porfavor');
        writeln;
        readln;
          end;
     END;

-El caso 3 no ha podido ser realizado.

     3: BEGIN
{....................................................................}
{NO UTILIZADO}
      { var
	mundo:String;

       begin
            mundo:=cargar_mundo('mundo.txt');
	    writeln(mundo);
            writeln(mundo[8]);
            writeln(mundo[25]);

       end. }
{................................................................}
         END;

-Este ultimo caso solo realizara la salida del juego activando la opcion "UNTIL" del REPEAT.

     4: BEGIN  {Opcion de salida del juego}
         writeln;
         writeln('A seleccionado salir del programa.');

        END;

   END;

   UNTIL selecc=4;  {Proceso repetido hasta que el usuario seleccione 4}
   textcolor(12);
   writeln;
   writeln('ADIOS');
   textcolor(white);
   readln;
   END.
{Fin del programa}
 
 ----------------------------  (añadido tras someter) ---------------------------- 

  21:08:10  11/12/09
   -> Segun los datos introducidos los ficheros son: 
G06P08D2
 -> Los autores del trabajo son: 
 ROMERO PAU, ALEJANDRO
 
 
 Nombres originales de los archivos entregados ->  LAVIDANU.PAS, LAVIDANUEVABUENA.txt