PROGRAM ElJuegoDeLaVida;
{PRACTICA DE DISE¥O 2 ENTREGA 1}
{TOMAS BUJEDA RAMI 471378, GRUPO 14, PUESTO 11}

{NOTA: TODOS LOS COMENTARIOS ESTÁN EN COLOR ROJO}

{NOTA: EL PROGRAMA ESTA DIVIDIDO POR PROCEDIMIENTOS EN FUNCION DE LA SELECCION
INICIAL DEL MENU, A CONTINUACION INDICO LAS OPERACIONES QUE HASTA EL MOMENTO
HE PROGRAMADO PARA QUE HAGA EL PROGRAMA.
SELECCION-1: SOLICITA Y ALMACENA EL LADO DEL TABLERO.
           : SOLICITA, ALMACENA Y ASIGNA A TODAS LAS CASILLAS LA PROBABILIDAD
    INDICADA POR EL JUGADOR ENTRE 0 Y 1
           : GENERA ALEATORIAMENTE UN NUMERO ENTRE 0 Y 1
           : COMPARA ESTE NUMERO PARA CADA CELDA
           : SI ESTA VIVA EN ESTADO INICIAL DE JUEGO ASIGNA EL CARACTER X A LA CASILLA
           : SI ESTA MUERTA EN ESTADO INICIAL DE JUEGO ASIGNA UN ESPACIO A LA CASILLA}
{EN ESTE PUNTO ESTA INCOMPLETO, YA QUE ME FALTA SACAR POR PANTALLA EL TABLERO}
{SELECCION-2: SOLICITA Y ALMACENA EL NUMERO DE TURNOS
            : SOLICITA Y ALMACENA CADA UNA DE LAS REGLAS DEL JUEGO
            : SOLICITA Y ALMACENA EL MODO DE EJECUCION SELECCIONADO}
{EN ESTE PUNTO IGUALMENTE SE ENCUENTRA INCOMPLETO YA QUE ME FALTA GENERAR LAS JUGADAS}
{SELECCION-3: ACTUALMENTE NO SE REALIZARLO }
{SELECCION-4: SALIR}

{NOTA: EN TODO EL PROGRAMA, AL SOLICITAR AL USUARIO QUE INTRODUZCA CUALQUIER
PARAMETRO, PARA APORTAR ROBUSTEZ, UTILIZO EL WHILE Y REPITO PARA INTRODUCIR
EN EL TEXTO QUE SE HA EQUIVOCADO, YA QUE SI NO CONSIDERO QUE NO SABRIA EL MOTIVO
DE PORQUE ESTA REPITIENDOSE, DE OTRA FORMA LO REALIZARIA CON EL REPEAT ... UNTIL...}

USES
crt; {PARA UTILIZAR EL CLRSCR ENTRE PARTIDA Y PARTIDA, ASI COMO EL READKEY}

TYPE
vetablero=Array [1..20, 1..20] OF char; {AQUI DEFINO LA "IDEA" DEL VECTOR}

{*************************************************************************}
PROCEDURE menu (var s_p_1_menu: integer);
{PROCEDIMIENTO QUE MUESTRA EL MENU DEL INICIO DEL PROGRAMA}
VAR
 i_p:integer; {Variable interna del Procedure}

{$I-}  {APORTA ROBUSTEZ, ACTIVA NO MARCAR FALLOS}
BEGIN
 writeln (' ');
 writeln ('------------------------------------');
 writeln ('-        Que deseas realizar       -');
 writeln ('-                                  -');
 writeln ('- 1 -       General Mundo          -');
 writeln ('- 2 -       Ejecuci¢n              -');
 writeln ('- 3 -       Cargar Estado Inicial  -');
 writeln ('- 4 -       Salir                  -');
 writeln ('------------------------------------');
 writeln (' Selecciona el n£mero y pulsa Intro ');
 writeln ('------------------------------------');
 readln (i_p);
    WHILE ((Ioresult<>0) OR (i_p<=0) OR (i_p>4))
    DO
    BEGIN
    writeln (' ');
    writeln (' Selecci¢n no correcta ');
    writeln (' ');
 writeln ('------------------------------------');
 writeln ('-        Que deseas realizar       -');
 writeln ('-                                  -');
 writeln ('- 1 -       General Mundo          -');
 writeln ('- 2 -       Ejecuci¢n              -');
 writeln ('- 3 -       Cargar Estado Inicial  -');
 writeln ('- 4 -       Salir                  -');
 writeln ('------------------------------------');
 writeln (' Selecciona el n£mero y pulsa Intro ');
 writeln ('------------------------------------');
 readln (i_p);
    END;
    s_p_1_menu:=i_p; {A LA VARIABLE DE SALIDA S_P_1_MENU LE ASIGNO EL VALOR DE I_P}
 {$i+}  {APORTA ROBUSTEZ, DESACTIVA NO MARCAR FALLOS}
END;
{**************************************************************************}
{**************************************************************************}
PROCEDURE lado (var lado2:integer);
VAR
lado:integer;
BEGIN
{$I-}   {APORTA ROBUSTEZ, ACTIVA NO MARCAR FALLOS}
 lado:=0;
 writeln (' ');
 writeln ('----------------------------------------------------------');
 writeln ('SELECCIONA EL TAMA¥O DEL LADO DEL TABLERO QUE QUIERAS ');
 writeln ('----------------------------------------------------------');
 writeln ('               --- Y PULSA INTRO ---');
 writeln ('----------------------------------------------------------');
 writeln (' SE GENERARA UN TABLERO CUADRADO DE LA DIMENSION QUE DIGAS');
 writeln ('----------------------------------------------------------');
 writeln ('  ');
 readln (lado);
  WHILE ((ioresult<>0) OR (lado<=3) OR (lado>20))
  DO
  BEGIN
    writeln (' ');
    writeln ('----------------------------------------------------------');
    writeln ('LO SIENTO, NO PUEDES SELECCIONAR ESE TAMA¥O ');
    writeln ('----------------------------------------------------------');
    writeln ('               --- Y PULSA INTRO ---');
    writeln ('----------------------------------------------------------');
    writeln ('SELECCIONA EL TAMA¥O DEL LADO DEL TABLERO QUE QUIERAS ');
    writeln ('----------------------------------------------------------');
    writeln (' ');
    writeln (' ');
    readln (lado);
  END;
  lado2:=lado;
 END;
{$I+}     {APORTA ROBUSTEZ, DESACTIVA NO MARCAR FALLOS}

{**************************************************************************}

PROCEDURE probabilidad_vida (var prob_vida:real);
{PIDE LA PROBABILIDAD BASE PARA LA VIDA PARA TODAS LAS CASILLAS, PARA DESPUES PODER COMPARAR CON EL RANDOM UNA POR UNA Y DISCRIMINAR SI ESTA VIVA O MUERTA}
VAR
 i: real;
{$I-}
BEGIN
 writeln (' ');
 writeln ('-------------------------------------------');
 writeln (' Ahora, debes indicar la probabilidad de   ');
 writeln ('   las casillas est‚n vivas para poder     ');
 writeln (' conocer posteriormente si realmente en    ');
 writeln ('el estado inicial del juego lo estar n o no');
 writeln ('           (Debe ser entre 0 y 1)          ');
 writeln ('-------------------------------------------');
 writeln ('  Selecciona la probabilidad y pulsa Intro ');
 writeln ('-------------------------------------------');
 readln (i);
  WHILE ((Ioresult<>0) OR (i<0) OR (i>1))
    DO
    BEGIN
    writeln (' ');
    writeln (' Selecci¢n no correcta ');
    writeln (' ');
    writeln (' Comprueba, como has indicado la "."');
    writeln (' ');
 writeln ('-------------------------------------------');
 writeln (' Ahora, debes indicar la probabilidad de   ');
 writeln ('   las casillas est‚n vivas para poder     ');
 writeln (' conocer posteriormente si realmente en    ');
 writeln ('el estado inicial del juego lo estar n o no');
 writeln ('           (Debe ser entre 0 y 1)          ');
 writeln ('-------------------------------------------');
 writeln ('  Selecciona la probabilidad y pulsa Intro ');
 writeln ('-------------------------------------------');
 readln (i);
 prob_vida:=i;
    END;
{$I+}
 END;
{**************************************************************************}

{**************************************************************************}
PROCEDURE compara (prob:real;alea:real; var resul:char);
{PROCEDIMIENTO PARA LA ESTADO INICIAL DE VIVAS - MUERTAS}
{RECOJO LA PROBABILIDAD, EL ALEATORIO DE RANDOM Y DEVUELVO
EL RESULTADO COMO CARACTER, YA INDICANDO SI ESTA VIVA LA CASILLA
CON "X" O SI ESTA MUERTA CON UN ESPACIO " "}
VAR
resulta:char;
BEGIN
  IF prob<=alea
  THEN
  resulta:='X'
  ELSE
  resulta:=' ';
  resul:=resulta;
END;
{****************************************:**********************************}


{**************************************************************************}
PROCEDURE ejecucion_turnos (VAR n_turnos2:integer);
{SOLICITA AL USUARIO LOS TURNOS DEL JUEGO A REALIZAR}
VAR
turnos: integer;{VARIABLE INTERNA}

BEGIN
{$I-}
 writeln (' ' );
 writeln ('-------------------------------------------');
 writeln ('    Indica cuantos turnos quieres jugar    ');
 writeln ('-------------------------------------------');
 writeln ('     Pulsa Intro despu‚s de tu seleccion   ');
 writeln ('-------------------------------------------');
 writeln (' ');
 read (turnos);
 WHILE ((Ioresult<>0) OR (turnos<0) OR (turnos>999999999))
    DO
    BEGIN
    writeln (' ');
    writeln (' Selecci¢n no correcta ');
    writeln (' ');
    writeln ('-------------------------------------------');
    writeln ('    Indica cuantos turnos quieres jugar    ');
    writeln ('-------------------------------------------');
    writeln ('     Pulsa Intro despu‚s de tu seleccion   ');
    writeln ('-------------------------------------------');
    writeln (' ');
    read (turnos);
{$I+}
    END;
    n_turnos2:=turnos; {ASIGNO A LA VARIABLE DE SALIDA EL VALOR DE TURNOS
    PARA QUE LO ENVIE A LA LLAMADA DEL PROCEDIMIENTO}
END;
{**************************************************************************}
PROCEDURE ejecucion_reglas (VAR regla_1:integer; VAR regla_2:integer; VAR regla_3: integer);
{SOLICITA AL USUARIO LAS REGLAS DEL JUEGO A SEGUIR Y LAS DEVELVE A LAS LLAMADAS}
VAR
X: integer; {NUM DE CELDAS VECINAS QUE HACEN NACER A UNA CELDA}
Y: integer; {NUM MINIMO DE CELDAS VECINAS QUE MANTIENEN VIVA A UNA CELDA}
Z: integer; {NUM MAXIMO DE CELDAS VECINAS QUE MANTIENEN VIVA A UNA CELDA}

BEGIN
{$I-}
 writeln (' ' );
 writeln (' ' );
 writeln ('---------------------------------------------------------------------');
 writeln ('                   Indica con que reglas quieres jugar               ');
 writeln ('---------------------------------------------------------------------');
 writeln (' Selecciona con cuantas celula vecinas vivas "nace" una nueva celula ');
 writeln ('---------------------------------------------------------------------');
 writeln ('     Deben ser de 1 a 8. Despu‚s de seleccionar, pulsa intro         ');
 writeln ('---------------------------------------------------------------------');
 writeln (' ');
 writeln (' ');
 read (X);
 WHILE ((Ioresult<>0) OR (X<1) OR (X>8))
    DO
    BEGIN
    writeln (' ');
    writeln (' Selecci¢n no correcta ');
    writeln (' ');
    writeln (' ');
    writeln ('---------------------------------------------------------------------');
 writeln ('                   Indica con que reglas quieres jugar               ');
 writeln ('---------------------------------------------------------------------');
 writeln (' Selecciona con cuantas celula vecinas vivas "nace" una nueva celula ');
 writeln ('---------------------------------------------------------------------');
 writeln ('     Deben ser de 1 a 8. Despu‚s de seleccionar, pulsa intro         ');
 writeln ('---------------------------------------------------------------------');
 writeln (' ');
 writeln (' ');
 read (X);
    END;
 writeln (' ');
 writeln (' ');
 writeln ('---------------------------------------------------------------------');
 writeln ('                   Indica con que reglas quieres jugar               ');
 writeln ('---------------------------------------------------------------------');
 writeln (' Selecciona con cuantas celula vecinas vivas como m¡nimo una celula  ');
 writeln ('---------------------------------------------------------------------');
 writeln (' sigue viva.  Deben ser de 1 a 8. Despu‚s de seleccionar, pulsa intro');
 writeln ('---------------------------------------------------------------------');
 writeln ('    Y l¢gicamente, no puede ser el mismo n£mero que la hacen nacer   ');
 writeln ('---------------------------------------------------------------------');
 writeln (' ');
 writeln (' ');
 read (Y);
 WHILE ((Ioresult<>0) OR (Y<1) OR (Y>8) OR (Y=X))
    DO
    BEGIN
    writeln (' ');
    writeln (' Selecci¢n no correcta ');
    writeln (' ');
    writeln (' ');
    writeln ('---------------------------------------------------------------------');
 writeln ('                   Indica con que reglas quieres jugar               ');
 writeln ('---------------------------------------------------------------------');
 writeln (' Selecciona con cuantas celula vecinas vivas como m¡nimo una celula  ');
 writeln ('---------------------------------------------------------------------');
 writeln (' sigue viva.  Deben ser de 1 a 8. Despu‚s de seleccionar, pulsa intro');
 writeln ('---------------------------------------------------------------------');
 writeln ('    Y l¢gicamente, no puede ser el mismo n£mero que la hacen nacer   ');
 writeln ('---------------------------------------------------------------------');
 writeln (' ');
 writeln (' ');
 read (Y);
    END;
 writeln (' ');
 writeln (' ');
 writeln ('---------------------------------------------------------------------');
 writeln ('                   Indica con que reglas quieres jugar               ');
 writeln ('---------------------------------------------------------------------');
 writeln (' Selecciona con cuantas celula vecinas vivas como maximo una celula  ');
 writeln ('---------------------------------------------------------------------');
 writeln (' sigue viva.  Deben ser de 1 a 8. Despu‚s de seleccionar, pulsa intro');
 writeln ('---------------------------------------------------------------------');
 writeln ('    Y l¢gicamente, no puede ser el mismo n£mero que la hacen nacer   ');
 writeln ('---------------------------------------------------------------------');
 writeln ('            Ni el mismo n£mero que has indicado como m¡nimo          ');
 writeln ('---------------------------------------------------------------------');
 writeln (' ');
 writeln (' ');
 read (Z);
 WHILE ((Ioresult<>0) OR (Z<1) OR (Z>8)OR (Z=X) OR (Z=Y))
    DO
    BEGIN
    writeln (' ');
    writeln (' Selecci¢n no correcta ');
    writeln (' ');
 writeln (' ');
 writeln (' ');
 writeln ('---------------------------------------------------------------------');
 writeln ('                   Indica con que reglas quieres jugar               ');
 writeln ('---------------------------------------------------------------------');
 writeln (' Selecciona con cuantas celula vecinas vivas como m¡nimo una celula  ');
 writeln ('---------------------------------------------------------------------');
 writeln (' sigue viva.  Deben ser de 1 a 8. Despu‚s de seleccionar, punsa intro');
 writeln ('---------------------------------------------------------------------');
 writeln ('    Y l¢gicamente, no puede ser el mismo n£mero que la hacen nacer   ');
 writeln ('---------------------------------------------------------------------');
 writeln ('            Ni el mismo n£mero que has indicado como m¡nimo          ');
 writeln ('---------------------------------------------------------------------');
 writeln (' ');
 writeln (' ');
 read (Z);
    END;
 regla_1:=X; {ASIGNO EL VALOR INTRODUCIDO A LA VARIABLE DE SALIDA}
 regla_2:=Y; {ASIGNO EL VALOR INTRODUCIDO A LA VARIABLE DE SALIDA}
 regla_3:=Z; {ASIGNO EL VALOR INTRODUCIDO A LA VARIABLE DE SALIDA}
{$I+}
END;
{**************************************************************************}
PROCEDURE modo_ejecucion (VAR modo1:char);
VAR
a:char; {VARIABLE DE PASO A PASO}

BEGIN
{$I-}
writeln (' ');
writeln (' */*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*');
writeln (' ');
writeln ('     Indica el modo de ejecuci¢n que deseas       ');
writeln (' ');
writeln (' Selecciona "P" para controlar tu los movimientos ');
writeln ('                y hacerlo paso a paso             ');
writeln (' Selecciona "S" para que el juego se desarrolle   ');
writeln ('                s¢lo y ver £nicamente el resultado');
writeln (' ');
writeln ('             Selecciona y pulsa intro');
writeln (' */*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*');
writeln (' ');
a:=readkey;
a:=upcase(a);
  IF a='S'
  THEN
  modo1:='S'
  ELSE
    IF a='P'
    THEN
    modo1:='P'
    ELSE
     REPEAT
    writeln (' ');
    writeln (' Selecci¢n no correcta ');
    writeln (' ');
writeln (' ');
writeln (' */*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*');
writeln (' ');
writeln ('     Indica el modo de ejecuci¢n que deseas       ');
writeln (' ');
writeln (' Selecciona "P" para controlar tu los movimientos ');
writeln ('                y hacerlo paso a paso             ');
writeln (' Selecciona "S" para que el juego se desarrolle   ');
writeln ('                s¢lo y ver £nicamente el resultado');
writeln (' ');
writeln ('             Selecciona y pulsa intro');
writeln (' */*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*');
writeln (' ');
a:=readkey; {COGE A DEL TECLADO DIRECTAMENTE, SIN INTRO}
a:=upcase(a);{PASA DE MINUSCULAS A MAYUSCULAS LOS CARACTERES}
  UNTIL
  ((IORESULT<>0) OR (a='S') OR (a='P'));
  modo1:=a;
END;
{**************************************************************************}
PROCEDURE tres;
BEGIN
 writeln (' LO SIENTO, AUN NO LO SE HACER');
 readln;
END;
{**************************************************************************}
PROCEDURE cuatro;
BEGIN
 writeln (' LO SIENTO, ESTA TAMPOCO AUN');
 readln;
END;
{**************************************************************************}
PROCEDURE dibuja(lado2:integer; var vatablero4:vetablero);
{REALIZA EL DIBUJO DEL TABLERO SELECCIONADO}
VAR
a:integer;
b:integer;
vatablero5:vetablero;
BEGIN
a:=0;
b:=0;
FOR b:=1 TO lado2 DO
 BEGIN
  FOR a:=1 TO lado2 DO
  write (vatablero5 [a,b]);
  writeln;
 END;
 BEGIN
 writeln (' LO SIENTO, AQUI TERMINA ESTA SELECCION DEL MENU QUE TENGO SIN TERMINARA');
 writeln (' porque aunque no he conseguido sacarlo por pantalla, ya he pedido');
 writeln (' la probabilidad, he generado el aleatorio entre 0 y 1 y ademas e ');
 writeln (' he asignado el caracter -X- para casillas vivas y el - - para las muertas');
 readln;
 WRITELN;
 readln;
END;
END;
{**************************************************************************}


PROCEDURE asignacion_menu (seleccion_menu:integer; vatablero2:vetablero);

{PROCEDIMIENTO QUE ENVIA LA ACCION SELECCIONADA POR EL JUGADOR
A LA PARTE DEL PROGRAMA QUE LE TOCA}
{RECIBO LA VARIABLES E_P_ASIGNACION_MENU QUE ES EL NUMERO
SELECCIONADO DEL MENU Y LA VARIABLE VATABLERO QUE ES LA VARIABLE DE TIPO
VECTORTABLERO}

VAR

lado_seleccionado:integer; {SELECCION DEL LADO INDICADO POR EL JUGADOR}
prob_vida:real; {VALOR DE PROBABILIDAD INDICADO POR EL JUGADOR PARA VIDA EN ESTADO INICIAL DEL JUEGO}
resultado:char; {CARACTER QUE ME DEVUELVE EN CASO DE CASILLA VIVA O MUERTA, SI VIVA -X- SI MUERTA - -}
n_turnos:integer; {VARIABLE QUE ALMACENA EL NUMERO DE TURNOS SELCCIONADO}
XX:integer; {NUM DE CELDAS VECINAS QUE HACEN NACER A UNA CELDA}
YY:integer; {NUM MINIMO DE CELDAS VECINAS QUE MANTIENEN VIVA A UNA CELDA}
ZZ:integer; {NUM MAXIMO DE CELDAS VECINAS QUE MANTIENEN VIVA A UNA CELDA}
modo:char; {SELECCION DE MODO DE EJECUCION, SERA -P- SI PASO A PASO O -S- SI SOLO RESULTADO}
vatablero3:vetablero;


 BEGIN
 lado_seleccionado:=0; {INICIALIZO VARIABLE}
 n_turnos:=0;   {INICIALIZO VARIABLE}
 XX:=0;  {INICIALIZO VARIABLE}
 YY:=0;  {INICIALIZO VARIABLE}
 ZZ:=0;  {INICIALIZO VARIABLE}
 resultado:=' ';
   CASE seleccion_menu
   OF
   1: {SI SELECCION ES 1}
      BEGIN
      lado (lado_seleccionado);
      {LLAMO A LADO Y ALMACENO EL VALOR DEL LADO SELECCIONADO}
      probabilidad_vida (prob_vida);
      {LLAMO A PROBABILIDAD_VIDA Y ALMACENO EL VALOR SELECCIONADO}
      compara (prob_vida, random, resultado);
      {LLAMO A COMPARA, LE ENVIO LA PROBABILIDAD SELECCIONADA Y EL
      EL ALEATORIO QUE ME GENERA EL RANDOM Y ALMACENO EL RESULTADO, QUE YA ES LA
      FORMA DE LA CASILLA DE X SI VIVA Y ESPACIO SI MUERTA}
        FOR vatablero3 [1,1]:=resultado
        TO vatablero3 [1,20]
        DO
          BEGIN
          FOR
          vatablero3 [1,1]:=resultado
          TO
          vatablero3 [20,1]
          DO
          dibuja (lado_seleccionado, vatablero3);
          END;
        {LLAMO A DIBUJA Y LE ENVIO EL VALOR DEL LADO_SELECCIONADO
        PARA QUE SEPA EL TAMA¥O DE LA CUADRICULA Y EL TIPO DE LA CUADRICULA}
      END;
   2: {SI SELECCION ES 2}
    BEGIN
    ejecucion_turnos (n_turnos);
    {LLAMO A EJECUCION TURNOS Y GUARDO EL NUMERO SELECCIONADO}
    ejecucion_reglas (XX, YY, ZZ);
    {LLAMO A EJECUCION_REGLAS Y ME DEVUELVE LAS 3 QUE DEBE
    SELECCIONAR EL TITULAR}
    modo_ejecucion (modo);
    {LLAMO A MODO EJECUCION Y ALMACENO LA FORMA DE JUEGO SELECCIONADA}
    END;
  3:tres; {SI SELECCION ES 3}
  {LLAMO A TRES}
  4:cuatro; {SI SELECCION ES 4}
  {LLAMO A CUATRO}
END;
END;

{}
{ PROGRAMA    PROGRAMA    PROGRAMA    PROGRAMA    PROGRAMA    PROGRAMA     }
{}
VAR
s_p_menu:integer; {SALIDA DEL PROCEDIMIENTO MENU}
vatablero:vetablero; {VARIABLE QUE CONTIENE EL VECTOR}

BEGIN
clrscr;
randomize;
menu (s_p_menu); {RECIBO EL VALOR DE LA SELECCION EN EL PROCEDURE MENU}
asignacion_menu (s_p_menu, vatablero); {ENVIO VALOR DE LA SELECCION Y TABLERO
AL PROCEDURE ASIGNACION_MENU}




 
 ----------------------------  (añadido tras someter) ---------------------------- 

  22:05:56  11/12/09
   -> Segun los datos introducidos los ficheros son: 
G14P11D2
 -> Los autores del trabajo son: 
 BUJEDA RAMI, TOMAS
 
 
 Nombres originales de los archivos entregados ->  VIDA2_3.PAS, texto.txt