PROGRAMA JUEGO DE LA VIDA

AUTORES:

David Pellejero Vela (NIA:556994) y Jorge Anadón García (NIA: 511636).

DOCUMENTACIÓN:

NOTA IMPORTANTE: para cargar el estado inicial al usuario se le pide que introduzca el estado inicial pero el nombre de este 
fichero no es que ponia el enunciado por defecto "estadoInicial.txt" sino "mundo.txt" debido a que no nos lo admitia creemos
debido a que el nombre es mas grande que lo que MS-DOS admite (8 caracteres) y lo hemos modificado porque asi lo carga.
Además hemos creido oportuno añadir una opción mas al menu para cambiar las reglas del juego, la cual no estaba en principio 
en el enunciado del juego asi cumplimos con todos los requisitos del enunciado y a la vez hacemos el juego mas completo y mas
facil.

Para resolver el problema que se nos presentaba hemos decidido resolverlo mediante programación modular
utilizando vectores y ficheros. También se ha declarado la unidad CRT (Uses crt) al principio del programa,
para poder hacer  uso de los dispositivos de entrada y salida. Todos los datos que tiene que introducir el usuario
están programados de manera robusta empleando la función IOResult de la unidad System.

Después de declarar la unidad CRT hemos definido el tablero como tipo tablero que es una matriz de vectores de tipo boolean,
ya que las células solo tienen dos estados (vivas o muertas). 

Descripción de módulos (procedimientos y funciones)

Los modulos a los cuales hacemos referencia en el programa principal son los siguientes:

PROCEDIMIENTO GENERARMUNDOALEATORIO: en este módulo se declaran como parametros tablero que es de tipo tablero
y tamTablero que es de tipo integer. Las dos variables estan precedidas con "var" para quedn el programa principal
se vean reflejados los cambios que sufren estas variables. I y j son dos variables locales que serviran para contabilizar 
las filas y las columnas del tablero. Las variables probabilidadCelula y probabilidadTablero son dos variables de tipo real
la primera va almacenado la probabilidad  generada aleatoriamente por el programa y la segunda almacena un valor
fijado por el usuario el cual sera comparado con el de probabilidadcelula y asi viviran o moriran posterirmente las células.
Luego se utilizan un par de bucles repeat-until para que el usuario introduzca el tamaño del tablero y la probabilidad de que
la célula este viva. Para recorrer el tablero y rellenar las células vivas o muertas se ha utilizado un par de bucles for-do para
recorrer el tablero y un condicional para comprobar si las células estan vivas o muertas.

PROCEDIMIENTO CARGARESTADOINICIAL: los parametros de este módulo son las mismos que en anterior y están declarados
de la misma manera. Como variables locales se emplean: fichero de tipo texto, nobrefich y linea de tipo cadena de caracteres
y la anteror mencionada j de tipo entero. Luego el procedimiento comienza pidiendo el nombre del fichero (mundo.txt) y lo 
asigna a la varible nombrefich mediante un condicional. Después carga el tablero del fichero elegido mediante el comando 
assign para abrirlo y poder modificarlo y luego leerlo con el comando reset. Para leer todo el fichero hemos recurrido a un
bucle  iteractivo While-not-do con la función lógica Eof que devuelve el valor booleano verdad cuando se lee la ultima linea del 
fichero.

PROCEDIMIENTO DIBUJARTABLERO: los parametros de este módulo son los mismos que en los 2 modulos anteriores a diferencia
de que no los hemos declarado precedidos de "var" debido a que sus valores no tienen que verse modificados en el programa 
principal. Como variables locales las anteriormente mencionadas i y j para recorrer el tablero. Comenzamos el módulo llamando 
al procedimiento clrscr de la unidad CRT par limpiar la pantalla. Luego se dibuja el tablero mediante 2 bucles iteractivos for-do 
sometidos el uno al otro con las variables i y j también se emplea el procedimiento textcolor de la unidad CRT y código ascii.

FUNCIÓN CALCULOVECINOS: en esta función hemos declarado como parametros de la misma: tablero de tipo tablero e i y j
de tipo integer y la función nos devuelve un integer. Como variables locales vi y vj de tipo integer para recorrer las filas y las 
columnas del tablero y la variable resultado tambien de tipo entero para guardar el resultado del número de vecinos. Luego 
empleamos un par de bucles iteractivos for-do que comprueban el estado de las casillas anterior y posterior de la casilla en la
que se encuantran sumandole o restandole una unidad a las variables i y j. Luego tenemos un condicional para que vaya evaluando
todas las casillas del tablero. Luego a la función le asignamos el resultado.

FUNCIÓN FUTUROCÉLULA: esta función emplea como parametros: tablero, de tipo tablero y x,y,z,i y j de tipo entero y devuelve
un booleano. Como variables locales emplea: vecinos, de tipo integer y resultado, esta vez de tipo booleano. Luego empleamos
3 condicionales para comprobar si una celula esta viva o muerta. El primer condicional comprueba si una célula esta el cualquier
casilla de los bordes del tablero y nos devolveria como resultado falso para matarlas. El segundo condicional nos comprueba si las células
muertas tienen X células muertas a su alrededor para asi devolver como resultado verdadero y la célula nazca. El tercer condional va 
unido al al anterior y esta diseñado de tal manera que si por el contrario la célula analizada en ese momento esta viva y el número de 
de sus vecinos es inferior al valor de Y o mayor que el valor de Z la célula pase a estar muerta y se debulve el resultado a la variable 
tablero.

FUNCIÓN NUMCELULASVIVAS: Esta función tiene como parametros los mismos que el procedimento dibujar tablero y nos devulve
un integer. Al igual que en dibujar tablero declaramos como variables locales i y j para recorrer el tablero y añadimos la variable resultado
para asignar el valor a la función. Luego creamos un bucle for-do para calcular las células vivas en el tablero y le asignamos el resultado a
la función.

PROCEDIMIENTO CAMBIARPARAMETROS: declaramos como parametros X,Y y Z de tipo entero precedidas de "var" para que se contabilice
en el programa principal. Como variable local declaramos opciónjuego de tipo entero. Luego tenemos un par de bucles repeat-until para que
el usuario introduzca correctamente las reglas del juego empleando IOResult para hacer las entradas robustas.

PROCEDIMIENTO EJECUCIÓN: como parametros declaramos tablero, de tipo tablero, tamtablero, de tipo integer, ambas precedidas de "var" 
para hacer referencia al programa principal y X,Y y Z de tipo integer. Luego declaramos el tipo modojuego con los parametrso paso a paso 
y resultdos. Como variables locales las anteriormente mencionadas i y j para recorrer el tablero de tipo integer, numturnos de tipo integer
y por ultimo nueboTablero de tipo tablero y modoJuego de tipo ModoJuego. Para comenzar empleamos un par de bucles Repeat-until para
que el usuario introduzca el número de turnos y el modo de juego ambas entradas robustas empleando IOResult. Luego se emplea un condicional
asignar la opción de juego que introduce el usuario a la variable modo juego. Para ejecutar decidimos emplear un bucle While-do que mientras los
turnos son mayores de 0 y el numero de celulas vivas tambien es mayor que 0 ejecuta un condicional que llama a dibujartablero si el modo juego 
es pasopaso y un bucle iteractivo for-do que recalcula el tablero y una vez acabados los turnos o muertas todas las células muestra los resultados.

PROCEDIMIENTO MOSTRARMENU: en este procedimiento no declaramos ninguna variable. Solamente comienza llamando al procedimiento clrscr de la
unidad CRT y luego se describen las opciones del menu mediante el procedimiento de la unidad System writeln.

PROGRAMA PRINCIPAL: en el programa principal hemos declarado las variables que se van a ver alteradas por los módulos en los cuales anteriormente
se les ha colocado "var" y que ahora se van a ver alteradas por las llamadas a dichos modulos. estas son tablero, de tipo tablero y tamtablero, 
opcionmenu, X, Y y Z de tipo integer. Para comenzar limpiamos la pantalla mediante clrscr e inicializamos el generador de numeros aleatorios mediante
el procedimiento randomize. Después inicializamos X, Y y Z a 3, 2 y 3 respectivamente. Para llamar al resto de los módulos emplemos un bucle
repeat-until para llamar a los módulos que una vez llamado al menu y elegida la opción empleamos condicionales para llamar al resto de los modulos
y se vaya ejecutando el programa segun se ha descrito anteriormente hasta que la función IOResult es 0 y la variable opcionmenu es igual a 5.







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

  14:16:24  11/12/09
   -> Segun los datos introducidos los ficheros son: 
G06P05D2
 -> Los autores del trabajo son: 
 Anadón García, Jorge
 Pellejero Vela, David
 
 Nombres originales de los archivos entregados ->  VIDA.PAS, Juego de la vida.txt