Pascal/Turbo Pascal - consulta

buenas necesito ayuda por favor pa realizar este proyecto...que a continuacion les envio..tengo 9 dias para entregarlo...gracias:

Proyecto No. 1: El juego de la vida
El juego de la vida es el mejor ejemplo de un autómata celular, diseñado por el matemático británico John Horton Conway en 1970.
Desde un punto de vista teórico, es interesante porque es equivalente a una máquina universal de Turing, es decir, todo lo que se puede computar algorítmicamente se puede computar en el juego de la vida.
Desde su publicación, ha atraído mucho interés debido a la gran variabilidad de la evolución de los patrones. Se considera que la vida es un buen ejemplo de emergencia y autoorganización. Es interesante para los científicos, matemáticos, economistas y otros observar cómo patrones complejos pueden provenir de la implementación de reglas muy sencillas.
El juego de la vida es en realidad un juego de cero jugadores, lo que quiere decir que su evolución está determinada por el estado inicial y no necesita ninguna entrada de datos posterior. El "tablero de juego" es una malla formada por cuadrados ("células") que se extiende por el infinito en todas las direcciones. Cada célula tiene 8 células vecinas, que son las que están próximas a ella, incluso en las diagonales. Las células tienen dos estados: están "vivas" o "muertas". El estado de todas las células se tiene en cuenta para calcular el estado de las
Se pide implementar el juego de la vida.
El juego utiliza un tablero que, para esta implementación, tendrá una dimensión de 15 filas por 20 columnas. Cada celda de este tablero podrá estar ocupada por una célula o podrá estar vacía. En el juego se parte de una configuración inicial de células (suministrada por el usuario o generada al azar) y se deja evolucionar esta población de acuerdo a las siguientes reglas definidas por Conway:
• Una célula presente en la generación t desaparecerá en la generación t+1 si:
- Se encontraba rodeada por menos de 2 células (muerte por soledad)
- Se encontraba rodeada por mas de 3 células (muerte por superpoblación)
• Una célula nacerá (aparecerá) en la generación t+1 en una celda vacía si esa celda se encontraba rodeada por exactamente tres células vivas en la generación anterior.
• En cualquier otro caso, una celda no variará su estado al pasar de la generación t a la t+1.

Ejemplos:

X - -
- x -
- - -
X X X
- X -
- - X
X - X
- - -
- - X
X - -
- x -
- - X

La célula central desaparecerá en la siguiente generación por soledad (1 vecino) la célula central morirá en la siguiente generación por superpoblación (4 vecinos) Una nueva célula nacerá en la siguiente generación en la casilla central (3 vecinos) La celda central seguirá conteniendo una célula viva en la siguiente generación (2 vecinos)
Algunas configuraciones iniciales interesantes:
x x -
x - x
- x x
- - -
x x x
- - -
- x -
- x x
x - x
- x x
x x -
- x -

patrón estático patrón oscilante patrón "deslizador" patrón simple de evolución muy compleja

Notas Importantes
a) A efectos de aplicación de las reglas, una celda del tablero se considerará rodeada por ocho celdas vecinas (celdas a izquierda-derecha, arriba-abajo y las cuatro celdas contiguas en diagonal).
b) La supervivencia, nacimiento o muerte de las células deberá determinarse considerando sus vecinos en esa generación. Es decir, no deberán realizarse cambios sobre el tablero hasta que no se haya determinado el destino de todas las celdas en la siguiente generación.
Implementación
El programa incorporará las características que se describen a continuación.
El programa aceptará o generará una configuración inicial de células sobre el tablero definido. El programa permitirá tanto calcular la evolución de esta población de generación en generación como calcular de una vez el resultado tras N generaciones (parámetro suministrado por el usuario). Tras mostrar por pantalla la población obtenida (en la generación siguiente en el primer caso o tras N generaciones en el segundo), el programa permitirá:
a) Terminar el juego
b) Editar de forma manual el tablero (eliminando células y/o creando otras nuevas).
c) Continuar calculando nuevas generaciones.
El programa permitirá definir la configuración inicial por cualquiera de estos procedimientos:
a) Leyendo datos suministrados por teclado.
b) Generando aleatoriamente la configuración inicial. En este modo, el usuario fijará por teclado el número de celdas ocupadas por células, y el programa distribuirá estas células de forma aleatoria sobre el tablero.
El programa permitirá configurar el comportamiento del juego con células que se encuentren en los bordes del tablero. En particular, será posible seleccionar cualquiera de estas posibilidades:
a) Tablero plano. Una celda en el borde del tablero evolucionará como si todos sus vecinos no accesibles fueran celdas vacías.
b) Tablero cilíndrico. En este modo, se tomarán la primera y última columnas del tablero como contiguas.
c) Tablero toroidal. En este modo, se considerarán como contiguas tanto la primera y última columnas del tablero como la primera y última fila.
Evaluación
1.- No se evaluará el aspecto gráfico más allá de la presentación básica del juego.
2.- Se evaluará positivamente:
a) Modularidad y estructuración del código.
b) Cantidad y calidad de los comentarios.
c) Claridad en el código.
d) Calidad de la documentación asociada, memoria y análisis.
e) Uso de estructuras de datos adecuadas al problema.
f) Nombre de las variables y constantes acordes a la función que desempeñan en el programa.

3.- Se penalizará fuertemente:
a) Uso de programación no estructurada, es decir uso de goto, exit y halt.
b) Uso de variables globales dentro de funciones o procedimientos.
c) Funciones o procedimientos no documentados. Cada función o procedimiento debe tener unos comentarios de cabecera con información de:
1) Qué es lo que realiza la función.
2) Qué parámetros de entrada recibe, y cuál es la función de cada uno de ellos.
3) Qué parámetros de salida recibe, y cuál es la función de cada uno de ellos.Q
4) Qué valor devuelve.
5) Requisitos, o precondiciones en los valores de los parámetros en la llamada a la función, y qué condiciones de error se manejan dentro de cada función.
d) Paso de parámetros innecesarios a funciones y procedimientos.
e) Programas que funcionen incorrectamente.
Se deberá entregar, en un CD libre de virus:
a) Programas fuentes, debidamente documentados.
b) Memoria, en formato txt, con información sobre:
1) Las estructuras de datos utilizadas.
2) Análisis de cómo se ha implementado el juego, módulos principales, comunicación entre
ellos, etc.
3) Qué pruebas se han efectuado, y cuáles han sido los resultados.
4) Qué ficheros son necesarios para la compilación y ejecución del juego.
5) Programas ejecutables

Muy Interesante.
Puedes enviarme un correo y hablamos de cuanto puede estar costando realizar este proyecto con toda la documentacion y fuentes.

Buenas

Necesito ayuda por favor para realizar este proyecto...que a continuacion les envio..tengo que entregarlo después del puente. Se gratificará, siempre dependiendo de la nota obtenida, lógicamente.

Muchas gracias:


OBJETIVOS: Se propone en esta práctica un ejercicio que debe ser resuelto utilizando los conceptos de vector, registro y la posible combinación de estos para representar realidades más complejas. El objetivo de esta práctica es el dominio de los mencionados conceptos para realizar un adecuado diseño de datos, de las operaciones de inserción y borrado en vectores multidimensionales y el acceso a ficheros. Para la realización de la práctica podrán utilizarse todos los elementos de prácticas anteriores. Además, deberán definirse y utilizar procedimientos y funciones cuando sea oportuno y no estará permitido el empleo de variables globales.

ENUNCIADO: Se propone la implementación de una versión del juego de la vida (ver http://es.wikipedia.org/wiki/Juego_de_la_vida). El juego de la vida es un juego de cero jugadores, lo que quiere decir que su evolución está determinada por el estado inicial y no necesita ninguna entrada de datos posterior. El "tablero de juego" es una malla formada por cuadrados ("células") que se extiende por el infinito en todas las direcciones. Cada célula tiene 8 células vecinas, que son las que están próximas a ella, incluso en las diagonales. Las células tienen dos estados: están "vivas" o "muertas" (o "encendidas" y "apagadas"). El estado de la malla evoluciona a lo largo de unidades de tiempo discretas (por turnos). El estado de todas las células se tiene en cuenta para calcular el estado de las mismas al turno siguiente. Todas las células se actualizan simultáneamente.

La versión del juego que se pide implementar contará con las siguientes características: el tablero será un cuadrado con un tamaño de entre 4 y 20 casillas por lado (indicado por el usuario). Las transacciones entre cada estado seguirán las siguientes reglas:
• Una célula muerta (apagada) con exactamente X células vecinas vivas "nace" (al turno siguiente estará viva/encendida).
• Una célula viva con entre Y y Z células vecinas vivas sigue viva (encendida), en otro caso muere (se apaga) o permanece muerta (por "soledad" o "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á que tener un menú con las siguientes operaciones:
• Generar mundo aleatorio: Dado el tamaño del lado del tablero y la probabilidad de que cada casilla este viva al inicio del juego (numero entre 0..1), se generará un nuevo tablero aleatoriamente. Es decir, dada una probabilidad (e.g.,0.7), si el numero aleatorio obtenido para una casilla es menor o igual a la probabilidad, se creara viva (encendida); si es mayor, la célula estará inicialmente muerta (apagada);
• Ejecución: Se le pedirá al usuario el número de turnos a ejecutar, las reglas del juego, y el modo de ejecución. Por defecto las reglas del juego serán X=3, Y=2 y Z=3. El modo “Paso a paso” mostrara un nuevo estado cada vez que se pulse el <intro> hasta que se llegue al número de turnos indicado. El modo “Solo resultados” solo mostrará en pantalla el estado final. Cada ejecución será a partir del último estado generado a no ser que se cargue un nuevo estado inicial.
• Cargar Estado Inicial: pide el fichero a cargar (por defecto, el fichero estadoInicial.txt) y lo usa como nuevo estado inicial. Para facilitar esta operación, se os da la función de pascal “cargar_mundo” que carga el estado inicial de fichero y devuelve una cadena de texto con cada fila separada por el carácter | (<Fila>|<Fila>|<Fila>|<Fila>…). Para probar vuestro programa, se os da un fichero de texto con un posible estado inicial.
• Salir: termina el programa. El programa solo terminará cuando se ejecute esta opción del menú. En el resto de operaciones, después de ejecutarse, se mostrará otra vez el menú y se solicitará al usuario que seleccione otra operación.

En la segunda entrega, se incluirán las siguientes operaciones,

La operación de ejecución dará la opción de guardar todos los estados que se han ido generando (el usuario indica el nombre del fichero, por defecto log.bin).

Se añadirá una nueva operación que cargue el fichero de log y analice si en esa ejecución hay dos estados iguales y no ha habido una extinción (todo muerto). Es decir, se analiza si el sistema es estable.

Mejora Opcional (10% adicional de nota – Nota máxima = 10)

En la ejecución se podrá seleccionar entre dos tipos de mundos, el plano (por defecto) y otro toroidal en el que los extremos están conectados entre sí. E.g., la casilla (1,1) tiene de vecinas a la (1,n), (n,1), y (n,n) entre otras.

PREREQUISITOS Y POSTCONDICIONES

Los mismos que la practica 1: Para que la práctica pueda ser corregida, y por tanto calificada con una nota superior a 0, el programa no dará errores de compilación. Junto al fichero con el código fuente del programa PASCAL realizado se entregará un fichero de texto con los datos personales del autor/autores de la práctica y la documentación del programa. En la documentación se ha de hacer hincapié en la explicación de cada uno de los módulos: Breve descripción de para qué sirve el módulo, porqué se ha construido como tal, de qué otros módulos hace uso o si es llamado por otros módulos del programa. Descripción de los parámetros y del mecanismo de transmisión (entrada, salida,...) elegido para cada unos de ellos (justificando la elección). Si el módulo implementa una operación compleja, breve descripción de cómo resuelve la operación, poniendo énfasis en las decisiones de diseño que se hayan tomado.

Requisitos adicionales: El diseño de las estructuras de datos se adecuará a las necesidades de representación de las entidades descritas en el enunciado del problema. Además deberá ser debidamente explicado en el archivo entregado junto con el código fuente.

SE VALORARÁ:

• Definición de los tipos de datos utilizados (estructura, nombrado), uso de variables y constantes adecuadas: 20%
• La modularidad del diseño efectuado (funciones y procedimientos, paso de información por parámetros) 15% de la puntuación máxima. No se deben utilizar VARIABLES GLOBALES. Su uso dará lugar a la calificación de este apartado con un 0.
• Funcionamiento correcto del programa (avance según reglas, gestión turnos,...): 30%
• Estructuración del código, presencia de comentarios, documentación: 15%
• Robustez y corrección en introducción datos: 10%
• Claridad y usabilidad de la interfaz: 10%

La obtención de una nota superior o igual a 1 punto sobre 10 dará la posibilidad de realizar la segunda entrega con el programa completo. La nota de la práctica será la obtenida en la segunda entrega.

ESTADO INICIAL

0000000000
0001100000
0000000000
0000000000
0001100010
0001100000
0000000000
0000001110
0000000000
0000000000

CARGAR MUNDO

program cm;

function cargar_mundo(nombreFich: string): string;
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;

var
mundo:String;

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

end.