Red de conocimiento informático - Material del sitio web - ¿Cómo programar un juego de blackjack en lenguaje C?

¿Cómo programar un juego de blackjack en lenguaje C?

/*6.3.4 Programa fuente*/

#define N 20

#define COL 100

#define FILA 40

# incluir "stdio.h"

#include "time.h"/*Función de hora del sistema*/

#include "graphics.h"/*Función de gráficos**

#include "alloc.h"/* Función de asignación dinámica de direcciones***

#include "stdlib.h"/*Función de biblioteca**

#include " string.h"/* Función de cadena*/

#include "ctype.h"/*Función de operación de caracteres*/

char p[4][13]={< / p>

{'A', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'J', 'Q', 'K'}, /*Cartas de póquer, 10 está representado por 0*/

{'A', 2', '3', '4', '5', ' 6 ','7','8','9','0','J','Q','K'},

{'A','2','3 ' , '4', '5', '6', '7', '8', '9', '0', 'J', 'Q', 'K'}

{ ' A', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'J', 'Q', 'K' }};

typedef struct node

{

int data;

struct node * link;

}STACK1;/*stack1**/

typedef struct node2

{

datos char;

struct node2 *link <; /p>

}STACK2; /*stack2**/

void init(void); /* Controlador de gráficos*/

void close(void); close*/

void play(void);/* El proceso específico de repartir cartas*/

void rand1(int j);/* Función de reparto aleatorio*/

void change(char *e, char *a); /* Función de infijo a sufijo*/

int computer(char *s); >

STACK1 *initstack1(STACK1 *top); /* Inicialización de pila*/

STACK1 *push(STACK1 *top, int x/* Operación de entrada de pila*/<); p>STACK1 *pop(STACK1 *top); /* pila elimina el elemento superior de la pila*/

int topx(STACK1 *top); /*stack1 lee el elemento superior de la pila*/

STACK1 *ptop(STACK1 *top, int *x); /*Stack1 lee el valor del elemento superior de la pila y elimina el elemento superior*/

int vacío(STACK1 * top); /*Función para determinar si la pila 1 está vacía*/

STACK2 *initsta

ck2(STACK2 *top); /* Inicializar pila 2*/

STACK2 *push2(STACK2 *top, char x); /*Operación de entrada de pila 2*/

STACK2 * pop2(STACK2 *top); /*La pila 2 elimina el elemento superior de la pila*/

char topx2(STACK2 *top); /*La pila 2 lee el elemento superior de la pila*/

STACK2 *ptop2(STACK2 *top, char *x); /*Stack2 lee el valor del elemento superior de la pila y elimina el elemento superior de la pila*/

int vacío2 (STACK2 *top); /* Determinar la pila 2 si es una función vacía*

int text1(char *s); /p>

{

char s[N], s1[N], ch;

int i, resultado

int gdriver, gmode; ;

clrscr(); / *Borrar la pantalla*/

init() /*Función de inicialización*/

while(1)

{

setbkcolor( NEGRO); /*Establecer color de fondo*/

cleardevice(); /*Borrar pantalla*/

play( ); /*distribuidor**

gotoxy(1,15); /* mover cursor**/

printf("------------) --------------Nota----- ---------------\n");

printf(" Ingrese expreso de acuerdo con los cuatro números anteriores\n"); /*Solicitar mensaje**/

printf(" Formato como sigue: 2.*(5. 7.)\n"); / * Solicitar formato de cadena de entrada**/

printf(" -- -------------------------- --- ---------------\n");

scanf("sc", s1, amp; ch); /* Ingrese la cadena y presione Enter*/

change(s1, s); /* Llama a la función de cambio a La expresión intermedia s1 se convierte en la expresión postfix s */

result=computer(s); Calcula el valor de la expresión postfix y devuelve el resultado*/

if(result= =24) /*Si el resultado es igual a 24 */

text1("muy bueno "); /*Llame a la función text1 para mostrar la cadena "muy bien"*/

else

text1("¡incorrecto! !!!") ;/* De lo contrario, la función text1 mostrará la cadena "¡¡¡incorrecto!!!" */

else

text1("incorrecto!*/

printf("Continuar (s/n)?\n"); /* Mensaje indicador, si se debe continuar*/

scanf("c", amp; ch); / * Introduce un carácter */

p>

if(ch=='n'||ch=='N') /* Si el carácter es igual a n o N */

break /* Saltar del; bucle y finalizar el programa*/

}

close()

return /*return**

}

void rand1 (int j)/*aleatorizar la función de licencia*/

{

int kind, num

char str[ 3; ], n;

randomize();

while(1)/* bucle hasta que se reparta una carta**

{

kind=random(4) ; /* número aleatorio de trajes**

num=random(13); /* número aleatorio de tallas**

if( p[kind] ][num]!=- 1) /*Este número no se ha tomado antes

}

int computer(char *s) /* Función de cálculo*/

{

PILA1 *top=NULL;

int i, k, num1, num2, resultado

i=0;

while(s[i ]! = '\0') /* Realice las siguientes operaciones cuando la cadena no esté terminada*

{

if(isdigit(s[ i]))/* Determinar si el carácter es un número*

{

k=0; /* k se establece inicialmente en 0*

do {

k=10* k s[i]-'0'; /* Concatenar caracteres en números decimales*/

i /* Agregar i a 1*/

} while(s[i]! ='.'); /* Repetir el bucle cuando el carácter no sea '.', cuando el carácter no sea '.'*/

arriba =push(top,k); /*Pon el número generado en la pila*/

}

if(s[i]==' ') /*Si es el ' ' número*/

{

top=ptop(top, amp; num2 /*Elimina el elemento superior de la pila y colócalo en num2*/

top=ptop(top, amp; num1); /*Elimina el elemento superior de la pila y colócalo en num1*/

result=num2 num1;/* Agrega num1 y num2 y ponerlo en resultado*/

top=push(top, amp; num2) /* Poner el resultado en resultado*/

top=push(top, amp; num2); ; /* Poner el resultado en resultado*

top=push(result);/ *Pon el resultado en resultado resultado /*Pon el resultado en la pila*/

}

if(s[i]=='-') /*Si el símbolo es '-' */

{

top=ptop( top, amp; num2); /*Saque el elemento superior de la pila y colóquelo en num2*/

top= ptop(top, amp; num1);

elemento superior y ponerlo en num1*/

result=num1-num2; /*Restar num1 de num2 y poner el resultado en result*/

top=push(top , result ); /* Empujar el resultado en la pila * result=num1/num2; /* Almacenar el resultado de dividir num1 por num2 en resultado*

top=push(top, result); el resultado se coloca en la pila*/

}

i; /*i plus 1*/

}

top =ptop (top , amp; resultado); /*El valor del último elemento en la parte superior de la pila es el resultado del cálculo*/

devolver resultado/*Devolver resultado*/

}

STACK1 *initstack1(STACK1 *top) /*Inicialización*/

{

top=NULL /*El puntero superior de la pila es establecido en null*/

return top;/* Devuelve el puntero superior de la pila*/

}

STACK1 *push(STACK1 *top, int x) /*función initstack*/

{

STACK1 *p; /* Tipo de puntero temporal STACK1**

p=(STACK1 *)malloc(sizeof( STACK1)); /* Solicitar espacio de tamaño STACK1* **

if(p==NULL) /* Si p está vacío***

{

printf("la memoria está desbordada\n. !!!") /* Mostrar desbordamiento de memoria*/

exit(0); }

p-gt ;data=x; /* Guarda el valor x en el nuevo espacio*/

p-gt; por el puntero superior de la pila actual***

top=p; /* El nuevo puntero superior de la pila es el nodo recién insertado*/

return top /* Devuelve el puntero superior de la pila*/

}

STACK1 *pop(STACK1 *top) /* Salir de la pila*/

{

STACK1 *q; /* Definir variables temporales*/

q =top;/* Guardar el puntero superior de la pila actual*/

top=top-gt; * Retroceder el puntero superior de la pila*/

free(q); /* Liberar q */

return top /* Devolver el puntero superior de la pila */

}

int topx(STACK1 *top) /* Leer la parte superior de los elementos de la pila*/

{

if(top==NULL ) /* Si la pila está vacía*/

{

printf( "La pila es nula\n" /* Mostrar información sobre la pila vacía */

return 0; /* Devuelve el número entero 0 */

}

Devuelve datos top-gt /* Devuelve el elemento superior de la pila */

}

STACK1 *ptop(STACK1 *top, int *x) /* Toma el elemento superior de la pila y elimínalo.

Elemento superior de la pila*/

{

*x=topx(top); /* Leer el elemento superior de la pila*/

top= pop(top) ;/* Eliminar el elemento superior de la pila*/

return top; /* Devuelve el puntero superior de la pila*/

}

int vacío(STACK1 *top) / * Determinar si la pila está vacía*/

{

if(top==NULL) /* Si está vacía*/

devuelve 1; /* Devuelve 1*/

else

devuelve 0 /* En caso contrario, devuelve 0*/

}

STACK2 *initstack2(STACK2 *top ) /* Inicialización*/

{

top=NULL /* Establece el puntero superior de la pila en nulo*/

Volver al principio; /* Volver al principio de la pila Puntero*/

}

STACK2 *push2(STACK2 *top, char x) / *Función de pila de inicialización*/

{

STACK2 *p /* Tipo de puntero temporal STACK2 */

p=(STACK2 *)malloc(sizeof( STACK2)); /* Solicitar espacio de tamaño STACK2 */

if(p==NULL) /* si p está vacío*/

{

printf("la memoria está desbordada\n. !!!!") ; /* mostrar La memoria se ha desbordado*/

exit(0) /* Salir**/p>

}

p-gt; data=x; /* Guardar valor x en un nuevo espacio*/

p-gt; el puntero superior de la pila actual**/p>

top=p /* El nuevo puntero superior de la pila es el nodo recién insertado*/

return top /* Return top; el puntero superior de la pila*/

}

STACK2 *pop2 (STACK2 *top) /* pop */

{

STACK2 *q; /*definir variable temporal */

q=top; /* almacena el puntero de la pila superior actual*/

top=top-gt; el puntero superior de la pila*/

free(q); /*libera q*/

return top /* Devuelve el puntero superior de la pila*/

}

char topx2(STACK2 *top) /* Leer el elemento superior de la pila*/

{

if(top==NULL) /* Si la pila está vacía*/

{

printf("La pila es nula\ n"); /* Muestra el mensaje de que la pila está vacía*/

return ''; /* Devuelve el carácter nulo*/

}

return top-gt /* Devuelve el elemento superior del; pila*/

}

PILA2 *ptop2(PILA2 *

top, char *x) /* Obtener el elemento superior de la pila y eliminar el elemento superior de la pila*/

{

*x=topx2(top);/* Leer el elemento superior de la pila* /

top=pop2(top); /* Eliminar el elemento superior de la pila*/

return top /* Devuelve el puntero en la parte superior de la pila*/

}

int vacío2(STACK2 *top) /* Determinar si la pila está vacía*/

{

if( top==NULL) /* Si está vacío */

devuelve 1 /* devuelve 1 */

else

devolver 0; /* en caso contrario devolver 0 */

}

int text1(char *s)

{

setbkcolor(AZUL) ); /* Establece el color de fondo en azul*/

cleardevice(); /* Limpia la pantalla*/

setcolor(12); red*/

settextstyle(1, 0, 8); /* Fuente de tres trazos. Ampliar 8 veces*//p>

outtextxy(120, 120, s); /*Cadena de salida s*/

setusercharsize(2, 1, 4, 1); * Ampliar 2 veces horizontalmente y 4 veces verticalmente*//p>

setcolor(15); /*Establece el color del texto en *blanco*/

settextstyle(3, 0, 5); /*Trazos sans serif, ampliados 5 veces*/

outtextxy(220, 220, s); /*Cadena de salida s*/

getch( ); Cualquier carácter en el teclado*/

return; /*Valor de retorno*/

}.