Juego de cartas

[demurral96]

Buenas tardes espero me puedan ayudar,

Tengo que hacer un programa para poder jugar un juego de cartas sencillo donde se reparten 5 cartas a cada jugador y el primero en tener 3 pares (que haga el ultimo par con la carta que roba) gane.

Ya tengo una idea de como hacer la mayoría del código para que el programa funcione, solo que mi problema es que no se muy bien como barajar las cartas tengo una idea en mi código pero esta mal ya que tengo mal el random si alguien me podría decir como cambiarlo o que esta mal para poder barajar y meter las cartas a la pila se lo agradecería muchísimo ya que llevo horas y nada se me ocurre.

Soy estudiante de ingeniería desoftware y apenas es mi segundo cuatrimestre por lo tanto todavía no se mucho ni domino esto de la programación.

Gracias por su tiempo.



#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <alloc.h>
#include <conio.h>

#define tarjetas 5

/*elegimos usar 4 tipos diferetes de palos a la baraja normal ya que lo que es el corazon,
la espada, el trebol y el diamante no se pueden mostrar cuando se corre el programa.

printf("%i%c", mazo[10]);*/


struct c{
int x;
char signo;
};

void push(struct c *cartas, int *tope, struct c mazo);
struct c pop(struct c *cartas, int *tope);

int main (void)
{
char jugador1[tarjetas]={0};
char jugador2[tarjetas]={0};
char jugador3[tarjetas]={0};
char jugador4[tarjetas]={0};
struct c *cartas;
int a, b, i, tope=-1;


struct c mazo[52]={
{1,155},
{2,155},
{3,155},
{4,155},
{5,155},
{6,155},
{7,155},
{8,155},
{9,155},
{10,155},
{11,155},
{12,155},
{13,155},
{1,156},
{2,156},
{3,156},
{4,156},
{5,156},
{6,156},
{7,156},
{8,156},
{9,156},
{10,156},
{11,156},
{12,156},
{13,156},
{1,157},
{2,157},
{3,157},
{4,157},
{5,157},
{6,157},
{7,157},
{8,157},
{9,157},
{10,157},
{11,157},
{12,157},
{13,157},
{1,159},
{2,159},
{3,159},
{4,159},
{5,159},
{6,159},
{7,159},
{8,159},
{9,159},
{10,159},
{11,159},
{12,159},
{13,159}
};

cartas=malloc(sizeof(struct c)*52);

clrscr();
randomize();

for(i=0;i<52;i++)
{
b=mazo[random(52)];
if(mazo[i].x!=0)
push(cartas, &tope, b);

b=0;
}
printf("Cuantos jugadores seran: ");
scanf("%i", &a);

switch(a)
{

case 1:

gotoxy(20,2);
printf("Jugador 1");

break;

}



return 0;
}

void push(struct c *cartas, int *tope, struct c mazo)
{
(*tope)++;

if(*tope<52)
cartas[*tope]=mazo;

return;
}

struct c pop(struct c *cartas, int *tope)
{
struct c x;

x=cartas[*tope];
(*tope)--;

if(*tope==-1)
printf("Empate");

return x;
}

[eferion]

Iniciado por demurral96

Soy estudiante de ingeniería desoftware y apenas es mi segundo cuatrimestre por lo tanto todavía no se mucho ni domino esto de la programación.

Conozco chavales de 15 años que se hacen sus progamitas en Java... que estés en un curso X no implica que tus conocimientos tengan que ser necesariamente escasos.

Te lo comento porque intentar excusarte con este tipo de argumentos no te va a aportar nada.

Bueno, vamos a por tu código. Voy a ponerme un poco en modo profe así que espero que mis comentarios los veas desde una perspectiva crítica no despectiva.

La primera regla de todo programa es que este ha de ser legible. Esto implica que las variables y los objetos usados en el programa han de tener nombres lo más descriptivos posibles.

Código C:

struct c{
  int x;
  char signo;
};
 

Estas 4 líneas de código de ejemplo violan completamente el párrafo anterior:

• ¿Por que c? ¿Tanto cuesta poner carta?
• ¿Qué demonios es x? ¿No será por algún casual el número de la carta?
• ¿Y signo? No sabía que las cartas tenían signo. Espera... ¿No será que signo representa el palo?

Por otro lado, tenemos que una baraja tiene 4 palos diferentes: Oros, Copas, Espadas y Bastos. Aquí podría perfectamente usarse un enum y no tener que repetir una ristra tremendamente legible de 155, 156, 157 y 159. Si luego quieres cambiar el caracter asociado te toca hacer 13 sustituciones para que el programa siga funcionando:

Código C:

enum Palos
{
  PaloNoValido, // Para posibles errores
  Oros,    // O Diamantes
  Copas,   // O Trébol
  Espadas, // O Picas
  Bastos   // O Corazones
};
typedef enum Palos Palos;
 
struct Carta{
  int valor;
  Palos palo;
};
typedef struct Carta Carta;
 
char GetPalo(Palos palo)
{
  char toReturn = 0;
 
  switch( palo )
  {
    case Oros:
      toReturn = 155;
      break;
 
    case Copas:
      toReturn = 156;
      break;
 
    case Espadas:
      toReturn = 157;
      break;
 
    case Bastos:
      toReturn = 158;
      break;
  }
 
  return toReturn;
}
 

Aunque pueda parecer una chorrada hay convenciones que conviene adquirir. En el caso de C, las macros, por motivos históricos, se han escrito siempre en mayúsculas para diferenciarlas de las variables y funciones. En tu caso tarjetas debería estar en mayúsculas:

Código C:

#define TARJETAS 5
 

Por otro lado se asume que cada jugador va a manejar cartas. Esta parte del programa la puedes enfocar de dos formas diferentes:

• Solo hay una lista de cartas y a cada jugador le facilitas un puntero (puntero o índice a la posición) a las cartas que posea.
• Cada jugador recibe una copia de las cartas.

En tu caso has optador por una tercera vía que es que cada jugador tiene únicamente ¿un char? de cartas. ¿Qué pretendes almacenar en el char? Si es el índice al mazo entonces char no es la opción recomendable por semántica. Si pretendes almacenar una copia de la carta char se te queda corto.

Código C:

// Almacenar punteros
Carta* jugador1[TARJETAS] = {0};
 
// Almacenar índices
int jugador1[TARJETAS] = {-1};
 
// Almacenar copia (ojo)
Carta jugador1[TARJETAS] = {};
 

Almacenar punteros o índices es sencillo porque para descartar una carta basta con asignar a ese elemento valor no válido (puntero=0 o índice=-1) para saber qué elemento hay que sustituir. En el caso de las copias necesitarías crear una carta especial para reconocerla y poder descartar correctamente.

Yo no soy demasiado amigo de tener los valores escritos a pelo en medio del código... y si es una baraja entera menos aun. Para generar el mazo de cartas yo te propondría usar símplemente un array de enteros de 0 a 52. Conocer el valor de la carta o el palo dado su índice es bastante sencillo:

Código C:

#define NUM_CARTAS 52
 
int GetValorCarta(int indice)
{
  return (indice%13) + 1;
}
 
Palos GetPaloCarta(int indice)
{
  Palos toReturn = PaloNoValido;
 
  switch( indice/13 )
  {
    case 0:
      toReturn = Oros;
      break;
 
    case 1:
      toReturn = Copas;
      break;
 
    case 2:
      toReturn = Espadas;
      break;
 
    case 3:
      toReturn = Bastos;
      break;
  }
 
  return toReturn;
}
 
int main()
{
  int mazo[NUM_CARTAS];
  for(int i=0; i<NUM_CARTAS; i++)
    mazo[i] = i;
}
 

Para mezclar las cartas lo más sencillo puede ser programar una serie de intercambios. Puedes, por ejemplo, recorrer la baraja 3 veces y en cada pasada vas intercambiando la carta actual con otra elegida al azar:

Código C:

#include <time.h>
#include <stdlib.h>
 
// Macro para intercambiar valores
#define SWAP(a,b) { int c=a; a=b; b=c; }
 
void barajar(int mazo[NUM_CARTAS])
{
  srand(time(NULL));
 
  for(int i=0; i<3; i++ ) // Recorremos 3 veces el mazo
  {
    for(int j=0; j<NUM_CARTAS; j++ ) // Iteramos cada carta
    {
      // Elegimos otra carta al azar
      int otra = rand()%NUM_CARTAS; 
 
      // intercambiamos las cartas
      SWAP(mazo[j],mazo[otra]);
    }
  }
}
 

Juntando todo lo dicho anteriormente tendríamos algo tal que:

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
#define TARJETAS 5
#define NUM_CARTAS 52
 
// Macro para intercambiar valores
#define SWAP(a,b) { int c=a; a=b; b=c; }
 
enum Palos
{
  PaloNoValido, // Para posibles errores
  Oros,    // O Diamantes
  Copas,   // O Trébol
  Espadas, // O Picas
  Bastos   // O Corazones
};
 
// Para convertir fácilmente cada palo a cadena
const char* PalosToString[] = { "", "Oros", "Copas", "Espadas", "Bastos" };
 
typedef enum Palos Palos;
 
int GetValorCarta(int indice)
{
  return (indice%13) + 1;
}
 
Palos GetPaloCarta(int indice)
{
  Palos toReturn = PaloNoValido;
 
  switch( indice/13 )
  {
    case 0:
      toReturn = Oros;
      break;
 
    case 1:
      toReturn = Copas;
      break;
 
    case 2:
      toReturn = Espadas;
      break;
 
    case 3:
      toReturn = Bastos;
      break;
  }
 
  return toReturn;
}
 
void barajar(int mazo[NUM_CARTAS])
{
  srand(time(NULL));
 
  for(int i=0; i<3; i++ ) // Recorremos 3 veces el mazo
  {
    for(int j=0; j<NUM_CARTAS; j++ ) // Iteramos cada carta
    {
      // Elegimos otra carta al azar
      int otra = rand()%NUM_CARTAS;
 
      // intercambiamos las cartas
      SWAP(mazo[j],mazo[otra]);
    }
  }
}
 
int main()
{
  int mazo[NUM_CARTAS];
  for(int i=0; i<NUM_CARTAS; i++)
    mazo[i] = i;
 
  barajar(mazo);
 
  for( int i=0;i<NUM_CARTAS;i++)
  {
    int valor = GetValorCarta(mazo[i]);
    Palos palo = GetPaloCarta(mazo[i]);
    printf("%d de %s\n", valor, PalosToString[palo]);
  }
 
  int jugador1[TARJETAS] = {-1};
  int jugador2[TARJETAS] = {-1};
  int jugador3[TARJETAS] = {-1};
  int jugador4[TARJETAS] = {-1};
 
}
 

Creo que este es un buen punto para retomar tu ejercicio.

Un saludo.

[aguml]

Magistral la explicación pero me gustaría añadir algo más. Creo que seria en este caso muy buena idea usar una lista simple para la baraja completa y luego barajas los punteros y conforme vas repartiendo cartas las vas quitando de la lista de la baraja. Por otro lado cada jugador usaría su propia lista simple para las cartas que manejen. Cuando la lista de la baraja este vacia ya no hay cartas que repartir.

[Malenko]

Si no usa una lista es, en mi opinión, porque se trata de un ejercicio sobre estructuras de datos donde parece que ha de practicar con el uso/implementación de las pilas.

No se trata de buscar la solución óptima, pero si la más limpia que cumplas con los requerimientos que le hayan puesto en clase. Por eso esas "limitaciones" en cuanto a que usar y que no usar.