+---------------------------------------------------------------------------------------------------+ + PRÁCTICA 2 DE DISEÑO "Juego de la Vida" + + + + Autores: + + Óscar Royo Oliveros + + Adrián Rupérez Casañal + + + + Grupo prácticas: + + + + G01 P.04 + + + +---------------------------------------------------------------------------------------------------+ Se nos pide realizar un programa en Turbopascal que sea una versión del juego de la Vida para cero jugadores. Esto quiere decir que su evolución está determinada por un estado inicial y no necesita ninguna entrada de datos posterior. El tablero será un cuadrado de con un tamaño de entre 4 y 20 casillas por lado. Cada célula (casilla) tiene 8 células vecinas, que son las que están próximas a ella incluso en las diagonales. Éstas tienen dos estados: están "vivas" o "muertas". El estado de cada una de ellas en el turno siguiente depende del estado de todas sus células vecinas. Las transacciones entre cada estado seguirán las siguientes reglas: *Una célula muerta con exactamente X células vecinas vivas "nace". *Una célula viva con entre Y y Z células vecinas vivas sigue viva, en otro caso se muere o permanece muerta (por soledad o por superpoblación). *El mundo es plano y en los bordes no es posible la vida. Es decir, las casillas de las filas y columnas primera y última nunca tendrán células vivas. El programa tendrá un menú con las siguientes operaciones: -Generar mundo aleatorio. -Ejecución. -Cargar estado inicial. -Salir. MÓDULOS UTILIZADOS: -El procedimiento menu principal, es un procedure usado para mostrar por pantalla el menú principal del juego. Sólo utiliza un parámetro de entrada (tablero1) que es una variable que se ha definido en el programa principal. Es el único subprogrmama que es llamado desde el programa principal y hemos definido dos variables locales dentro de él que son empleadas a lo largo del módulo. Según la opción elegida por el usuario, éste módulo llamará a otros subprogramas: mundoaleatorio, ejecucion, cargarestadoinicial y salir. -El procedimiento Mundo aleatorio es el procedure que crea el tablero a gusto del usuario. Le pide que introduzca el tamaño del lado del tablero y la probabilidad de que cada célula esté viva o muerta. Utiliza un parámetro de entrada (tablero) y otro de entrada-salida (tamaño del tablero) ya que el tamaño del tablero se utilizará en otros subprogramas. Al pedir los datos, los pide de manera robusta para que los datos introducidos sean correctos. Hemos utilizado operadores relacionales para evaluar si el dato obtenido del teclado, es válido o no, añadiendo operadores lógicos, directivas al compilador ({$I-}, {$I+}) y la función del sistema IOResult. Este procedure a su vez llama al procedimiento dibujartablero para que saque por pantalla el tablero que se a creado. -El procedimiento Ejecución es el procedimiento que ejecuta el juego. Muestra por pantalla las reglas del juego. Le pregunta al usuario si quiere introducir él los valores de X, Y y Z o utilizar los valores por defecto. Luego le pide que introduzca el número de turnos y como quiere que sea el modo de juego: paso a paso o solo resultados. Los parámetros que emplea son dos de entrada: el tablero y el tamaño del lado del tablero. Hemos creado 6 variables locales dentro de este subprograma que son de tipo simple: integer. Al pedir los datos, también los pide de manera robusta para que los datos introducidos sean correctos; al igual que en el procedure mundo aleatorio. Según el modo de juego que pida el usuario, éste módulo llama a su vez al procedure jugarpasoapaso o al procedure jugarsoloresultados. -El procedimiento jugarpasoapaso es un procedure, el cual llama a otro procedimiento jugar; pero al final de cada turno, tiene un readln que le hace mostrar cada turno y dibujar el tablero. Está definido con 5 parámetros de entrada (valor de x, valor de y, valor de z, turnos y tamaño del tablero) y con uno de entrada salida (tablero). A su vez se ha definido también una variable local para hacer un for que llame al procedimiento jugar durante los turnos determinados. Este procedimiento llama a dos subprogramas, jugar y dibujar tablero; para que en cada turno haga lo indicado y el usuario le tenga que dar a la tecla enter para pasar al siguiente turno. -El procedimiento jagarsoloresultados es un procedure igual que el anterior, con la única diferencia de que al final de cada turno no tiene un readln para hacerle mostrar el siguiente turno, sino que él solo ejecuta todos los turnos y solo muestra el último. Igual que en el anterior, llama a dos subprogramas, jugar y dibujartablero. -El procedimiento jugar es el que se encarga de realizar todas las operaciones para que en el siguiente turno las células muertas "vivan", permanezcan en el estado en el que se encuentran ó si están vivas, "mueran". Utiliza 4 parámetros de entrada, uno de entrada-salida y hemos definido 2 variables locales. Hemos creado otro tablero auxiliar que se hace una copia completa del tablero que ya teniamos para poder ir mirando en él las células vecinas muertas y vivas y cambiarlas en cada turno en nuestro tablero original. Ya que de lo contrario, de no tener este vector, los cambios producidos en cada célula nos cambiarían los de los siguientes cambios. A lo largo de todo el tablero, excepto en los bordes, se llama a la función casillasvecinas que nos dice el número de casillas vecinas vivas que tenemos alrededor de la célula en la que nos encontramos. Con este dato, ya sabemos el comportamiento que va a tener la célula en la que estamos. Este procedimiento, unicamente llama a la función casillasvecinas. -El procedimiento dibujartablero, es un procedure que hemos empleado para dibujar el tablero del Juego de la Vida. Es una matriz cuadrada. Los parámetros que emplea son parámetros de entrada ya que solo le hace falta saber el contenido del tablero y su tamaño. Hemos definido 3 variables locales para el uso de varias veces de la sentencia for...do. -La función casillasvecinas es una función a la que se llama desde el procedimiento jugar, y nos da un número de tipo integer con la cantidad de células vecinas vivas alrededor de la célula en la que nos encontramos. Recorre las 8 casillas vecinas de alrededor una a una y si son 1 (vivas), sumamos 1 al contador que lo hemos inicializado a cero. Así sabremos el número de casillas vecinas vivas. Al hacerlo con la sentencia for...do; también incluye en el contador la casilla en la que nos encontramos, por lo que si está viva, al finalizar la cuenta, le restamos 1 al contador. Está función es llamada con 4 parámetros de entrada y nos devuelve un valor integer (entero). También hemos definido 3 variables locales: el contador y las variables x,y para recorrer el tablero. Al finalizar la función, asignamos el contador a la funcion (casillasvecinas:=contador). El programa principal comienza llamando al procedure menuprincipal y dentro de éste, se van llamando a los distintos procedimientos según la opción que elija el usuario. Este procedimiento, tiene un repeat hasta que la variable opcion sea igual a 4, es decir..salir del programa. - Observaciones: Hemos definido 3 constantes al principio del programa: *[0 y 1] => Para que las casillas del tablero sean células muertas (0) ó células vivas (1). Ya que éstas se emplean a lo largo de todo el programa. *[MAX=20] => Para el máximo tamaño del tablero. En la declaración de los TIPOS, hemos declarado un solo tipo: Ttablero = Array [1..MAX,1..MAX] of integer; para los vectores de los tableros. ---------------------------- (añadido tras someter) ---------------------------- 23:00:27 11/12/09 -> Segun los datos introducidos los ficheros son: G01P04D2 -> Los autores del trabajo son: Royo Oliveros, Óscar Rupérez Casañal, Adrián Nombres originales de los archivos entregados -> Juego de la vida.PAS, JUEGO DE LA VIDA.txt