Tres en Raya o Juego del Gato

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("██");
}
}
}
/*------------------------------------------------------------------------------*/
Descargar adjuntos
COMPARTE ESTE TUTORIAL

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
HAY 22 COMENTARIOS
  • Anónimo dijo:

    me gustaria saber el codigo

  • Anónimo dijo:

    holaa todos por favor el que tenga el codigo del tres en raya o triqui en c++ y que se guege contra el ordenador porfavor enviarmelo al siguiente msn c.j.p.m@hotmail.com se os agradeceria es nota final del se mestre y lo hago pero no me funciona lo de jugar contra el ordenador

  • Anónimo dijo:

    Por favor me pueden mandar el programa que me permita jugar "tres en raya" contra la computadora. Pero el cˇdigo necesariamente tiene que ir en NetBeans 6.0.1. Se les agradece por anticipado.

  • Anónimo dijo:

    Por favor me pueden enviar el juego del tres en raya en Turbo Pascal, solo con procedimientos y funciones sin utilizar vectores y matrices.Gracias

  • Anónimo dijo:

    me podria mandar alguien el tres en raya en pascal

  • Anónimo dijo:

    que hacen esos caracteres al imprimir, como busco algo similar cprintf("▄▀▀▀▄"); cprintf("▀▄ ▄▀");

  • Anónimo dijo:

    Como estan? x favor necesito el juego de el 21 que corra bien... que aparezcan las cartas tambien... en verdad es de urgencia... es para borland c++.... espero me puedan ayudar... o x lo menos un alcance como guia...

  • Anónimo dijo:

    que onda, quisiera saber si me pueden pasar el programa dek gato, no tan complicado, quiero el juego del gato sencillo, y que si compile por favor. Gracias.

  • Anónimo dijo:

    Para los que quieran el cˇdigo sin errores pueden solicitarmelo enviandome un correo a fleons79@gmail.com con el asunto de "Tres en Raya"

  • Anónimo dijo:

    necesito el juego del gato pero sin matrices... solo con las funciones basicas.......

  • Anónimo dijo:

    Hola, necesito el juego de las tres en raya en turbo c debe jugar contra el ordenador Llevo intentandolo un montˇn de tiempo pero no consigo que funcione, os agradecerÝa que me ayudarais. GRACIAS

  • Anónimo dijo:

    Espero poder recibir el mensaje Gracias

  • Anónimo dijo:

    hola me podrian hacer el favor de facilitarme este mismo codigo pero en pascal 7.0 ayudenme por favor me lo pidieron en la universidad y el tiempo que nos dieron es muy corto estare agradecido de sus beuno oficios.

  • Anónimo dijo:

    SI DESEAN SOLICITARME ESTE CËDIGO SIN ERRORES ENVIENME UN CORREO A: fleons79@gmail.com CON EL SIGUIENTE ASUNTO: Tres en raya

  • Anónimo dijo:

    quiero jugar a gato

  • Anónimo dijo:

    yeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee compa˝eros

  • Anónimo dijo:

    Juego clßsico,entretenido, de toda la vida y que jamas pasara a la historia

  • Anónimo dijo:

    Tu tres en raya no compila

  • Anónimo dijo:

    necesito el codigo fuente del programa porque este que envio no me funciona me manda muchos errores. gracias

  • Anónimo dijo:

    No se que es lo que pasa pero cuando ejecuto el programaen turbo me sale que tiene 25 errores la vercion de mi turbo c es la 3.0 si me prodrian decir porke me salen los errores gracias ;-)

  • Anónimo dijo:

    El cˇdigo del programa de 3 en raya, lo hemos probado a compilar con el Turbo C y nos ha dado nada menos que 25 errores.

  • Anónimo dijo:

    hola: necesito un juego en pascal que contenga procedimientos y funciones , les agradezco su colaboracion. Gracias.

Conéctate o Regístrate para dejar tu comentario.