Juego de caras

[Italico76]

Deberias decirnos si debe usar C o puedes usar C++ ya que con el segundo puedes crear clases.

Lo mas importante como te dice es pensar bien las estructuras de datos, asi en ANSI C:

Código C:

struct Baraja
{
    int numero;
    char palo;  // c=corazones, d=diamantes, t=treboles, e=espadas
}
 

aunque en C (no-Ansi) podrias usar enum tambien y... finalmente si lo piensas... es mejor que Baraja sea tambien una clase!

Si lo piensas... no salen cartas de cualquier parte del mazo!!!! no es un array sino una pila o cola segun sea la forma de repartir del crupier: saque las cartas de un extremo del mazo o del opuesto luego de mezclar. Todo esta en la estructura de datos que elijas ... incluso el considerar a un Comodin como un palo mas te puede beneficiar en que te simplifica la logica al momento de formar "pares" por ejemplo

Código C:

#include <iostream>
#include <stdio.h>
#include <queue>
#include <vector>
#include <algorithm>
#include <time.h>
//#include <stdexcept>
 
using namespace std;
 
enum Palos {Trebol,Diamante,Corazon,Espada,Comodin};
 
/*
    Poker
    @author Pablo Bozzolo (2014)
 */
class Baraja
{   
 
public:
 
    // quizas deberian ser atributos privados ;)    
    int numero;
    enum Palos palo; 
 
    void mostrar()
    {
        string tipo;        
        switch (palo) 
        { 
                case(Trebol):
                    cout << numero << " de Trebol" << endl;
                    break;  
                case(Diamante):
                    cout << numero << " de Diamante" << endl;
                    break;      
                case(Corazon):
                    cout << numero << " de Corazon" << endl;
                    break;      
                case(Espada):
                    cout << numero << " de Espada" << endl;
                    break;          
                case(Comodin):
                    cout << "Comodin" << endl;
                    break;          
        }
    }
};
 
class Mazo
{
    //Baraja cartas[];
    std::queue<Baraja> cartas;
 
public:  
 
    // crea mazo
    Mazo()
    {
        Baraja bar; 
        
        for (int i=1;i<=13;i++)
        {
            bar.numero=i;
            for (int j=0;j<Comodin;j++)
            {
                bar.palo= (Palos) j;
                cartas.push(bar);
            }               
        }
 
        // completamos el mazo :)
        bar.palo = Comodin;
        bar.numero = 0;
 
        cartas.push(bar);
        cartas.push(bar);
    };
 
    // si bien el mazo se mezcla por accion del crupier, dejemos eso de lado :)
    void mezclar()
    {
 
        Baraja carta;
        vector<Baraja> nuevo_mazo (54);         
        int up_down;                
        
        // copio el mazo
        for (int i=0;i<54;i++)
        {
            carta = cartas.front();
            cartas.pop();
            nuevo_mazo.at(i) = carta;           
        }   
 
        random_shuffle (nuevo_mazo.begin(), nuevo_mazo.end());
        
        // lo copio al mazo original
        for (int i=0;i<54;i++)
        {
            carta = nuevo_mazo.at(i);           
            cartas.push(carta);
        }           
    };
 
    // cuando una baraja regresa al mazo
    void aceptar(Baraja bar)
    {
 
    };
 
    // cuando un jugar coje del mazo, éste lo cede
    Baraja ceder()
    {
        Baraja bar;
        //...
        return bar;
    };
 
    // verifica que el mazo este completo y que no haya nada extraño como 5 comodines :P
    bool isOk(bool show_errors=true)
    {
        Baraja carta;
        int comodines;
        int espadas;
        int treboles;
        int corazones;
        int diamantes;
        int total;
        bool ok;
 
 
        comodines =0;
        espadas   =0;
        treboles  =0;
        corazones =0;
        diamantes =0;
        for (int i=0;i<54;i++)
        {
            carta = cartas.front();
            cartas.pop();
            switch (carta.palo) 
            { 
                case(Trebol):
                    treboles++;
                    break;  
                case(Diamante):
                    diamantes++;
                    break;      
                case(Corazon):
                    corazones++;
                    break;      
                case(Espada):
                    espadas++;
                    break;          
                case(Comodin):
                    comodines++;                        
            }           
            cartas.push(carta); 
        }
 
        total = comodines+espadas+treboles+diamantes+corazones;
        ok = (comodines==2 && espadas==13 && treboles==13 && diamantes==13 && corazones==13 && (total == 54));
        
        if (!ok)
        {   
            if (show_errors)
                printf("ERROR: hay %d comodines, %d espadas, %d treboles, %d diamantes y %d corazones sumado un total de %d\n", comodines,espadas,treboles,diamantes,corazones,total);          
            
            return ok;
 
        }
        //else cout << "Mazo OK! ;)" << endl;   
 
    }
 
 
    // a fines de debug.. crearemos un metodo para mostrar el mazo  
    void mostrar()
    {
        Baraja carta;
 
        for (int i=1;i<=54;i++)
        {
            carta = cartas.front();
            cartas.pop();
            carta.mostrar();
            cartas.push(carta);
        }
    }
 
};  
 
 
class Jugador
{
 
public:
 
    Jugador(string nombre)
    {       
    };
 
    void jugar()
    {}
 
};
 
 
class Crupier
{
    Mazo* mazo;
    vector<Jugador*> players;   
 
public:
 
    Crupier(){};
    
    void aceptar(Mazo* m)
    {
        mazo = m;
    }
    
    void registrar(Jugador* player)
    {
        players.push_back(player);
    };  
 
    // reparte a cada jugar registrado
    void repartir()
    {
        // ..
    }
 
    void mezclar()
    {
        mazo->isOk();   
        mazo->mezclar();
        mazo->mostrar();    
        mazo->isOk();
    }
};
 
 
int main ()
{
    // Inicializo semilla para mezclado de cartas
    srand (time(NULL));     
 
    // Creo el mazo
    Mazo mazo;
 
    // Creo dos jugadores y al crupier  
    Jugador player1("Pablo");   
    Jugador player2("Carlos");
    Crupier crupier;
 
    // Paso el mazo al crupier, se mezcla, baraja (reparte)...
    crupier.aceptar(&mazo);
    crupier.registrar(&player1);
    crupier.registrar(&player2);
    crupier.mezclar();
    
    // alternadamente deberia repartir a cada jugar registrado para la partida
    crupier.repartir();
    
    // ...
 
    
}
 

Ese codigo no hace MUCHO cierto (hasta ahora solo mezcla las cartas) .. PERO ... vas definiendo a grandes razgos lo que hay en tu sistema....