/*
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: [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)
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("ÛÛ");
}
}
}
/*------------------------------------------------------------------------------*/
Tres en Raya o Juego del Gato
Tres en raya en modo texto, escrito en Turbo C. Se puede jugar contra la computadora.
Descargar adjuntos
COMPARTE ESTE TUTORIAL
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN LINKEDIN
COMPARTIR EN WHATSAPP