GATO o TRES en RAYA, permite jugar entre dos personas o entre el

/*GATO o TRES en RAYA, permite jugar entre dos personas o entre el ordenador y
una persona. Presenta menús gráficos, funciones...
Lo publico tal y como me lo enviaron...
*/
/*
Bajado de http://programandoenc.webcindario.com
*/
#include
#include
#include
#include
#include
<stdio.h>
<conio.h>
<dos.h>
<stdlib.h>
<conio2.h>
/*-----------------------------------------------------------------------------*/
//aqui se guardan y se cargan los datos para los archivos
struct estructura
{
int
mat[3][3]; //esta es la matriz donde se juega
char nj1[15];
//este guarda el nombre del jugador1
char nj2[15];
//este guarda el nombre del jugador2
int
jug;
//este guarda quien tiene el turno actualmente
int
mod;
//modo de juego humano vrs humano\" o \"humano vrs
maquina\"
char narch[10]; //este es el nombre con que se guard¢ el juego
};
//estructura para asignar los archivos disponibles para guardar juegos
struct archivos
{
FILE *save1;
FILE *save2;
FILE *save3;
FILE *save4;
FILE *save5;
FILE *save6;
FILE *save7;
FILE *save8;
FILE *save9;
};
/*-----------------------------------------------------------------------------*/
void limpiarMatrix(int [][3]);
void cuadro(char nomb1[],char nomb2[],int modo);
void imprimirSimbolo(int,int,int);
void mover(int [][3],int,int,int,int *modo,char[],char[],estructura
registro,archivos archivo);
int cantidad(int [][3],int,int);
int ganador(int [][3]);
int empate(int [][3]);
int modoJuego(void);
void mejorJugada(int [][3],int *fila,int *columna);
void nombres(int modo,char nomb1[],char nomb2[]);
void ininombres(char nomb1[],char nomb2[]);
void limpiarregistro(estructura datos);
void archivar(estructura datos1,archivos archivo);
void desarchivar(estructura datos2,archivos archivo,int *error);
int matrizVacia(int [][3]);
void imprimirGuardados(archivos archivo);
void presentacion(void);
void ayuda(void);
void marco(void);
/*-----------------------------------------------------------------------------*/
main()
{
estructura registro; //declaracion de registro de tipo estructura
archivos archivo;
//declaracion de archivo de tipo archivos
presentacion();
//mostrar presentacion
int matriz[3][3];
//matriz en la que se juega
int salir;
//variable que determina cuando salir del
programa
int simbolo;
//variable que determina el simbolo
int fila,columna;
//posiciones en la matriz
int jugador;
int modo;
//variable para guardar el modo de juego
char nombre1[15];
//nombre del jugador 1
char nombre2[15];
//nombre del jugador 2
//randomize(); //generacion de tabla de numeros aleatorios
do //ciclo que despliega el menu principal
{
textcolor(YELLOW);
textbackground(BLACK);
//pone el simbolo y jugador 1 en el centro del cuadro del juego
fila=1;
columna=1;
simbolo=jugador=1;
salir=0;
modo=modoJuego(); //determinar el modo de juego
if (modo==3) //si la opcion escogida es salir
{
clrscr();
marco();
gotoxy(25,12);
cprintf("Sugerencias: [email protected]");
//delay(5000);
exit(1);
}
//asignar los nombres de los 2 jugadores
nombres(modo,nombre1,nombre2);
salir=2;
while ((salir!=1)) //mientras no se quiera salir al men£ principal
{
limpiarMatrix(matriz); //pone toda la matriz en cero
clrscr();
marco();
//imprime el marco externo
cuadro(nombre1,nombre2,modo); //imprime la zona de juego
imprimirSimbolo(simbolo,fila,columna); //imprime un simbolo en
pantalla
}
mover(matriz,jugador,fila,columna,&modo,nombre1,nombre2,registro,archivo);
textcolor(YELLOW);
gotoxy(29,21);
cprintf("DIGITE LA OPCION:");
textcolor(WHITE);
gotoxy(29,22);
cprintf("1. SALIR AL MENU");
textcolor(WHITE);
gotoxy(29,23);
cprintf("2. REINICIAR JUEGO");
gotoxy(47,21);
scanf("%d",&salir);
}
salir=0;
} while (salir!=1);
/*-----------------------------------------------------------------------------*/
//Este procedimiento pone toda la matriz en cero, para que est‚ vacia
//PARAMETROS:
//mat[][3] es la matriz donde se juega
void limpiarMatrix(int mat[][3])
{
for(int f=0;f<3;f++)
for(int c=0;c<3;c++)
{
mat[f][c]=0;
imprimirSimbolo(0,f,c);
}
}
/*-----------------------------------------------------------------------------*/
//Este procedimiento imprime toda la zona del juego
//PARAMETROS:
//nomb1[] es el nombre del jugador 1
//nomb2[] es el nombre del jugador 2
//modo el el modo de juego
void cuadro(char nomb1[],char nomb2[],int modo)
{
int x,y; //para manejo de las posiciones en pantalla
textbackground(BLACK);
textcolor(LIGHTCYAN);
gotoxy(13,6);
printf("JUGADOR 1");
gotoxy(13,7);
cprintf("%s",nomb1);
gotoxy(13,9);
printf("TIPO");
gotoxy(13,10);
cprintf("HUMANO");
gotoxy(13,12);
printf("SIMBOLO");
gotoxy(13,13);
x=13;
y=13;
textcolor(LIGHTCYAN);
gotoxy(x,y);
cprintf("ßÜ Üß");
gotoxy(x,y+1);
cprintf(" Û ");
gotoxy(x,y+2);
cprintf("Üß ßÜ");
textcolor(LIGHTRED);
gotoxy(57,6);
printf("JUGADOR 2");
gotoxy(57,7);
cprintf("%s",nomb2);
gotoxy(57,9);
printf("TIPO");
gotoxy(57,10);
if (modo==1)
cprintf("HUMANO");
else
cprintf("MAQUINA");
gotoxy(57,12);
printf("SIMBOLO");
x=57;
textcolor(LIGHTRED);
gotoxy(x,y);
cprintf("ÜßßßÜ");
gotoxy(x,y+1);
cprintf("Û
Û");
gotoxy(x,y+2);
cprintf("ßÜÜÜß");
textcolor(WHITE);
gotoxy(27,6);
cprintf("ÉÍÍÍÍÍÍÍËÍÍÍÍÍÍÍËÍÍÍÍÍÍÍ»");
gotoxy(27,7);
cprintf("º");
gotoxy(35,7);
cprintf("º");
gotoxy(43,7);
cprintf("º");
gotoxy(51,7);
cprintf("º");
gotoxy(27,8);
cprintf("º");
gotoxy(35,8);
cprintf("º");
gotoxy(43,8);
cprintf("º");
gotoxy(51,8);
cprintf("º");
gotoxy(27,9);
cprintf("º");
gotoxy(35,9);
cprintf("º");
gotoxy(43,9);
cprintf("º");
gotoxy(51,9);
cprintf("º");
gotoxy(27,10);
cprintf("ÌÍÍÍÍÍÍÍÎÍÍÍÍÍÍÍÎÍÍÍÍÍÍ͹");
gotoxy(27,11);
cprintf("º");
gotoxy(35,11);
cprintf("º");
gotoxy(43,11);
cprintf("º");
gotoxy(51,11);
cprintf("º");
gotoxy(27,12);
cprintf("º");
gotoxy(35,12);
cprintf("º");
gotoxy(43,12);
cprintf("º");
gotoxy(51,12);
cprintf("º");
gotoxy(27,13);
cprintf("º");
gotoxy(35,13);
cprintf("º");
gotoxy(43,13);
cprintf("º");
gotoxy(51,13);
cprintf("º");
gotoxy(27,14);
cprintf("ÌÍÍÍÍÍÍÍÎÍÍÍÍÍÍÍÎÍÍÍÍÍÍ͹");
gotoxy(27,15);
cprintf("º");
gotoxy(35,15);
cprintf("º");
gotoxy(43,15);
cprintf("º");
gotoxy(51,15);
cprintf("º");
gotoxy(27,16);
cprintf("º");
gotoxy(35,16);
cprintf("º");
gotoxy(43,16);
cprintf("º");
gotoxy(51,16);
cprintf("º");
gotoxy(27,17);
cprintf("º");
gotoxy(35,17);
cprintf("º");
gotoxy(43,17);
cprintf("º");
gotoxy(51,17);
cprintf("º");
gotoxy(27,18);
cprintf("ÈÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÊÍÍÍÍÍÍͼ");
ayuda();
marco();
}
/*-----------------------------------------------------------------------------*/
//Este procedimientose encarga de imprimir el simbolo en la fila y columna.
//PARAMETROS:
//simbolo es la variable que determina el simbolo del jugador actual
//fila es la variable que determina la fila actual
//columna es la variable que determina la columna actual
void imprimirSimbolo(int simbolo,int fila, int columna)
{
int x,y;
//FILA 0
if((fila==0)&&(columna==0))
{
x=29;
y=7;
}
if(fila==0&&columna==1)
{
x=37;
y=7;
}
if(fila==0&&columna==2)
{
x=45;
y=7;
}
//FILA 1
if(fila==1&&columna==0)
{
x=29;
y=11;
}
if(fila==1&&columna==1)
{
x=37;
y=11;
}
if(fila==1&&columna==2)
{
x=45;
y=11;
}
//FILA 2
if(fila==2&&columna==0)
{
x=29;
y=15;
}
if(fila==2&&columna==1)
{
x=37;
y=15;
}
if(fila==2&&columna==2)
{
x=45;
y=15;
}
if (simbolo==-1)
{
textcolor(LIGHTRED);
gotoxy(x,y);
cprintf("ÜßßßÜ");
gotoxy(x,y+1);
cprintf("Û
Û");
gotoxy(x,y+2);
cprintf("ßÜÜÜß");
}
if (simbolo==1)
{
textcolor(LIGHTCYAN);
gotoxy(x,y);
cprintf("ßÜ Üß");
gotoxy(x,y+1);
cprintf(" Û ");
gotoxy(x,y+2);
cprintf("Üß ßÜ");
}
if (simbolo==0) //si se encuentra vacia
{
gotoxy(x,y);
cprintf("
");
gotoxy(x,y+1);
cprintf("
");
gotoxy(x,y+2);
cprintf("
");
}
//impresion de los indicadores de la posicion
textcolor(LIGHTGREEN);
textbackground(BLACK);
int x1,y1,x2,y2;
x1=26;
x2=53;
y1=5;
y2=19;
if ((fila==0)||(fila==1)||(fila==2))
{
gotoxy(27,5);
cprintf("
");
gotoxy(27,19);
cprintf("
");
gotoxy(x1,8);
cprintf(" ");
gotoxy(x2,8);
cprintf(" ");
gotoxy(x1,12);
cprintf(" ");
gotoxy(x2,12);
cprintf(" ");
gotoxy(x1,16);
cprintf(" ");
gotoxy(x2,16);
cprintf(" ");
gotoxy(x+2,y1);
cprintf("%c",31);
gotoxy(x+2,y2);
cprintf("%c",30);
gotoxy(x1,y+1);
cprintf("%c",16);
gotoxy(x2,y+1);
cprintf("%c",17);
}
textcolor(WHITE);
gotoxy(x+2,y+1);
}
/*-----------------------------------------------------------------------------*/
//Este procedimiento se encarga del reconocimiento de las teclas digitadas,
//PARAMETROS:
//matrix[][3] matriz en la que se juega
//jugador variable que almacena el jugado que tiene el turno
//fila posicion actual de la fila en la matriz
//columna posicion actual de la columna en la matriz
//modo el modo de juego
//jug1[] nombre del jugador 1
//jug2[] nombre del jugador 2
//registro estructura para guardar los datos para guardar y cargar
//archivo archivos en los que se guardan los juegos
void mover(int matrix[][3],int jugador,int fila, int columna,int *modo,char
jug1[],char jug2[],estructura registro,archivos archivo)
{
int tecla,turno,espacio,ff,cc,error;
char nombrea[10];
turno=jugador;
do //ciclo para poder reiniciar el juego con los mismos jugadores
{
if(turno==1) //si es turno del jugador 1 imprime su simbolo
{
gotoxy(27,4);
cprintf("
");
gotoxy(27,4);
textcolor(LIGHTCYAN);
cprintf("ES TURNO PARA %s",jug1);
marco();
}else if(turno==-1) //si es turno del jugador 2 imprime su simbolo
{
gotoxy(27,4);
cprintf("
");
gotoxy(27,4);
textcolor(LIGHTRED);
cprintf("ES TURNO PARA %s",jug2);
marco();
}
tecla=getch();//lectura de la tecla
if (tecla == 0)
tecla = getch();
switch (tecla)
{
case 72://direccional arriba
{
gotoxy(25,20);
cprintf("
");
imprimirSimbolo(matrix[fila][columna],fila,columna);//impresion del
contenido de la celda abandonada
//cambio de fila
if (fila==0)
fila=2;
else
fila--;
imprimirSimbolo(turno,fila,columna);//impresion del
simbolo del simbolo del jugador actual
break;
}
case 80://direccional abajo
{
gotoxy(25,20);
cprintf("
");
imprimirSimbolo(matrix[fila][columna],fila,columna);//impresion del
contenido de la celda abandonada
//cambio de fila
if (fila==2)
fila=0;
else
fila++;
imprimirSimbolo(turno,fila,columna);//impresion del
simbolo del simbolo del jugador actual
break;
}
case 75://direccional izquierda
{
gotoxy(25,20);
cprintf("
");
imprimirSimbolo(matrix[fila][columna],fila,columna);//impresion del
contenido de la celda abandonada
//cambio de columna
if (columna==0)
columna=2;
else
columna--;
imprimirSimbolo(turno,fila,columna);//impresion del
simbolo del simbolo del jugador actual
break;
}
case 77://direccional derecha
{
gotoxy(25,20);
cprintf("
");
imprimirSimbolo(matrix[fila][columna],fila,columna);//impresion del
contenido de la celda abandonada
//cambio de columna
if (columna==2)
else
columna=0;
columna++;
imprimirSimbolo(turno,fila,columna);//impresion del
simbolo del simbolo del jugador actual
break;
}
case 13://tecla enter
{
gotoxy(25,20);
cprintf("
");
if (matrix[fila][columna]==0)//si la posicion actual est
vacia
{
if (turno==1)//si es turno del jugador 1
{
matrix[fila][columna]=1;//asignar este
posicion al jugador 1
imprimirSimbolo(1,fila,columna);//imprimir
su signo ne pantalla
//si el modo es humano vrs m quina realizar
la jugada de la maquina
if
((*modo==2)&&(ganador(matrix)!=1)&&(empate(matrix)!=1))
{
gotoxy(27,4);
cprintf("
");
gotoxy(27,4);
textcolor(LIGHTRED);
cprintf("ES TURNO PARA %s",jug2);
marco();
mejorJugada(matrix,&fila,&columna);//determinar la mejor posicion para
jugar
matrix[fila][columna]=-1;//asignar
este posicion al jugador 2
imprimirSimbolo(-1,fila,columna);
}
else//si el modo es humano vrs humano
cambiar de turno
2
turno=-1;//cambio de turno al jugador
}
else
if (turno==-1)//si es turno del jugador 2
{
if (*modo==1)//si el modo es humano
vrs humano
{
matrix[fila][columna]=-
1;//asignar este posicion al jugador 2
realizar la jugada de la maquina
imprimirSimbolo(-1,fila,columna);
}
else//si el modo es humano vrs m quina
{
jugar
mejorJugada(matrix,&fila,&columna);//determinar la mejor posicion para
matrix[fila][columna]=-
1;//asignar este posicion al jugador 2
}
imprimirSimbolo(-1,fila,columna);
}
turno=1;//cambio de turno al jugador 1
}
else//si la posicion actual se encuentra ocupada por
algun jugador
{
textcolor(YELLOW);
gotoxy(25,20);
cprintf("
gotoxy(25,20);
cprintf("ESTA CELDA ESTµ OCUPADA");
");
}
if (ganador(matrix)==1)//si el jugador 1 gan¢
{
gotoxy(27,4);
cprintf("
");
textcolor(LIGHTCYAN+128);
gotoxy(25,20);
cprintf("
marco();
gotoxy(28,20);
cprintf("EL JUGADOR %s",jug1);
cprintf(" GANà");
tecla=27;
");
}
if (ganador(matrix)==-1)//si el jugador 2 gan¢
{
gotoxy(27,4);
cprintf("
");
textcolor(LIGHTRED+128);
gotoxy(25,20);
cprintf("
marco();
gotoxy(28,20);
cprintf("EL JUGADOR %s",jug2);
cprintf(" GANà");
tecla=27;
");
}
if (empate(matrix)==1)//si hubo empate
{
gotoxy(27,4);
cprintf("
");
textcolor(LIGHTBLUE+128);
gotoxy(25,20);
cprintf("
marco();
gotoxy(33,20);
cprintf("JUEGO EMPATADO");
tecla=27;
");
}
//delay(1000);
//si no hubo ni ganador ni empate
if( (ganador(matrix)==0) && ( empate(matrix)==0))
imprimirSimbolo(turno,fila,columna);
textcolor(WHITE);
break;
}
case 59://F1 VER CREDITOS
{
presentacion();
//impresion del area de juego
textbackground(BLACK);
clrscr();
cuadro(jug1,jug2,*modo);
for (ff=0;ff<3;ff++)
for (cc=0;cc<3;cc++)
imprimirSimbolo(matrix[ff][cc],ff,cc);
imprimirSimbolo(turno,fila,columna);
break;
}
case 60://F2 SALVAR JUEGO
{
//si no hay ningun ganador, ni empate, y la mariz no est
vacia
if( (ganador(matrix)==0) && ( empate(matrix)==0 ) &&
(matrizVacia(matrix)==1) )
{
//llenar registro
for (ff=0;ff<3;ff++)
for (cc=0;cc<3;cc++)
registro.mat[ff][cc]=matrix[ff][cc];
for (cc=0;cc<10;cc++)
registro.nj1[cc]=jug1[cc];
for (cc=0;cc<10;cc++)
registro.nj2[cc]=jug2[cc];
registro.jug=turno;
registro.mod=*modo;
//guardar en archivo
archivar(registro,archivo);
}
else//si hay un ganado o un empate o la matriz esta
vac¡a
{
textcolor(YELLOW);
gotoxy(25,20);
cprintf("
");
gotoxy(25,20);
cprintf("NO SE PUEDE GUARDAR ESTE JUEGO");
//delay(1000);
}
//impresion del area de juego
textbackground(BLACK);
clrscr();
cuadro(jug1,jug2,*modo);
for (ff=0;ff<3;ff++)
for (cc=0;cc<3;cc++)
imprimirSimbolo(matrix[ff][cc],ff,cc);
imprimirSimbolo(turno,fila,columna);
break;
}
case 61://F3 CARGAR JUEGO
{
limpiarregistro(registro);//borrar posible basura en el
registro
//leer los datos desde el archivo para guardarlo en el
registro
desarchivar(registro,archivo,&error);
if (error==0)//si el archivo no est vac¡o
{
limpiarMatrix(matrix);//poner toda la matriz en 0
//llenar el registro con la informacion del
archivo
for (int ff=0;ff<3;ff++)
for (int cc=0;cc<3;cc++)
matrix[ff][cc]=registro.mat[ff][cc];
ininombres(jug1,jug2);
for (cc=0;cc<10;cc++)
jug1[cc]=registro.nj1[cc];
for (cc=0;cc<10;cc++)
jug2[cc]=registro.nj2[cc];
fila=1;
columna=1;
turno=registro.jug;
*modo=registro.mod;
}
//impresion del area de juego
textbackground(BLACK);
clrscr();
cuadro(jug1,jug2,*modo);
for (ff=0;ff<3;ff++)
for (cc=0;cc<3;cc++)
imprimirSimbolo(matrix[ff][cc],ff,cc);
imprimirSimbolo(turno,fila,columna);
break;
}
}
}while (tecla!=27);//mientras la tecla digitada sea diferente de ESCAPE
}
/*-----------------------------------------------------------------------------*/
//Esta funcion retorna la cantidad de veces que aparece "num" en "linea"
//PARAMETROS:
//matrix[][3] matriz en la que se juega
//linea linea de la matriz en la que se va a buscar
//num elemento que se quiere buscar
int cantidad(int matrix[][3],int linea,int num)
{
int cont=0;
int l;
switch (linea)
{
case 1://linea horizontal superior
{
for(l=0;l<3;l++)
{
if (matrix[0][l]==num)
cont++;
}
break;
}
case 2://linea horizontal intermedia
{
for(l=0;l<3;l++)
{
if (matrix[1][l]==num)
cont++;
}
break;
}
case 3://linea horizontal inferior
{
for(l=0;l<3;l++)
{
if (matrix[2][l]==num)
cont++;
}
break;
}
case 4://linea vertical izquierda
{
for(l=0;l<3;l++)
{
if (matrix[l][0]==num)
cont++;
}
break;
}
case 5://linea vertical intermedia
{
for(l=0;l<3;l++)
{
if (matrix[l][1]==num)
cont++;
}
break;
}
case 6://linea vertical derecha
{
for(l=0;l<3;l++)
{
if (matrix[l][2]==num)
cont++;
}
break;
}
case 7://linea diagonal principal
{
for(l=0;l<3;l++)
{
if (matrix[l][l]==num)
cont++;
}
break;
}
case 8://linea diagonal inversa
{
for(l=0;l<3;l++)
{
if (matrix[2-l][l]==num)
cont++;
}
break;
}
}
return(cont);
}
/*-----------------------------------------------------------------------------*/
//Esta funcion retorna el simbolo del jugador ganador 1,-1 o un 0 si no hay
ganador
//PARAMETROS:
//matrix[][3] matriz en la que se juega
int ganador(int matrix[][3])
{
int winner=0;
if (cantidad(matrix,1,-1)==3)
winner=-1;
if (cantidad(matrix,2,-1)==3)
winner=-1;
if (cantidad(matrix,3,-1)==3)
winner=-1;
if (cantidad(matrix,4,-1)==3)
winner=-1;
if (cantidad(matrix,5,-1)==3)
winner=-1;
if (cantidad(matrix,6,-1)==3)
winner=-1;
if (cantidad(matrix,7,-1)==3)
winner=-1;
if (cantidad(matrix,8,-1)==3)
winner=-1;
if (cantidad(matrix,1,1)==3)
winner=1;
if (cantidad(matrix,2,1)==3)
winner=1;
if (cantidad(matrix,3,1)==3)
winner=1;
if (cantidad(matrix,4,1)==3)
winner=1;
if (cantidad(matrix,5,1)==3)
winner=1;
if (cantidad(matrix,6,1)==3)
winner=1;
if (cantidad(matrix,7,1)==3)
winner=1;
if (cantidad(matrix,8,1)==3)
winner=1;
return (winner);
}
/*-----------------------------------------------------------------------------*/
//Esta funcion retorna un 1 si hay empate o un 0 si no lo hay
//PARAMETROS:
//matrix[][3] matriz en la que se juega
int empate(int matrix[][3])
{
int emp;
int contador=0;
int c,f;
//determinar si la matriz est llena
for(f=0;f<3;f++)
for(c=0;c<3;c++)
{
if (matrix[f][c]!=0)
contador++;
}
//si no hay ganador y la matriz est llena
if ((ganador(matrix)==0)&&(contador==9))
emp=1;//hay un empate
else
emp=0;//no hay un empate
return (emp);
}
/*-----------------------------------------------------------------------------*/
//Funcion que retorna un 1 si el modo de juego es humano vrs humano y un 2 si es
humano vrs maquina.
int modoJuego(void)
{
int opcion,tecla;
clrscr();
marco();
//impresion del menu principal
gotoxy(25,9);
cprintf("SELECCIONE LA OPCION QUE DESEE");
textcolor(LIGHTCYAN);
gotoxy(25,11);
cprintf("1- JUEGO HUMANO vrs HUMANO");
gotoxy(25,12);
cprintf("2- JUEGO HUMANO vrs COMPUTADORA");
gotoxy(25,13);
cprintf("3- SALIR DEL JUEGO");
textcolor(WHITE);
gotoxy(25,15);
cprintf("DIGITE EL NUMERO DE LA OPCION: ");
scanf("%d",&opcion);//opcion es la opcion escogida
return (opcion);
}
/*-----------------------------------------------------------------------------*/
//Este procedimiento determina la fila y la columna donde la maquina tiene la
mejor jugada,
//ya sea para ganar o para bloquear el gane del jugador 1 (humano)
//PARAMETROS:
//matrix[][3] es la matriz en la que se juega
//*fila celda en la memoria fisica a la que apunta fila, ya se va a modificar su
valor
//*columna celda en la memoria fisica a la que apunta columna, ya se va a
modificar su valor
void mejorJugada(int matrix[][3],int *fila,int *columna)
{
int f,c,listo;//indica si ya se encontr¢ la mejor jugada o no
int lin10, lin20, lin30, lin40, lin50, lin60, lin70, lin80;
int lin11, lin21, lin31, lin41, lin51, lin61, lin71, lin81;
int lin12, lin22, lin32, lin42, lin52, lin62, lin72, lin82;
listo=0;//aun no se ha encontrado
//CANTIDAD DE CELDAS VACÖAS
lin10 = cantidad(matrix,1,0);//en linea 1
lin20 = cantidad(matrix,2,0);//en linea 2
lin30 = cantidad(matrix,3,0);//en linea 3
lin40 = cantidad(matrix,4,0);//en linea 4
lin50 = cantidad(matrix,5,0);//en linea 5
lin60 = cantidad(matrix,6,0);//en linea 6
lin70 = cantidad(matrix,7,0);//en linea 7
lin80 = cantidad(matrix,8,0);//en linea 8
//CANTIDAD DE CELDAS OCUPADAS POR EL JUGADOR 1
lin11 = cantidad(matrix,1,1);//en linea 1
lin21 = cantidad(matrix,2,1);//en linea 2
lin31 = cantidad(matrix,3,1);//en linea 3
lin41 = cantidad(matrix,4,1);//en linea 4
lin51 = cantidad(matrix,5,1);//en linea 5
lin61 = cantidad(matrix,6,1);//en linea 6
lin71 = cantidad(matrix,7,1);//en linea 7
lin81 = cantidad(matrix,8,1);//en linea 8
//CANTIDAD DE CELDAS OCUPADAS POR LA MAQUINA
lin12 = cantidad(matrix,1,-1);//en linea 1
lin22 = cantidad(matrix,2,-1);//en linea 2
lin32 = cantidad(matrix,3,-1);//en linea 3
lin42 = cantidad(matrix,4,-1);//en linea 4
lin52 = cantidad(matrix,5,-1);//en linea 5
lin62 = cantidad(matrix,6,-1);//en linea 6
lin72 = cantidad(matrix,7,-1);//en linea 7
lin82 = cantidad(matrix,8,-1);//en linea 8
//JUGADA PARA GANAR
//si en la linea 1 hay un 0 y dos -1 y no se ha encontrado la mejor jugada
if((lin10==1)&&(lin12==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(c=0;c<3;c++)
{
if (matrix[0][c]==0)
{
*fila=0;
*columna=c;
listo=1;
}
}
}
//si en la linea 2 hay un 0 y dos -1 y no se
else if((lin20==1)&&(lin22==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(c=0;c<3;c++)
{
if (matrix[1][c]==0)
{
*fila=1;
*columna=c;
listo=1;
}
}
}
//si en la linea 3 hay un 0 y dos -1 y no se
else if((lin30==1)&&(lin32==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(c=0;c<3;c++)
{
if (matrix[2][c]==0)
{
*fila=2;
*columna=c;
listo=1;
}
}
}
//si en la linea 4 hay un 0 y dos -1 y no se
else if((lin40==1)&&(lin42==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(f=0;f<3;f++)
{
if (matrix[f][0]==0)
{
*fila=f;
*columna=0;
listo=1;
}
}
}
//si en la linea 5 hay un 0 y dos -1 y no se
else if((lin50==1)&&(lin52==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(f=0;f<3;f++)
{
if (matrix[f][1]==0)
{
*fila=f;
*columna=1;
listo=1;
}
}
}
ha encontrado la mejor jugada
ha encontrado la mejor jugada
ha encontrado la mejor jugada
ha encontrado la mejor jugada
//si en la linea 6 hay un 0 y dos -1 y no se ha encontrado la mejor jugada
else if((lin60==1)&&(lin62==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(f=0;f<3;f++)
{
if (matrix[f][2]==0)
{
*fila=f;
*columna=2;
listo=1;
}
}
}
//si en la linea 7 hay un 0 y dos -1 y no se ha encontrado la mejor jugada
else if((lin70==1)&&(lin72==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(f=0;f<3;f++)
{
if (matrix[f][f]==0)
{
*fila=f;
*columna=f;
listo=1;
}
}
}
//si en la linea 8 hay un 0 y dos -1 y no se ha encontrado la mejor jugada
else if((lin80==1)&&(lin82==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(f=0;f<3;f++)
{
if (matrix[f][2-f]==0)
{
*fila=f;
*columna=2-f;
listo=1;
}
}
}else
//JUGADA PARA BLOQUEAR
//si en la linea 1 hay un 0 y dos 1 y no se ha encontrado la mejor jugada
if((lin10==1)&&(lin11==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(c=0;c<3;c++)
{
if (matrix[0][c]==0)
{
*fila=0;
*columna=c;
listo=1;
}
}
}
//si en la linea 2 hay un 0 y dos 1 y no se ha encontrado la mejor jugada
else if((lin20==1)&&(lin21==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(c=0;c<3;c++)
{
if (matrix[1][c]==0)
{
}
*fila=1;
*columna=c;
listo=1;
}
}
//si en la linea 3 hay un 0 y dos 1 y no se
else if((lin30==1)&&(lin31==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(c=0;c<3;c++)
{
if (matrix[2][c]==0)
{
*fila=2;
*columna=c;
listo=1;
}
}
}
//si en la linea 4 hay un 0 y dos 1 y no se
else if((lin40==1)&&(lin41==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(f=0;f<3;f++)
{
if (matrix[f][0]==0)
{
*fila=f;
*columna=0;
listo=1;
}
}
}
//si en la linea 5 hay un 0 y dos 1 y no se
else if((lin50==1)&&(lin51==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(f=0;f<3;f++)
{
if (matrix[f][1]==0)
{
*fila=f;
*columna=1;
listo=1;
}
}
}
//si en la linea 6 hay un 0 y dos 1 y no se
else if((lin60==1)&&(lin61==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(f=0;f<3;f++)
{
if (matrix[f][2]==0)
{
*fila=f;
*columna=2;
listo=1;
}
}
}
//si en la linea 7 hay un 0 y dos 1 y no se
ha encontrado la mejor jugada
ha encontrado la mejor jugada
ha encontrado la mejor jugada
ha encontrado la mejor jugada
ha encontrado la mejor jugada
else if((lin70==1)&&(lin71==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(f=0;f<3;f++)
{
if (matrix[f][f]==0)
{
*fila=f;
*columna=f;
listo=1;
}
}
}
//si en la linea 8 hay un 0 y dos 1 y no se ha encontrado la mejor jugada
else if((lin80==1)&&(lin81==2)&&(listo==0))
{
//buscar la posicion vac¡a
for(f=0;f<3;f++)
{
if (matrix[f][2-f]==0)
{
*fila=f;
*columna=2-f;
listo=1;
}
}
}
else
{
//PONE EN CUALQUIER POSICION
if ((matrix[1][0]==1)&&(matrix[0][1]==1)&&(matrix[0][0]==0))
{
*fila
=0;
*columna
=0;
}else if ((matrix[1][0]==1)&&(matrix[2][1]==1)&&(matrix[2][0]==0))
{
*fila
=2;
*columna
=0;
}else if ((matrix[2][1]==1)&&(matrix[1][2]==1)&&(matrix[2][2]==0))
{
*fila
=2;
*columna
=2;
}else if ((matrix[0][1]==1)&&(matrix[1][2]==1)&&(matrix[0][2]==0))
{
*fila
=0;
*columna
=2;
}else if ((matrix[1][1]==1)&&(matrix[0][0]==0))
{
*fila
=0;
*columna
=0;
}else if ((matrix[1][1]==1)&&(matrix[2][2]==1)&&(matrix[0][2]==0))
{
*fila
=0;
*columna
=2;
}else if (matrix[1][1]==0)
{
*fila
=1;
*columna
=1;
}else if (matrix[0][1]==0)
{
*fila
=0;
*columna
=1;
}else if (matrix[1][0]==0)
{
*fila
=1;
*columna
=0;
}else if (matrix[1][2]==0)
{
*fila
=1;
*columna
=2;
}else if (matrix[2][1]==0)
{
*fila
=2;
*columna
=1;
}else if (matrix[0][0]==0)
{
*fila
=0;
*columna
=0;
}else if (matrix[2][2]==0)
{
*fila
=2;
*columna
=2;
}else if (matrix[0][2]==0)
{
*fila
=0;
*columna
=2;
}else if (matrix[2][0]==0)
{
*fila
=2;
*columna
=0;
}
}
}
/*-----------------------------------------------------------------------------*/
//Este procedimiento se encarga de la lectura de los nombres de los jugadores
//PARAMETROS:
//modo modo de juego
//nomb1[] nombre del jugador 1
//nomb2[] nombre del jugador 2
void nombres(int modo,char nomb1[],char nomb2[])
{
ininombres(nomb1,nomb2);//borrar el contenido de nombre los nombres
gotoxy(25,17);
cprintf(" NOMBRE DEL JUGADOR 1 (HUMANO): ");
scanf("%s",nomb1);
gotoxy(25,19);
if(modo==1)
cprintf(" NOMBRE DEL JUGADOR 2 (HUMANO): ");
else if(modo==2)
cprintf(" NOMBRE DEL JUGADOR 2 (MAQUINA): ");
scanf("%s",nomb2);
}
/*-----------------------------------------------------------------------------*/
//Pone el nombre de los jugadores en blanco
//PARAMETROS:
//nomb1[] nombre del jugador 1
//nomb2[] nombre del jugador 2
void ininombres(char nomb1[],char nomb2[])
{
for (int i=0;i<15;i++)
{
nomb1[i]=' ';
nomb2[i]=' ';
}
}
/*-----------------------------------------------------------------------------*/
//Este procedimiento se encarga de guardar el juego en un archivo
//PARAMETROS:
//datos1 que contiene los datos para guardar
//archivo archivos en los que se guardan los juegos
void archivar(estructura datos1,archivos archivo)
{
int espacio;//posicion en la que se va guardar el juego
char nombrea[10];
imprimirGuardados(archivo);
textcolor(YELLOW);
textcolor(YELLOW);
//impresion del men£ de guardar juegos
gotoxy(1,1);
cprintf("MENU GUARDAR");
gotoxy(1,11);
cprintf("# ESPACIO A GUARDAR: ");
gotoxy(22,11);
printf(" ");
gotoxy(22,11);
scanf("%d",&espacio);
gotoxy(4,espacio+1);
printf("
");
gotoxy(4,espacio+1);
scanf("%s",nombrea);
textbackground(BLACK);
switch (espacio)
{
case 1://guardar en el archivo save1
{
for (int cc=0;cc<10;cc++)
datos1.narch[cc]=nombrea[cc];
archivo.save1=fopen("A:save1.dat","w");
if(archivo.save1==NULL)
printf("nERROR: No se puede abrir el archivo");
else
fwrite(&datos1,sizeof(struct
estructura),1,archivo.save1);
fclose(archivo.save1);
break;
}
case 2://guardar en el archivo save2
{
for (int cc=0;cc<10;cc++)
datos1.narch[cc]=nombrea[cc];
archivo.save2=fopen("A:save2.dat","w");
if(archivo.save2==NULL)
printf("nERROR: No se puede abrir el archivo");
else
fwrite(&datos1,sizeof(struct
estructura),1,archivo.save2);
fclose(archivo.save2);
break;
}
case 3://guardar en el archivo save3
{
for (int cc=0;cc<10;cc++)
datos1.narch[cc]=nombrea[cc];
archivo.save3=fopen("A:save3.dat","w");
if(archivo.save3==NULL)
printf("nERROR: No se puede abrir el archivo");
else
fwrite(&datos1,sizeof(struct
estructura),1,archivo.save3);
fclose(archivo.save3);
break;
}
case 4://guardar en el archivo save4
{
for (int cc=0;cc<10;cc++)
datos1.narch[cc]=nombrea[cc];
archivo.save4=fopen("A:save4.dat","w");
if(archivo.save4==NULL)
printf("nERROR: No se puede abrir
else
fwrite(&datos1,sizeof(struct
estructura),1,archivo.save4);
fclose(archivo.save4);
break;
}
case 5://guardar en el archivo save5
{
for (int cc=0;cc<10;cc++)
datos1.narch[cc]=nombrea[cc];
archivo.save5=fopen("A:save5.dat","w");
if(archivo.save5==NULL)
printf("nERROR: No se puede abrir
else
fwrite(&datos1,sizeof(struct
estructura),1,archivo.save5);
fclose(archivo.save5);
break;
}
case 6://guardar en el archivo save6
{
for (int cc=0;cc<10;cc++)
datos1.narch[cc]=nombrea[cc];
archivo.save6=fopen("A:save6.dat","w");
if(archivo.save6==NULL)
printf("nERROR: No se puede abrir
else
fwrite(&datos1,sizeof(struct
estructura),1,archivo.save6);
fclose(archivo.save6);
break;
}
case 7://guardar en el archivo save7
{
for (int cc=0;cc<10;cc++)
datos1.narch[cc]=nombrea[cc];
archivo.save7=fopen("A:save7.dat","w");
if(archivo.save7==NULL)
printf("nERROR: No se puede abrir
else
fwrite(&datos1,sizeof(struct
estructura),1,archivo.save7);
fclose(archivo.save7);
break;
}
case 8://guardar en el archivo save8
{
for (int cc=0;cc<10;cc++)
datos1.narch[cc]=nombrea[cc];
archivo.save8=fopen("A:save8.dat","w");
if(archivo.save8==NULL)
printf("nERROR: No se puede abrir
el archivo");
el archivo");
el archivo");
el archivo");
el archivo");
else
fwrite(&datos1,sizeof(struct
estructura),1,archivo.save8);
fclose(archivo.save8);
break;
}
case 9://guardar en el archivo save9
{
for (int cc=0;cc<10;cc++)
datos1.narch[cc]=nombrea[cc];
archivo.save9=fopen("A:save9.dat","w");
if(archivo.save9==NULL)
printf("nERROR: No se puede abrir el archivo");
else
fwrite(&datos1,sizeof(struct
estructura),1,archivo.save9);
fclose(archivo.save9);
break;
}
default:
{
gotoxy(1,12);
cprintf("ERROR: NO EXISTE");
//delay(1000);
}
}
}
/*-----------------------------------------------------------------------------*/
//Este procedimiento se encarga de cargar el juego en desde un archivo y
guardarlo en un registro
//PARAMETROS:
//datos2 registro que va a contener los datos del juego
//archivo archivos en los que se guardan los juegos
//*error indica un si ocurre un error en la carga de los archivos
void desarchivar(estructura datos2,archivos archivo,int *error)
{
int espacio;
char nombrea[10];
*error=0;
imprimirGuardados(archivo);
//impresion del men£ de cargar juegos
textcolor(YELLOW);
gotoxy(1,1);
cprintf("MENU CARGAR");
textcolor(YELLOW);
gotoxy(1,11);
cprintf("# JUEGO A CARGAR: ");
gotoxy(19,11);
printf(" ");
gotoxy(19,11);
scanf("%d",&espacio);
//archivo que se quiere cargar
switch (espacio)
{
case 1://cargar el archivo save1
{
archivo.save1=fopen("A:save1.dat","r");
if(archivo.save1==NULL)
{
gotoxy(1,12);
cprintf("ERROR: ESTµ VACIA");
//delay(1000);
*error=1;
}
else
fread(&datos2,sizeof(struct
estructura),1,archivo.save1);
fclose(archivo.save1);
break;
}
case 2://cargar el archivo save2
{
archivo.save2=fopen("A:save2.dat","r");
if(archivo.save2==NULL)
{
gotoxy(1,12);
cprintf("ERROR: ESTµ VACIA");
//delay(1000);
*error=1;
}
else
fread(&datos2,sizeof(struct
estructura),1,archivo.save2);
fclose(archivo.save2);
break;
}
case 3://cargar el archivo save3
{
archivo.save3=fopen("A:save3.dat","r");
if(archivo.save3==NULL)
{
gotoxy(1,12);
cprintf("ERROR: ESTµ VACIA");
//delay(1000);
*error=1;
}
else
fread(&datos2,sizeof(struct
estructura),1,archivo.save3);
fclose(archivo.save3);
break;
}
case 4://cargar el archivo save4
{
archivo.save4=fopen("A:save4.dat","r");
if(archivo.save4==NULL)
{
gotoxy(1,12);
cprintf("ERROR: ESTµ VACIA");
//delay(1000);
*error=1;
}
else
fread(&datos2,sizeof(struct
estructura),1,archivo.save4);
fclose(archivo.save4);
break;
}
case 5://cargar el archivo save5
{
archivo.save5=fopen("A:save5.dat","r");
if(archivo.save5==NULL)
{
gotoxy(1,12);
cprintf("ERROR: ESTµ VACIA");
//delay(1000);
*error=1;
}
else
fread(&datos2,sizeof(struct
estructura),1,archivo.save5);
fclose(archivo.save5);
break;
}
case 6://cargar el archivo save6
{
archivo.save6=fopen("A:save6.dat","r");
if(archivo.save6==NULL)
{
gotoxy(1,12);
cprintf("ERROR: ESTµ VACIA");
//
delay(1000);
*error=1;
}
else
fread(&datos2,sizeof(struct
estructura),1,archivo.save6);
fclose(archivo.save6);
break;
}
case 7://cargar el archivo save7
{
archivo.save7=fopen("A:save7.dat","r");
if(archivo.save7==NULL)
{
gotoxy(1,12);
cprintf("ERROR: ESTµ VACIA");
//
delay(1000);
*error=1;
}
else
fread(&datos2,sizeof(struct
estructura),1,archivo.save7);
fclose(archivo.save7);
break;
}
case 8://cargar el archivo save8
{
archivo.save8=fopen("A:save8.dat","r");
if(archivo.save8==NULL)
{
gotoxy(1,12);
cprintf("ERROR: ESTµ VACIA");
//
delay(1000);
*error=1;
}
else
fread(&datos2,sizeof(struct
estructura),1,archivo.save8);
fclose(archivo.save8);
break;
}
case 9://cargar el archivo save9
{
archivo.save9=fopen("A:save9.dat","r");
if(archivo.save9==NULL)
{
gotoxy(1,12);
cprintf("ERROR: ESTµ VACIA");
//
delay(1000);
*error=1;
}
else
fread(&datos2,sizeof(struct
estructura),1,archivo.save9);
fclose(archivo.save9);
break;
}
}
}
/*-----------------------------------------------------------------------------*/
//Funcion que retorna un 0 si la matriz esta vacia o un 1 si no lo est
//PARAMETROS:
//matrix[][3] es la matriz en la que se juega
int matrizVacia(int matrix[][3])
{
int resultado=0;
for (int f=0;f<3;f++)
for (int c=0;c<3;c++)
if(matrix[f][c]!=0)
resultado=1;
return resultado;
}
/*-----------------------------------------------------------------------------*/
//Procedimiento que se encarga de limpiar el contenido del registro
//PARAMETROS:
//datos registro que se va a limpiar
void limpiarregistro(estructura datos)
{
for (int ff=0;ff<3;ff++)
for (int cc=0;cc<3;cc++)
datos.mat[ff][cc]=0;
for (int cc=0;cc<10;cc++)
{
datos.nj1[cc]=' ';
datos.nj2[cc]=' ';
datos.narch[cc]=' ';
}
datos.jug=0;
datos.mod=0;
}
/*-----------------------------------------------------------------------------*/
//Este procedimiento despliega una lista de los juegos guardados en archivos
//PARAMETROS:
//archivo son los archivos en los que se guardan los juegos
void imprimirGuardados(archivos archivo)
{
estructura datos;
textbackground(BLUE);
textcolor(BLUE);
for(int x=1;x<=23;x++)
for(int y=1;y<13;y++)
{
gotoxy(x,y);
cprintf("Û");
}
textcolor(LIGHTCYAN);
limpiarregistro(datos);
//NOMBRE CON QUE SE GUARDà EL JUEGO 1
gotoxy(1,2);
cprintf("1- ");
archivo.save1=fopen("A:save1.dat","r");
gotoxy(4,2);
if(archivo.save1==NULL)//si el archivo no existe imprime vacio
printf("[ VACIO ]");
else
{
fread(&datos,sizeof(struct estructura),1,archivo.save1);
cprintf("%s",datos.narch);
fclose(archivo.save1);
}
limpiarregistro(datos);
//NOMBRE CON QUE SE GUARDà EL ARCHIVO 2
gotoxy(1,3);
cprintf("2- ");
archivo.save2=fopen("A:save2.dat","r");
gotoxy(4,3);
if(archivo.save2==NULL)//si el archivo no existe imprime vacio
printf("[ VACIO ]");
else
{
fread(&datos,sizeof(struct estructura),1,archivo.save2);
cprintf("%s",datos.narch);
fclose(archivo.save2);
}
limpiarregistro(datos);
//NOMBRE CON QUE SE GUARDà EL ARCHIVO 3
gotoxy(1,4);
cprintf("3- ");
archivo.save3=fopen("A:save3.dat","r");
gotoxy(4,4);
if(archivo.save3==NULL)//si el archivo no existe imprime vacio
printf("[ VACIO ]");
else
{
fread(&datos,sizeof(struct estructura),1,archivo.save3);
cprintf("%s",datos.narch);
fclose(archivo.save3);
}
limpiarregistro(datos);
//NOMBRE CON QUE SE GUARDà EL ARCHIVO 4
gotoxy(1,5);
cprintf("4- ");
archivo.save4=fopen("A:save4.dat","r");
gotoxy(4,5);
if(archivo.save4==NULL)//si el archivo no existe imprime vacio
printf("[ VACIO ]");
else
{
fread(&datos,sizeof(struct estructura),1,archivo.save4);
cprintf("%s",datos.narch);
fclose(archivo.save4);
}
limpiarregistro(datos);
//NOMBRE CON QUE SE GUARDà EL ARCHIVO 5
gotoxy(1,6);
cprintf("5- ");
archivo.save5=fopen("A:save5.dat","r");
gotoxy(4,6);
if(archivo.save5==NULL)//si el archivo no existe imprime vacio
printf("[ VACIO ]");
else
{
fread(&datos,sizeof(struct estructura),1,archivo.save5);
cprintf("%s",datos.narch);
fclose(archivo.save5);
}
limpiarregistro(datos);
//NOMBRE CON QUE SE GUARDà EL ARCHIVO 6
gotoxy(1,7);
cprintf("6- ");
archivo.save6=fopen("A:save6.dat","r");
gotoxy(4,7);
if(archivo.save6==NULL)//si el archivo no existe imprime vacio
printf("[ VACIO ]");
else
{
fread(&datos,sizeof(struct estructura),1,archivo.save6);
cprintf("%s",datos.narch);
fclose(archivo.save6);
}
limpiarregistro(datos);
//NOMBRE CON QUE SE GUARDà EL ARCHIVO 7
gotoxy(1,8);
cprintf("7- ");
archivo.save7=fopen("A:save7.dat","r");
gotoxy(4,8);
if(archivo.save7==NULL)//si el archivo no existe imprime vacio
printf("[ VACIO ]");
else
{
fread(&datos,sizeof(struct estructura),1,archivo.save7);
cprintf("%s",datos.narch);
fclose(archivo.save7);
}
limpiarregistro(datos);
//NOMBRE CON QUE SE GUARDà EL ARCHIVO 8
gotoxy(1,9);
cprintf("8- ");
archivo.save8=fopen("A:save8.dat","r");
gotoxy(4,9);
if(archivo.save8==NULL)//si el archivo no existe imprime vacio
printf("[ VACIO ]");
else
{
fread(&datos,sizeof(struct estructura),1,archivo.save8);
cprintf("%s",datos.narch);
fclose(archivo.save8);
}
limpiarregistro(datos);
//NOMBRE CON QUE SE GUARDà EL ARCHIVO 9
gotoxy(1,10);
cprintf("9- ");
archivo.save9=fopen("A:save9.dat","r");
gotoxy(4,10);
if(archivo.save9==NULL)//si el archivo no existe imprime vacio
printf("[ VACIO ]");
else
{
fread(&datos,sizeof(struct estructura),1,archivo.save9);
cprintf("%s",datos.narch);
fclose(archivo.save9);
}
limpiarregistro(datos);
}
/*-----------------------------------------------------------------------------*/
//Procedimiento que imprime la presentacion al principio y al presionar F1
durante un juego
void presentacion(void)
{
clrscr();
textcolor(LIGHTCYAN);
gotoxy(23,5);
cprintf("COLEGIO UNIVERSITARIO DE ALAJUELA");
//delay(10);
gotoxy(36,6);
cprintf("( CUNA )");
//delay(10);
gotoxy(33,7);
cprintf("ELABORADO POR:");
//delay(10);
textcolor(YELLOW);
gotoxy(30,8);
cprintf("FREDDY LEON SALAZAR");
//delay(10);
gotoxy(36,9);
cprintf("20020188");
//delay(10);
textcolor(LIGHTCYAN);
gotoxy(30,10);
cprintf("PROYECTO PROGRAMADO");
//delay(10);
textcolor(YELLOW);
gotoxy(29,11);
cprintf("CURSO: PROGRAMACION 2");
//delay(10);
gotoxy(22,12);
cprintf("PROFESOR: GEOVANNY CHACàN RODRIGUEZ");
//delay(10);
gotoxy(31,13);
textcolor(LIGHTCYAN);
cprintf("III CUATRIMESTRE");
//delay(10);
gotoxy(38,14);
cprintf("2002 ");
gotoxy(79,25);
marco();
//delay(3000);
getch();
}
/*-----------------------------------------------------------------------------*/
//Imprime la barra de teclas que se pueden usar en la parte inferior de la
pantalla durante el juego
void ayuda(void)
{
textbackground(BLUE);
gotoxy(1,25);
clreol();
textcolor(LIGHTGREEN);
gotoxy(2,25);
cprintf("ENTER");
textcolor(WHITE);
gotoxy(7,25);
cprintf(" UBICAR ");
textcolor(LIGHTGREEN);
gotoxy(16,25);
cprintf("ESCAPE");
textcolor(WHITE);
gotoxy(23,25);
cprintf("MENé ");
textcolor(LIGHTGREEN);
gotoxy(30,25);
cprintf("%c",27);
gotoxy(31,25);
cprintf("%c",26);
gotoxy(32,25);
cprintf("%c",24);
gotoxy(33,25);
cprintf("%c",25);
textcolor(WHITE);
gotoxy(35,25);
cprintf("MOVER ");
textcolor(LIGHTGREEN);
gotoxy(43,25);
cprintf("F1");
textcolor(WHITE);
gotoxy(46,25);
cprintf("CREDITOS ");
textcolor(LIGHTGREEN);
gotoxy(57,25);
cprintf("F2");
textcolor(WHITE);
gotoxy(60,25);
cprintf("GUARDAR ");
textcolor(LIGHTGREEN);
gotoxy(70,25);
cprintf("F3");
textcolor(WHITE);
gotoxy(73,25);
cprintf("CARGAR");
textbackground(BLACK);
}
/*-----------------------------------------------------------------------------*/
//Imprime el marco exterior
void marco(void)
{
for (int X=1; X<=79; X++)
for (int Y=1; Y<=24; Y++)
{
if( (X==1)||(X==79)||(Y==1)||(Y==24) )
{
gotoxy(X,Y);
cprintf("ÛÛ");
}
}
}
/*-----------------------------------------------------------------------------*/