|
/*
COLEGIO UNIVERSAITARIO DE ALAJUELA
PROYECTO PROGRAMADO EN LENGUAJE C
CURSO: PROGRAMACIàN II
PROFESOR: PROFESOR: GEOVANNY CHACàN RODRIGUEZ
ESTUDIANTE: FREDDY LEàN SALAZAR
CARNE: 20020188
III CUATRIMESTRE
A¥O 2002
*/ #include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <stdlib.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);
/*------------------------------------------------------------------------------*/
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:
Esta dirección de correo electrónico está protegida contra los robots de spam, necesita tener Javascript activado para poder verla
");
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)
columna=0;
else
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
turno=-1;//cambio de turno al jugador 2
}
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
imprimirSimbolo(-1,fila,columna);
}
else//si el modo es humano vrs m quina realizar la jugada de la maquina
{
mejorJugada(matrix,&fila,&columna);//determinar la mejor posicion para jugar
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+BLINK);
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+BLINK);
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+BLINK);
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(®istro,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 ha encontrado la mejor jugada
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 ha encontrado la mejor jugada
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 ha encontrado la mejor jugada
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 ha encontrado la mejor jugada
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;
}
}
}
//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 ha encontrado la mejor jugada
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 ha encontrado la mejor jugada
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 ha encontrado la mejor jugada
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 ha encontrado la mejor jugada
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
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 el archivo\");
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 el archivo\");
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 el archivo\");
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 el archivo\");
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\");
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 (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);
}
/*------------------------------------------------------------------------------*/
//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(\"ÛÛ\");
}
}
}
/*------------------------------------------------------------------------------*/ http://www.programacion.com/codigo/137/
|
