Tres en Raya o Juego del Gato

Autor: Freddy León Salazar

Tres en raya en modo texto, escrito en Turbo C. Se puede jugar contra la computadora.

/*
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: fleons79@hotmail.com\");
			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(\"ÛÛ\");
			}
		}
}
/*------------------------------------------------------------------------------*/

Utilidades

	Leer comentarios (31)
	Escribir comentario
	Puntuación: No disponible
	Votar
	Recomendar este código
	Estadísticas

Patrocinados

Hospedaje web y servidores dedicados linux por Ferca Network