Red de conocimiento informático - Descarga de software - Escribir un juego de backgammon en lenguaje C

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*/

}