Enviado por Franco el 16 de Agosto de 19103 a las 00:48:07:
En respuesta a: necisito un programa en turbo pascal (juego de la vida) enviado por esmael ch el 05 de Agosto de 19103 a las 12:21:33:
aka esta el juego,pero esta en una matriz de 15x20
Program Conway (Input,Output);
Uses Crt;
Const
DimH = 15; {Numero de filas}
DimV = 20; {Numero de columnas}
respuestas: Set Of Char = ['G','g','E','e','T','t'];
{Posibles respuestas que puede introducir el usuario}
Type
tab = Array [1..DimH,1..DimV] Of Char; {Forma del tablero}
RegTablero =
{Registro que contiene el tablero y su forma,las generaciones y
la forma de pasar de generacion (si es de una en una o si son
varias).}
Record
tablero: tab; {Tablero de 15 filas x 20 columnas}
FormaTab: Char; {Forma: Plano, Cilindrico, Toroidal}
ModoGeneracion: Char; {Calcular generaciones de una en una o
un numero determinado de generaciones}
NGen: Integer; {Numero de generaciones a calcular}
gen: Integer; {Muestra por pantalla el numero de generaciones}
cont: Byte; {Para contar las celulas de alrededor}
End;
Var
ConfigTab: RegTablero; {Registro que contiene la configuracion del tablero}
TabAux: tab; {Tablero auxiliar para guardar la generacion}
i,j: Byte; {Variables para los bucles}
resp: String; {Respuesta del usuario a las diferentes opciones}
{--------------------------------------------------------------------------------------}
Procedure LeerTablero(Var t: RegTablero);
{
Entrada: t: Tipo del tablero que vamos a leer.
Funcion: Obtener el tablero desde un fichero introducido por el usuario.
Salida: Tablero con sus celulas correspondientes. Se guarda en la variable
tablero perteneciente al registro dado.
}
Var
nombre: String; {Nombre del fichero}
fich: Text; {Fichero al que asignaremos el nombre}
casilla: Char; {Cada casilla de la matriz de celulas}
Begin
Writeln;
Write(' Introduzca el nombre y la ruta del fichero donde esta el tablero: ');
Readln(nombre); {Leemos el nombre del fichero}
Writeln;
Assign(fich,nombre); {Le asignamos el nombre a fich}
Reset(fich); {Abrimos el fichero}
For i := 1 To DimH Do {Recorremos la matriz [DimH x DimV]}
Begin
For j := 1 To DimV Do
Begin
Read(fich,casilla); {Leemos el caracter del fichero}
If (casilla In ['@','-']) Then
t.tablero[i,j] := casilla {Si es correcto lo acumulamos}
Else {Sino mostramos un mensaje de error}
Begin
Writeln;
Writeln(' El archivo introducido contiene fallos, por favor,');
Writeln(' compruebelo y vuelva a introducir un fichero nuevo.');
Writeln;
LeerTablero(t)
End;
End;
{Si no hemos llegado al final del fichero pasamos a la linea siguiente}
If Not Eof(fich) Then
Readln(fich)
End;
Close(fich);
End; {LeerTablero}
{--------------------------------------------------------------------------------------}
Function NumCorrecto(Var num: Integer): Integer;
{
Entrada: Dato en el que vamos a acumular el valor si es un numero.
Funcion: Procedimiento para saber si el usuario ha introducido un digito o
un caracter que no corresponde a ningun numero.
Controlar que el valor que introduce el usuario es un numero.
Salida: La variable num toma el valor del numero introducido por el usuario.
}
Var
correcto: Boolean;
n: String;
Function EsNumero: Boolean;
{
Funcion: Asegurarnos de que se ha introducido un caracter numerico.
Salida: La Funcion EsNumero toma el valor true si es un caracter numerico.
}
Begin
EsNumero := False; {Inicializamos EsNumero}
If ((Ord(n[i]) >= 48) And (Ord(n[i]) 1) And (i > 1) Then {Si hay mas de un caracter...}
Begin
If EsNumero Then
num := (num * 10) + (Ord(n[i]) - 48)
{Le sumamos las decenas necesarias cada vez que se ejecuta el bucle
y asi vamos obteniendo el numero total}
Else
correcto := False {No se ha introducido un numero}
End
Else {Si solo ha introducido un caracter...}
Begin
If EsNumero Then
num := Ord(n[i]) - 48 {Obtenemos el valor numerico}
Else
correcto := False {No se ha introducido un numero}
End
End; {For}
If Not correcto Then
num := -1 {No vamos a realizar ninguna generacion, el numero no es correcto}
End; {NumCorrecto}
{--------------------------------------------------------------------------------------}
Procedure TabAleatorio(Var Reg: RegTablero);
{
Entrada: Registro donde guardaremos el tablero.
Funcion: Generar una matriz aleatoria de 15x20 con un numero de celulas dado.
Salida: Tablero aleatorio con su numero de celulas correspondientes.
}
Var
ocupadas: Integer; {Casillas que debe contener el tablero}
relleno : Integer; {Numero de casillas que vamos rellenando}
Begin
With Reg Do Begin
Repeat
Writeln;
Write('Casillas ocupadas por celulas (Max = 300): ');
i := NumCorrecto(ocupadas) {Leemos el numero de casillas, chequeamos
que sea correcto y lo acumulamos en ocupadas}
Until (ocupadas >= 0) And (ocupadas '@') Then {Si la casilla no esta ocupada...}
Begin
tablero[i,j] := '@'; {Acumulamos una celula}
relleno := relleno + 1 {Contamos las casillas que rellenamos}
End
{Hasta que hallamos rellenado las casillas necesarias}
Until relleno = ocupadas;
{Rellenamos los espacios del tablero que queden en blanco}
For i := 1 To DimH Do
For j := 1 To DimV Do
If tablero[i,j] '@' Then {Si no hay una celula debe estar vacio}
tablero[i,j] := '-'
End {Reg}
End; {TabAleatorio}
{--------------------------------------------------------------------------------------}
Procedure LimpiaLinea;
{
Funcion: Limpia la linea de la pantalla la cual necesitemos.
}
Begin
Write(' ':48);
End; {LimpiaLinea}
{--------------------------------------------------------------------------------------}
Procedure DatosManual(Var Reg: RegTablero);
{
Entrada: Registro donde vamos a guardar el tablero que editamos manualmente.
Funcion: Permitir al usuario editar manualmente un fichero.
Salida: Tablero con sus celulas correspondientes.
}
Procedure LeeCaracter(Var r: String);
{
Entrada: Caracteres que introduce el usuario (variable r).
Funcion: Leer un caracter para la casilla del tablero.
Salida: Se guarda el caracter en el tablero.
}
Begin
With Reg Do
Begin
Readln(r); {Leemos la casilla}
If (r = '*') Or (r = '@') Then {Quiere que aparezca una celula}
tablero[i,j] := '@'
Else If (r = '-') Or (r = '') Then {Quiere que sea una casilla vacia}
tablero[i,j] := '-'
Else
Begin
Repeat
Gotoxy(2,23);
Write('El caracter introducido no es valido, escriba otro.');
Gotoxy(23,22); {Limpiamos la respuesta anterior}
LimpiaLinea;
Gotoxy(23,22);
LeeCaracter(r);
Gotoxy(2,23); {Limpiamos: "El caracter introducido..."}
Write(' ':51)
Until (r = '@') Or (r = '-') Or (r = '') Or (r = '*');
End;
End; {Reg}
End; {LeeCaracter}
Var x: Byte; {Para mostrar por pantalla los datos}
Begin {DatosManual}
With Reg Do
Begin
ClrScr;
{Mostramos el tablero vacio (solo mostramos las coordenadas)}
Gotoxy(3,1);
Write('ABCDEFGHIJKLMNOPQRST');
For x := 1 To DimH Do
Begin
Gotoxy(1,x+1);
Write(x)
End;
{Pedimos que vaya rellenando el tablero}
Gotoxy(1,18);
Writeln;
Writeln(' Introduzca los datos del tablero:');
Writeln(' Si desea que aparezca una celula introduzca "*" o "@".');
Writeln(' Pulse "intro" o escriba "-" para indicar que no hay celula.');
Writeln(' Coordenadas: ');
For i := 1 To DimH Do
For j := 1 To DimV Do
Begin
Gotoxy(15,22);
Write('(',i,',',j,'): '); { (i,j): }
Gotoxy(23,22);
LimpiaLinea;
Gotoxy(23,22);
LeeCaracter(resp);
Gotoxy(j+2,i+1); {Posicion en la pantalla de cada casilla}
Write(tablero[i,j]); {Respuesta del usuario, si es o no una celula}
End;
End; {Reg}
Gotoxy(2,24);
Write('Pulse "enter" para continuar: ');
Readln(resp)
End; {DatosManual}
{--------------------------------------------------------------------------------------}
Procedure VaciaTablero(Var Reg: RegTablero);
{
Entrada: Registro donde se encuentra el tablero.
Funcion: Dejar el tablero sin ningun caracter.
Salida: Tablero del registro dado, vacio.
}
Begin
For i := 1 To DimH Do
For j := 1 To DimV Do
Reg.tablero[i,j] := '-'; {Vaciamos la casilla}
End; {VaciaTablero}
{--------------------------------------------------------------------------------------}
Procedure MuestraTablero(Reg: RegTablero);
{
Entrada: Registro donde se encuentra el tablero.
Funcion: Mostrar el tablero por pantalla con sus correspondientes celulas.
Salida: Se muestra el tablero por pantalla.
}
Begin
With Reg Do
Begin {Mostramos una linea encima del tablero indicando de que tipo es}
Gotoxy(5,3);
Case FormaTab Of
'1': Write('Tablero Plano'); {Si el tablero es plano...}
'2': Write('Tablero Cilindrico'); {Si el tablero es cilindrico...}
'3': Write('Tablero Toroidal'); {Si el tablero es toroidal...}
End; {case}
Gotoxy(5,5); {Vamos a mostrar el tablero}
Write('ABCDEFGHIJKLMNOPQRST'); {Letras que nos valen como coordenadas}
For i := 1 To DimH Do
Begin
Gotoxy(3,5+i); {Escribimos las coordenadas de las filas}
Write(i); {Valor de i que nos vale como coordenada}
Gotoxy(5,i+5);
For j := 1 To DimV Do {Escribe las casillas del tablero}
Write(tablero[i,j]);
Writeln;
End;
End; {RegisTab}
End; {MuestraTablero}
{--------------------------------------------------------------------------------------}
Procedure Opciones(generaciones: Word);
{
Salida: Mostramos las opciones del tablero:
Funcion:
Se muestran las siguientes opciones por pantalla al lado el tablero:
El usuario elegira como entrada de datos las letras correspondientes:
E/e: Editar el tablero manualmente.
G/g: Guardar la configuarcion a fichero.
"enter": Calcular nuevas generaciones.
T/t: Terminar el programa.
Entrada: Letra (opcion) elegida por el usuario.
}
Begin
Gotoxy(30,3);
Write('Opciones del juego:');
Gotoxy(27,5);
Write('* Editar de forma manual el tablero: (E/e)');
Gotoxy(27,6);
Write('* Pulse "enter" para calcular las generaciones.');
Gotoxy(27,7);
Write('* Guardar la configuracion en un fichero: (G/g)');
Gotoxy(27,8);
Write('* Terminar el juego. (T/t)');
Gotoxy(27,9);
{Vamos mostrando cuantas generaciones se han calculado}
If generaciones = 1 Then
Write('* Se ha calculado 1 generacion. ') {Singular}
Else
Write('* Se han calculado ',generaciones,' generaciones.'); {Plural}
End; {Opciones}
{--------------------------------------------------------------------------------------}
Procedure Plano(Var Reg: RegTablero);
{
Entrada: Registro donde se encuentra el tablero.
Funcion: Obtener el numero de celulas que rodean a cada celula tomando un
tablero plano.
Salida: Contador (cont) con el numero de celulas que rodean a la celula.
}
Begin
With Reg Do
Begin
{Si esta entre las coordenadas del tablero plano}
If (i 0) And (i 0) And (j 0) And (i 3) Or (cont ''; {Es necesario que se introduzca algun fichero}
Assign(FichConfig,nombre);
Rewrite(FichConfig);
{Recorremos el tablero y lo vamos escribiendo en el fichero}
For i := 1 To DimH Do
Begin
For j := 1 To DimV Do
Write(FichConfig,tablero[i,j]);
Writeln(FichConfig) {Pasamos a la siguiente fila}
End;
Gotoxy(27,15); {Mostramos un mensaje de que fue guardado con exito}
Write('La configuracion fue guardada en: ',nombre);
Close(FichConfig)
End {Reg}
End; {GuardaAFichero}
{-----------------------------------------------------------------------------}
Procedure EditaManual(Var Reg: RegTablero);
{
Entrada: Recibimos el registro donde vamos a guardar los datos.
Funcion: Que el usuario pueda cambiar las casillas del tablero.
Salida: Tablero con la nueva casilla modificada.
}
Var
columna: Char; {Columna del tablero, esta representada con un letra
entre la A y la correspondiente a DimV}
n: String; {Para comprobar que se introducen datos correctos}
fila: String; {Fila del tablero, representada por un numero entre 1 y DimH}
Procedure MuestraFallo;
{
Funcion: Informar al usuario de que ha introducido unos datos incorrectos.
}
Begin
Gotoxy(27,22);
Write('Recuerde: 15x20!');
Gotoxy(27,23);
Write('No corresponde a ninguna posicion del tablero');
Gotoxy(27,24);
Write('Numeros para las filas, letras para las columnas');
j := 0; {No es un valor valido, con j := 0 hacemos que se repita el bucle}
End; {MuestraFallo}
Begin {EditaManual}
With Reg Do
Begin
Gotoxy(27,15);
Write('Si selecciona una casilla con celula, esta morira,');
Gotoxy(27,16);
Write('si selecciona una vacia, nacera una celula.');
Gotoxy(27,18);
Write('Introduzca las coordenadas: ');
Repeat
{Limpiamos el espacio de pantalla que no nos sirve}
Gotoxy(33,19);
LimpiaLinea;
Gotoxy(36,20);
LimpiaLinea;
{Mostramos las opciones por pantalla}
Repeat
Gotoxy(27,19);
Write('Fila: '); {Fila que en la que se encuentra la casilla}
Readln(fila)
Until fila ''; {Chequeamos que no se deje en blanco}
Repeat
Gotoxy(27,20);
Write('Columna: '); {Columna en la que se encuentra la casilla}
Readln(n); {Leemos la columna}
If Ord(n[0]) = 1 Then {Si solo hay una letra}
columna := n[1] {La acumulamos}
Else {Limpiamos el valor incorrecto}
Begin
Gotoxy(27,20);
LimpiaLinea;
MuestraFallo
End
Until (Ord(n[0]) = 1); {No puede haber mas de una letra}
If (length(fila) = 2) Then {Si la fila leida se encuentra entre 10 y 15..}
i := (Ord(fila[2]) - 48) + ((Ord(fila[1]) - 48) * 10) {La acumulamos}
Else If (length(fila) = 1) Then {La fila se encuentra entre 1 y 9...}
i := (Ord(fila[1]) - 48) {La acumulamos en i}
Else
i := 0; {No se ha introducido un valor correcto}
If ((Ord(columna) >= Ord('A')) And (Ord(columna) = Ord('a')) And (Ord(columna) = 1) And (i = 1) And (j = 1) And (i = 1) And (j 1 Then {La respuesta no es valida}
Begin
Gotoxy(27,13);
Write('La respuesta introducida no es valida.');
Gotoxy(35,11);
LimpiaLinea;
Gotoxy(35,11);
Readln(resp) {Volvemos a pedir la respuesta}
End
End; {CompruebaResp}
Begin {MuestraOpcion}
Repeat
Gotoxy(27,11);
Write('Opcion:');
LimpiaLinea;
Gotoxy(35,11);
Readln(resp);
CompruebaResp(resp); {Comprobamos que no tenga mas de un caracter}
If Not ((resp[1] In respuestas) Or (resp = '')) Then {Si no es correcta}
Begin
Gotoxy(27,13);
Write('La respuesta introducida no es valida.')
End;
{Hasta que sea G/g, E/e, T/t o "enter"}
Until (resp[1] In respuestas) Or (resp = '');
End; {MuestraOpcion}
{--------------------------------------------------------------------------------------}
Procedure LimpiaOpcion;
{
Funcion: Limpiar la pantalla de las opciones que no son necesarias
}
Begin
For i := 13 To 24 Do
Begin
Gotoxy(27,i);
Write(' ':50);
End;
End; {LimpiaOpcion}
{--------------------------------------------------------------------------------------}
Begin {********************** PROGRAMA PRINCIPAL ************************** p.p}
VaciaTablero(ConfigTab); {Dejamos el tablero sin ninguna celula viva}
Repeat {Pedimos que nos diga como desea obtener los datos del tablero}
ClrScr;
Writeln;
Writeln(' Elija su configuracion inicial: ');
Writeln;
Writeln(' 1) Leer los datos de un fichero.'); {Desde fichero}
Writeln(' 2) Generar una configuracion aleatoria.'); {Aleatorio}
Writeln(' 3) Leer los datos desde teclado.'); {Desde teclado}
Write(' Introduzca su opcion: ');
Readln(resp);
Until (resp = '1') Or (resp = '2') Or (resp = '3');
With ConfigTab Do
Begin
Repeat {Obtenemos como se quieren calcular las generaciones}
Writeln;
Writeln(' ¿Como desea que se calculen las generaciones?');
Writeln(' 1 - Calcular generacion tras generacion.');
Writeln(' 2 - Calcular un numero determinado de generaciones.');
Write(' Elija 1 o 2, por favor: ');
Readln(ModoGeneracion);
If ModoGeneracion = '2' Then {Si quiere calcular varias generaciones}
Begin
Repeat
Write(' Introduzca el numero de generaciones a calcular: ');
gen := NumCorrecto(Ngen); {Chequeamos que introduzca un numero}
gen := Ngen {Guardamos la generacion en una variable para
mostrarlo cuando vayan pasando las generaciones}
Until Ngen > 0
End
Else {Para mostrar por pantalla el inicio de las generaciones}
gen := 0;
ClrScr
Until ModoGeneracion In ['1','2']
End; {ConfigTab}
Case resp[1] Of
'1': LeerTablero(ConfigTab); {Leemos el tablero del fichero}
'2': TabAleatorio(ConfigTab); {Generamos un tablero aleatorio}
'3': DatosManual(ConfigTab) {El tablero se genera manualmente}
{Solo puede valer 1, 2 o 3 porque ya lo hemos chequeado antes}
End;
Repeat {Forma del Tablero}
ClrScr;
Writeln(' Elija el numero del tipo de tablero que prefiere: ');
Writeln(' 1 - Plano.');
Writeln(' 2 - Cilindrico.');
Writeln(' 3 - Toroidal.');
Write(' Introduzca su respuesta: ');
Readln(ConfigTab.FormaTab)
Until ConfigTab.FormaTab In ['1','2','3'];
ClrScr;
ConfigTab.gen := 0; {No hemos calculado ninguna generacion, lo inicializamos}
resp := '';
MuestraTablero(ConfigTab); {Mostramos el tablero inicial}
Repeat
With ConfigTab Do
Begin
If ModoGeneracion = '2' Then
{Se ha pedido calcular un numero determinado de generaciones}
Begin
Gotoxy(27,5);
Write('Pulse enter para calcular las generaciones: ');
MuestraOpcion;
gen := Ngen;
For Ngen := Ngen Downto 1 Do
Begin
Celulas(ConfigTab); {Calculamos la siguiente generacion}
tablero := TabAux {Acumulamos la generacion}
End;
If (resp = 'G') Or (resp = 'g') Then
GuardaAFichero(ConfigTab)
Else If (resp = 'E') Or (resp = 'e') Then
EditaManual(ConfigTab);
MuestraTablero(ConfigTab);
Opciones(gen);
ModoGeneracion := '1'; {Para calcular las generaciones de una en una}
End; {If}
Opciones(gen); {Menu de opciones del programa}
MuestraOpcion;
If ModoGeneracion = '1' Then {Calcular generacion tras generacion}
Begin
LimpiaOpcion; {Limpiamos las opciones que no son necesarias}
If resp = '' Then {Se quiere calcular una nueva generacion}
Begin
celulas(ConfigTab); {Calculamos la siguiente generacion}
tablero := TabAux; {Acumulamos la generacion}
gen := gen + 1 {Aumentamos la generacion}
End
Else
Begin
If (resp = 'G') Or (resp = 'g') Then
GuardaAFichero(ConfigTab)
Else If (resp = 'E') Or (resp = 'e') Then
EditaManual(ConfigTab)
End;
MuestraTablero(ConfigTab)
End {If}
End; {ConfigTab}
Until (resp = 'T') Or (resp = 't')
End. {********************** PROGRAMA PRINCIPAL ************************** p.p}