Escribir un juego de backgammon en lenguaje C
********************************************* ***** ***************/
/* Los archivos de encabezado que contienen las funciones de la biblioteca utilizadas en el programa deben incluirse usando el comando #include* /
#include lt;stdio.hgt;
#include lt;bios.hgt;
#include lt;ctype.hgt;
#include lt;conio .hgt;
#include lt;dos.hgt;
/****************** ******** *************************************/
/* Definir constantes simbólicas*/
/*Definir los caracteres de tabulación necesarios para dibujar el tablero de ajedrez*/
#define CROSSRU 0xbf /*Punto de la esquina superior derecha*/
#define CROSSLU 0xda /* Punto de la esquina superior izquierda*/
#define CROSSLD 0xc0 /*Punto de la esquina inferior izquierda*/
#define CROSSRD 0xd9 /*Inferior punto de la esquina derecha*/
#define CROSSL 0xc3 /*Izquierda*/
#define CROSSR 0xb4 /*Derecha*/
#define CROSSU 0xc2 /* Arriba*/
#define CROSSD 0xc1 /*Abajo*/
#define CROSS 0xc5 /*Punto de cruce*/
/*Definir la posición del Esquina superior izquierda del tablero de ajedrez en la pantalla*/
#define MAPXOFT 5
#define MAPYOFT 2
/*Define el código de clave de operación del jugador 1 */
#define PLAY1UP 0x1157/*Movimiento hacia arriba--'W'*/
#define PLAY1DOWN 0x1f53/*Mover hacia abajo--'S'*/
#define PLAY1LEFT 0x1e41/*Desplazar a la izquierda--'A' */
#define PLAY1RIGHT 0x2044/*Mover a la derecha--'D'*/
#define PLAY1DO 0x3920/*Mover--Barra espaciadora*/
/*Definir el código de tecla de operación del jugador 2*/
#define PLAY2UP 0x4800/*Mover hacia arriba--tecla de dirección arriba*/
#define PLAY2DOWN 0x5000/*Mover hacia abajo--Tecla de dirección hacia abajo*/
#define PLAY2LEFT 0x4b00/*Mover hacia la izquierda--Tecla de dirección hacia la izquierda*/
#define PLAY2RIGHT 0x4d00/*Mover a la derecha--Tecla de dirección derecha */
#define PLAY2DO 0x1c0d/*Colocar--Tecla Enter*/
/*Si desea salir A mitad del juego, puedes presionar la tecla Esc*/<
/p>
#define ESCAPE 0x011b
/*Define el estado del punto de intersección en el tablero de ajedrez, es decir, si hay una pieza de ajedrez en ese punto*/
/*Si hay una pieza de ajedrez, también debería Puede indicar qué pieza de ajedrez es del jugador*/
#define CHESSNULL 0 //No hay ninguna pieza de ajedrez
#define CHESS1 'O'//Pieza de ajedrez del jugador nº 1
#define CHESS2 'X'//Pieza de ajedrez del jugador nº 2
/*Definir tipo de clave*/
#define KEYEXIT 0/*Tecla de salida*/
#define KEYFALLCHESS 1/*soltar tecla*/
#define KEYMOVECURSOR 2/*tecla de movimiento del cursor*/
#define KEYINVALID 3/*clave no válida*/
/*Definir constantes simbólicas: verdadero, falso --- verdadero es 1, falso es 0 */
#define VERDADERO 1
#define FALSO 0
/*************************** ********************** *************/
/* Definir estructura de datos*/
/*Estructura de datos de las coordenadas de intersección del tablero de ajedrez*/
punto de estructura
{
int x, y
;};
/******** ******************************* ********************** /
/*Descripción del prototipo de función personalizada*/
void Init(void) ;
int GetKey(void);
int CheckKey(int press);
int ChangeOrder(void);
int ChessGo (int Orden, cursor de punto de estructura);
void DoError(void) ;
void DoOK(void);
void DoWin(int Order);
void MoveCursor(int Order, int press);
void DrawCross(int x, int y);
void DrawMap(void);
int JudgeWin(int Orden, cursor de punto de estructura);
int JudgeWinLine(int Orden, cursor de punto de estructura, dirección int);
void ShowOrderMsg(int Orden); /p>
void Juego Final(void);
/* ***************************** ********************** *******/<
/p>
/********************************************* ***************/
/* Definir variables globales*/
int gPlayOrder /*Indicar el reproductor actual*/< / p>
struct point gCursor; /*La posición del cursor en el tablero de ajedrez*/
char gChessBoard[19][19] /*Se utiliza para registrar el estado de cada punto en el tablero de ajedrez*/
/*************************************** ***** ****************/
/********************* ******* *************************************/
/*Función principal*/
void main()
{
int press;
int bOutWhile=FALSE; Salir del indicador de bucle*/
Init();/*Inicializar imagen, datos*/
while(1)
{
press=GetKey();/*Obtener usuario El valor de la clave*/
switch(CheckKey(press))/*determinar el tipo de clave*/
{
/*es la tecla de salida*/
case KEYEXIT:
clrscr() /*Borrar pantalla*/
bOutWhile = TRUE
break;
/*Es la tecla de movimiento*/
case KEYFALLCHESS:
if(ChessGo(gPlayOrder, gCursor)== FALSE)/*Jugar ajedrez*/
DoError();/*Movimiento incorrecto*/
else
{
DoOK( );/*Movimiento correcto*/
/*Si el jugador actual gana*/
if(JudgeWin(gPlayOrder, gCursor)==TRUE)
{
DoWin(gPlayOrder) ;
bOutWhile = TRUE /*Establece el indicador del bucle de salida en verdadero*/
}
/*De lo contrario*/
else
/*Intercambiar jugadores*/
ChangeOrder()
}
break;
/*Es la tecla de movimiento del cursor*/
case KEYMOVECURSOR:
MoveCursor(gPlayOrder, presione);
p>
break;
/*es una clave no válida*/
case KEYINVALID:
break;
}< / p>
if(bOutWhile==TRUE)
descanso
}
/*El juego termina*/
Fin del juego ();
}
/****************************** **** **************************/
/*Inicialización de interfaz, inicialización de datos*/
void Init(void)
{
int i, j
char *Msg[]=
{
"Tecla Jugador1:",
" ARRIBA----w",
" ABAJO--s",
" IZQUIERDA- -a",
" DERECHA-d",
" DO----espacio",
"",
"Tecla Jugador2:",
"ARRIBA----arriba",
"ABAJO--abajo",
"IZQUIERDA- -izquierda",
" DERECHA-derecha",
" DO----ENTER",
"",
"salir del juego: ",
"ESC",
NULL,
};
/*El primero en moverse es el jugador No 1*/
gPlayOrder = CHESS1;
/*Los datos del tablero se borran, es decir, no hay piezas de ajedrez al comienzo de cada punto del tablero*/<. /p>
for(i=0; ilt ;19;i)
for(j=0;jlt;19;j)
gTablero de ajedrez[i][j ]=CHESSNULL;
/* Posición inicial del cursor*/
gCursor.x=gCursor.y=0;
/*Dibujar un tablero de ajedrez*/
textmode(C40);
DrawMap();
/*Mostrar descripción de la tecla de operación*/
i=0;
textcolor(BROWN);
while(Msg[i]!=NULL)
{
gotoxy(25, 3 i);
cputs(Msg[i]) ;
i ;
}
/*Mostrar el jugador actual*/
ShowOrderMsg(gPlayOrder);
/*Mueve el cursor a la esquina superior izquierda del tablero de ajedrez*/
gotoxy(gCursor.x MAPXOFT, gCursor.y MAPYOFT) ;
}
/*Dibujar el tablero de ajedrez*/
void Draw
Mapa(void)
{
int i, j;
clrscr()
for(i=0; ilt; 19; i )
for(j=0; jlt; 19; j )
DrawCross(i,j);
}
/*Dibujar intersecciones en el tablero de ajedrez*/
void DrawCross(int x, int y)
{
gotoxy(x MAPXOFT, y MAPYOFT ) ;
/*La intersección es la pieza de ajedrez del jugador 1*/
if(gChessBoard[x][y]==CHESS1)
{
textcolor(LIGHTBLUE);
putch(CHESS1);
return
}
/* La intersección es la pieza de ajedrez del jugador 2*/
if(gChessBoard[x][y]==CHESS2)
{
textcolor(LIGHTBLUE) ;
putch(CHESS2);
return;
}
textcolor(VERDE);
/ *Arriba izquierda intersección de esquina*/
if(x==0amp;amp;y==0)
{
putch(CROSSLU);
p >return;
}
/*Intersección de la esquina inferior izquierda*/
if(x==0amp;amp;y==18 )
{
putch(CROSSLD);
return;
}
/*Cruz en la parte superior Punto de la esquina derecha*/
if(x==18amp;amp;y==0)
{
putch(CROSSRU);
return;
}
/*Intersección de la esquina inferior derecha*/
if(x==18amp; amp; y==18)
{
putch(CROSSRD);
return;
}
/*Intersección del límite izquierdo*/
if(x==0)
{
putch(CROSSL
retorno
}
/*Intersección del límite derecho*/
if(x==18)
{
putch(CROSSR);
return;
}
/*Intersección del límite superior*/
if(y==0)
{
putch(CROSSU);
return
}
/*Intersección del límite inferior*/
if(y==18)
{
putch(
CROSSD);
return;
}
/*Punto de intersección en el medio del tablero*/
putch(CROSS) ;
p>
}
/*Intercambiar jugadores*/
int ChangeOrder(void)
{
if( gPlayOrder==AJEDREZ1)
gPlayOrder=AJEDREZ2;
else
gPlayOrder=AJEDREZ1;
return( gPlayOrder);
}
/*Obtener valor clave*/
int GetKey(void)
{
char lowbyte;
int press;
while (bioskey(1) == 0)
/*Si el usuario no presiona una tecla , bucle vacío*/
press=bioskey(0);
lowbyte=pressamp;0xff;
press=pressamp;0xff00 toupper(lowbyte);
return(press) ;
}
/*Manejo de errores de raíz*/
void DoError(void)
{
sonido(1200);
retraso(50);
nosound();
/*Win procesamiento de ajedrez*/
void DoWin(int Order)
{
sound(1500); p>
sonido(0); retraso(50);
sonido(800); retraso(100);
sonido(50); /p>
sonido(1500); retraso(100);
sonido(0); retraso(50);
sonido(0 ); retraso(50);
nosound();
color de texto(PARPADEO ROJO); 25, 20);
if(Orden==AJEDREZ1)
cputs("¡JUGADOR1 GANÓ!");
else
cputs("¡JUGADOR2 GANÓ!");
gotoxy(25,21);
cputs(" \\lt;^ ^gt;/");
getch();
}
/*Mover ajedrez*/
int ChessGo(int Orden, estructura punto Cursor)
{
/ *Determinar si hay una pieza de ajedrez en la intersección*/
if(gChessBoard[Cursor.x]
[Cursor.y]==CHESSNULL)
{
/*Si no hay pieza de ajedrez, puedes colocar la pieza*/
gotoxy(Cursor .x MAPXOFT, Cursor .y MAPYOFT);
textcolor(LIGHTBLUE);
putch(Orden);
gotoxy(Cursor.x MAPXOFT, Cursor. y MAPYOFT);
gChessBoard[Cursor.x][Cursor.y]=Orden
return TRUE; else
return FALSE;
}
/*Juzga si el jugador actual ganará después de colocar la pieza*/
int JudgeWin (int Orden, cursor de punto de estructura)
{
int
for(i=0; ilt; 4; i )
/*Juzga si hay 5 piezas de ajedrez consecutivas en la dirección especificada*/
if(JudgeWinLine(Order, Cursor, i))
return TRUE;
return FALSE;
}
/*Juzga si hay 5 piezas de ajedrez consecutivas en la dirección especificada*/
int JudgeWinLine(int Order) , struct point Cursor, int dirección)
{
int i;
struct point pos, dpos;
const int testnum = 5 ;
int count;
switch(dirección)
{
caso 0: /*en dirección horizontal*/
pos.x=Cursor.x-(testnum-1);
pos.y=Cursor.y;
dpos.x=1;
dpos.y=0;
break;
caso 1: /*en dirección vertical*/
pos.x=Cursor .x;
pos.y=Cursor.y-(testnum-1);
dpos.x=0
dpos.y=1;
break;
caso 2: /*En dirección diagonal desde la parte inferior izquierda a la superior derecha*/
pos.x=Cursor.x-(testnum -1);
p>pos.y=Cursor.y (testnum-1);
dpos.x=1
dpos.y=; -1;
break;
caso 3: /*En dirección diagonal desde la parte superior izquierda a la inferior derecha*/
pos.x=Cursor.x -(t
estnum-1);
pos.y=Cursor.y-(testnum-1);
dpos.x=1;
dpos.y= 1;
descanso;
}
recuento=0;
para(i=0; ilt; testnum*2 1; i )
{
if(pos.xgt;=0amp;amp;pos.xlt;=18amp;amp;pos.ygt;=0amp;amp;pos.ylt; =18)
{
if(gChessBoard[pos.x][pos.y]==Orden)
{
contar ;
if(countgt;=testnum)
devolver VERDADERO;
}
más
contar =0;
}
pos.x =dpos.x;
pos.y =dpos.y; /p>
return FALSE;
}
/*Mover cursor*/
void MoveCursor(int Order, int press)
{
cambiar(presionar)
{
caso PLAY1UP:
if(Order==CHESS1amp;amp;gCursor .ygt;0)
gCursor.y--;
break;
case PLAY1DOWN:
if(Order==CHESS1amp ;amp; gCursor.ylt; 18)
gCursor.y ;
romper;
caso PLAY1LEFT:
if(Order= =CHESS1amp;amp;gCursor.xgt;0)
gCursor.x--;
descanso;
caso JUGAR1DERECHA:
if(Order==AJEDREZ1amp;amp;gCursor.xlt;18)
gCursor.x;
romper;
caso PLAY2UP:
if(Order==CHESS2amp;amp;gCursor.ygt;0)
gCursor.y--;
break;
caso PLAY2DOWN:
if(Order==CHESS2amp;amp;gCursor.ylt;18)
gCursor.y;
romper;<
/p>
caso PLAY2LEFT:
if(Order==CHESS2amp;amp;gCursor.xgt;0)
gCursor.x--;
romper;
caso PLAY2RIGHT:
if(Order==CHESS2amp;amp;gCursor.xlt;18)
gCursor.x;
romper;
}
gotoxy(gCursor.x MAPXOFT, gCursor.y MAPYOFT
}
/*); Procesamiento de finalización del juego*/
void EndGame(void)
{
textmode(C80);
}
/*Mostrar el jugador de ajedrez actual*/
void ShowOrderMsg(int Order)
{
gotoxy(6, MAPYOFT 20);
textcolor(ROJO CLARO);
if(Order==CHESS1)
cputs("¡Jugador1 va!");
else
cputs("¡Player2 go!");
gotoxy(gCursor.x MAPXOFT, gCursor.y MAPYOFT);
}
/* Manejo correcto de movimientos*/
void DoOK(void)
{
sonido(500);
retardo(70);
sonido(600);
retraso(50);
sonido(1000);
retraso(100); p >
nosound();
}
/*Verificar el tipo de clave del usuario*/
int CheckKey(int press)
{
if(press==ESCAPE)
return KEYEXIT /*es la tecla de salida*/
else
if
( ( presione==PLAY1DO amp; amp; gPlayOrder==CHESS1) ||
( presione==PLAY2DO amp; amp; gPlayOrder==CHESS2)
)
return KEYFALLCHESS; /*es la tecla de colocación*/
else
if
( press== PLAY1UP || presione==PLAY1DOWN ||
presione==PLAY1LEFT || presione==PLAY1RIGHT ||
presione==PLAY2UP || presione==PLAY2DOWN ||
presione==
PLAY2LEFT || presione==PLAY2RIGHT
)
return KEYMOVECURSOR; /*es la tecla de movimiento del cursor*/
else
return KEYINVALID ;/*Botón no válido*/
}