Necesito ayuda con este programa quiero que me imprima las cartas que almacene

[Shaitan Nasser]

Hice el ciclo while pero no se como hago para que reparta mis cartas a mis 4 jugadores, y que cuando a alguien le salga una A este le de el poder que cogerle la carta que tiene arriba los otros 3 jugadores, pero este poder se decide si lo quiere usar en el instante o en otro momento, ayuda por favor.

#include <iostream>
#include <stack>
#include <stdlib.h>
#include <time.h>
#include <list>
#include <conio.h>

using namespace std;

class Carta{
   public:
      Carta* siguiente;
      Carta(){
         siguiente = NULL;
      }
      Carta(string n,int v){
         nombre=n;
         valor=v;
         siguiente = NULL;
      }
      string nombre;
      int valor;
};

class Pila{
   public:
      Carta* cabeza;
      void agregar(string nombre, int valor){
         Carta* carta= new Carta(nombre,valor);
         if(cabeza==NULL){
            cabeza=carta;
         }
         else{
            carta->siguiente=cabeza;
            cabeza=carta;
         }
         
      }
      Pila(){
         cabeza=NULL;   
      }
      
      Carta* pop(){
         Carta* aux = cabeza;
         
         cabeza = cabeza->siguiente;
         
         aux->siguiente = NULL;
         
         return aux;
      }
      
      Carta* peek(){
         return cabeza;
         
      }
      bool estaVacia(){
         if(cabeza==NULL)
         return true;
         else
         return false;
      }
      
      
};

class Jugador{
   public:
   Jugador(string nombre,int numjugador){
      this->nombre=nombre;
      this->numjugador=numjugador;
      siguiente=NULL;
      anterior=NULL;
      tienepoder=false;
   }
   Pila cartas;
   string nombre;
   int numjugador;
   Jugador* siguiente;
   Jugador* anterior;
   bool tienepoder;
};


class Lista{
   public:
      Jugador* Primero;
      Jugador* Ultimo;
      void agregar(string nombre, int numjugador){
         
         Jugador* jugador=new Jugador(nombre,numjugador);
         if(Primero==NULL){
            Primero=Ultimo=jugador;
         }
         else{
            Ultimo->siguiente=jugador;
            jugador->anterior=Ultimo;
            Ultimo=jugador;
            Ultimo->siguiente=Primero;
         }
         
      }
      
      Jugador* getPrimero(){
         return Primero;
      }
      
   Lista(){
      this->Primero = NULL;
      this->Ultimo = NULL;
   }
   
};

void pasarPila(Carta carta[], Pila* pila){
   for(int i=0; i<52; i++){
      
      if(carta.valor != 0)
         pila->agregar(carta.nombre, carta.valor);
   }
}


void barajar(Carta cartas[]){
   
   Carta aux;
   
   for(int x=0; x<51; x++){
        int i=rand() % 51 + 0;
        int j=rand() % 51 + 0;
       
        aux = cartas;
       
        cartas = cartas[j];
        cartas[j] = aux;
       
    }
}


int main()
{
   Lista jugadores;
   Carta carta[52];
   Pila pilaCartas;
   int pos =0;
      
   for(int i=0; i<4; i++){
      
      for(int j=0; j<13; j++){
         if(i == 0)
            carta[pos] = Carta("Espada",j+2);
            
         if(i == 1)
            carta[pos] = Carta("Corazon",j+2);
            
         if(i == 2)
            carta[pos] = Carta("Diamante",j+2);
            
         if(i == 3)
            carta[pos] = Carta("Trebol",j+2);
            
         pos++;
      }
   }
   
   pos = 0;
   
    //int carta[52]={1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13};
    //list< string> jugadores;
    //int suma[5]={0,0,0,0,0};
    string jugador;
    srand(time(NULL));
    cout <<"Ingrese el Primer Jugador: ";
    cin>>jugador;
    jugadores.agregar(jugador, 1);
    cout <<"Ingrese el Segundo Jugador: ";
    cin>>jugador;
    jugadores.agregar(jugador, 2);
    cout <<"Ingrese el Tercer Jugador: ";
    cin>>jugador;
    jugadores.agregar(jugador, 3);
    cout <<"Ingrese el Cuarto Jugador: ";
    cin>>jugador;
    jugadores.agregar(jugador, 4);
   
    //stack <int> cartas;
    //stack <int> entregadas;
    /*for(int i=0; i<51; i++){
        int ran=rand() % 51 + 0;
        cartas.push(carta[ran]);
    }*/
   
    barajar(carta);
    cout<<"Las cartas Fueron Barajadas"<<endl;
   
   
    //Jugadores toman carta para decidir el turno
   Jugador* aux = jugadores.getPrimero();
   
   do{   aux->cartas.agregar(carta[pos].nombre, carta[pos].valor);
      
      carta[pos].nombre = "";
      carta[pos].valor = 0;
      pos++;
      aux=aux->siguiente;
   }while(aux!= jugadores.getPrimero());
      /*aux->cartas.agregar(carta[pos].nombre, carta[pos].valor);
      
      carta[pos].nombre = "";
      carta[pos].valor = 0;
      cout<<"@";
      pos++;*/
      
   barajar(carta);
   
   pasarPila(carta, &pilaCartas);
   
    aux = jugadores.getPrimero();
    Jugador* primero;
    int valor = 0;
   
    do{   
      if(aux->cartas.peek()->valor > valor){
          valor = aux->cartas.peek()->valor;
          primero = aux;
      }
   
   }while(aux->siguiente != jugadores.getPrimero());
       
    while(!pilaCartas.estaVacia()){
       Jugador* aux2 = jugadores.getPrimero();
       while(aux2->siguiente!=jugadores.getPrimero());{
          
          aux2=aux2->siguiente;
      }
   }
   
   
   
    /*cout<<"Las cartas Fueron Barajadas"<<endl;
    list<string>::iterator iter(jugadores.begin());
    int cont=0;
    while(cartas.empty()==false){
        if(iter==jugadores.begin()){
            while(iter!=jugadores.end()&&cartas.empty()==false){
                entregadas.push(cartas.top());
                cout<<"Jugador "<<*iter<<" "<<entregadas.top()<<endl;
                if (cont!=4)
                    suma[cont]+=entregadas.top();
                cartas.pop();
                cont++;
                iter++;
                getch();
            }
        }
        if(iter==jugadores.end()){
            while(iter!=jugadores.begin()&&cartas.empty()==false){
                iter--;
                entregadas.push(cartas.top());
                cout<<"Jugador "<<*iter<<" "<<entregadas.top()<<endl;
                if (cont!=4)
                    suma[cont]=suma[cont]+entregadas.top();
                cartas.pop();
                cont--;
                getch();
            }
        }
    }
    list<string>::iterator iter2(jugadores.begin());
    int cont2=0;
    while(iter2!=jugadores.end()){
        cout <<"El Jugador "<<*iter2<<" Tiene "<<suma[cont2]<<" Cartas"<<endl;
        cont2++;
        iter2++;
    }*/
    return 0;
}

[Serapis]

Tienes que pensar como un humano, y luego traducirlo a código... porque programar es eso.

Se obvian las funciones que no son precisas para llegar al punto donde explicar el asunto de tu interés.

1º - Debes disponer de una baraja, supongamos que la baraja se compone de 4 palos (y como soy español y no inglés usamos de ejemplo la baraja española y no la francesa (la de póker)).

Código [Seleccionar] Expandir


array de bytes Baraja(0 a 39) //también podría ser bidimensional (0 a 3, 0 a 9)
entero siguienteCarta   // el índice de la carta que actualmente está arriba en la banca (lista para salir).

// Esta función genera la baraja. Cada carta aparece 1 solo 1 vez.
funcion RellenarBaraja
   entero j, k, i, n

   i = 0
   bucle para k de 0 a 3
       bucle para j de 0 a 9
           Baraja(n) = (i+j)  // basta un solo bucle desde 0 a 39, pero lo hago en 2 bucles
                                     // para que entiendas la equivalencia resuelta con un array bidimensional
                                      // Baraja(k,j) = (i+j)
       fin bucle
       i +=10
   fin bucle

   llamada a Barajar(2)
fin funcion

2º Tras ser generada la baraja (contener las cartas deseadas), debe ser barajada.

Código [Seleccionar] Expandir


// Esta función baraja las cartas, esto es las cambia de orden.
funcion Barajar(entero veces)
   entero k, j, i, n

   Si (veces<1) luego   // se debe barajaral menos una vez.
       veces = 1
   OSi (veces>9) luego  // tampoco queremos barajar 1000 veces, no es necesario...
       veces = 9
   Fin si

   bucle para j desde 0 a veces-1
       bucle para k desde 39 hasta 1 regresivamente
           //elegir al azar un índice entre 0 y el actual del ciclo
           i = aleatorio(entre 0 y k)
           // intercambiar los valores de los índices de ciclo y elegido al azar  
           n = baraja(i)                
           baraja(i) = baraja(k)
           baraja(k) = n
       fin bucle
   fin bucle

   siguienteCarta  = 0  // el índice la carta actual en la banca es la primera.
fin funcion



Ahora toca repartir las cartas entre los jugadores, pero antes de repartir, vemos la necesidad de tener un alojamiento para los datos de cada jugador, básicamente hará falta una estructura que contenga el array de 'cuales' cartas tiene cada jugador. un valor que indique cuantas le restan válidas en ese array.

Código [Seleccionar] Expandir


estructura Jugador
   string nombre //un nombre para el jugador, así cuando se pase el turno, se indica su nombre. Esto debe establecerse al iniicio del juego (una única vez)
   array de bytes Cartas(0 a 39) //dijimos que repartimos 5, si un jugador puede tener más cartas que las que se reparten,
                  // el tamaño del array debe aumentarse hasta tal posibilidad, si se ignora, debe ser el mismo tamaño de la baraja.
                  // Prevenimos tal situacion si ya albergamos esa posibilidad. La baraja también podría ser un jugador de nombre "La Banca", con esa misma cantidad de cartas en el array...
                 // Si el tamaño es el de la baraja, basta con crear los arrays al inicio del juego una única vez.
   entero cantidad  //número de cartas que tiene actualmente, esto evita redimensionar el array, porque apunta a la sigueinte (en realidad a la anterior).
   // otros datos que convenga que se mantenga para cada jugador.
fin estructura

Array de jugador jugadores(0 a 3)  //4 jugadores, ó (0 a 4), siendo la banca el jugador 0 y el resto los jugadores en lid.



3º Repartimos... debemos saber cuantos jugadores hay en la partida y cuantas cartas se reparten. Vamos a suponer que no se reparten todas sino, 5 al empezar... por simplicidad, no se comprueba si quedan suficientes cartas por repartir. En teoria si se llega al final, habría que tomar las que haya aún en la anca y barajarlas (solo las que quedan ahí), es fácil modificar la función de barajado para indicar cuantas barajar y tal...
Al parámetro desde se le pasa el valor de siguienteCarta , que se actualiza al retorno de la función.

Código [Seleccionar] Expandir


// Esta función es la correcta cuando cada reparto sucede que todos los jugadores se han descartado, si no es así, el procedimiento debe variar (se pone debajo una aproximación al caso).
entero = funcion RepartirBorrando(entero numJugadores, entero numCartas, entero desde)
   entero j, k, i, n

   // borra-sobrescribe valores previos.
   bucle para k desde 0 a numJugadores-1 // jugadores
       jugadores(k).tengoAses = 0 // se borran todos los ases que tuviere, si le quedan...
       //realojar espacio para jugadores(k).cartas(0 numcartas -1)
       // pero si el array es del tamaño de la baraja basta hacerlo solo al inicio del juego, no tras cada partida ni reparto de cartas.
       jugadores(k).cantidad = numCartas //esto no es estrictamente necesario, se establece a  
   fin bucle

   bucle para j desde 0 a numCartas-1  //cartas
       bucle para k desde 0 a numJugadores-1 // jugadores
             n= baraja(desde)
             jugadores(k).cartas(j) = n            
             desde +=1
       fin bucle
   fin bucle

   devolver desde // desde lleva la cuenta de cartas gastadas, en la banca.
fin funcion


Función de reparto cuando se puede tener diferente número de cartas, según momentos y jugador durante la partida. alcaso se supone un tamaño de array de cartas para cada jugador del mismo que la baraja, así se evita errores de desbordamiento y hace innnecesario controlar dicho factor...

Código [Seleccionar] Expandir


entero = funcion Repartir(entero numJugadores, entero numCartas, entero desde)
   entero j, k, i, n

   // OJO: nótese que aquí se ha intercambiado el orden de los bucles (facilidad para el código, el reparto sigue siendo aleatorio, pués las cartas están barajadas y nadie sabe donde ni cuales.
   bucle para k desde 0 a numJugadores-1 // jugadores
       i = jugadores(k).cantidad
       bucle para j desde 0 a numCartas-1  //cartas
             n= baraja(desde)
             jugadores(k).cartas(i + j) = n          
             desde +=1
       fin bucle
       jugadores(k).cantidad += numCartas // suma las que se reparten a las que se tiene actualmente
   fin bucle

   devolver desde // desde lleva la cuenta de cartas gastadas, en la banca.
fin funcion

4º Ahora llegamos al punto donde es el turno de un jugador y se comprueba si tiene un as y por tanto roba una carta (la siguiente o una alazar?) al resto de jugadores...
Recuerda: Se han obviado las funciones que no son precisas para llegar a este punto donde se explica el asunto de tu interés.

Código [Seleccionar] Expandir


entero funcion SiguienteTurno(entero turno) //, entero indiceCarta para elcaso de que sea el jugador quien decide qué carta se arroja.
   entero j, k , i, n

   k =  jugadores(turno).cantidad -1

   // tomar la siguiente carta:
   si se elige al azar
       i = Aleatorio(entre 0 y k)        
   oSi se toma la siguiente que sigue en secuencia
       i = k        
   oSi decidio el usuario
       i = indiceCarta
   fin si
    // valor de la carta seleccionada
   n = jugadores(turno).cartas( i )

   // Esto solo si elegir la carta supone descartarse de ella.
   Si decidio el usuario // y la carta se debe descartar, esta se pasa atrás... las válidas son las 'cantidad-1' primeras en el array de ese jugador
       jugadores(turno).cartas( i ) = jugadores(turno).cartas( k )  
       jugadores(turno).cartas( k ) = n
   fin si
   jugadores(turno).cantidad -=1  

   
   // evaluar si es un as y que as, es
   si ((n modulo 10) = 0 ) luego  // ¿la carta 'n' es un AS?
       n = (n / 10)  // ¿qué AS, es?  0, 10, 20, 30 // por ejemplo oros, copas, espadas y bastos, respectivamente, tu decides...
       // Si (n = AsPalo) luego ... caso de que deba ser un as especifico y no cualquiera de ellos
           // retirar una carta a cada uno de los jugadores restantes (sin saber que se hace con ellas, se supone que solo se le retira 1 y nada más)
           bucle para j desde 0 a numJugadores-1
               Si (j <> turno) luego //distinto de   //no se puede quitar carta a sí mismo.
                    si  (jugadores(j).cantidad >0) luego
                         jugadores(j).cantidad -=1   //le quitamos la última, si es al azar,
                                   // proceder como más arriba, elegir al azar entre las que reste
                                   // intercambiarla por la última 'válida' y restar una a la cantidad.
                    fin si
               fin si
           fin bucle
       // fin si
   fin si


   devolver ((turno + 1) modulo numJugadores) //0-1-2-3-0-1-2-3-0-1-2--->3--->0
fin funcion

Para entender correctamente el pseudocódigo considera lo siguiente:
- La baraja tiene 40 cartas, una copia por cada carta, que han sido barajadas x veces.
- El array 'baraja' representa la banca.
- La banca cuando reparte cartas, aumenta el índice en tantas cartas como reparte, las de más abajo están en uso, las que restan hasta 39, siguenen la banca.
- Las cartas del jugadores, sigue el orden al revés, dado que no hay forma de saber cuantas cartas tendrá en algún momento, cuando se le retira una, se intercambia de orden con la del final de las que le quedan válidas, y su cuenta se reduce en uno.
- Los valores de las cartas  en la baraja van del 0 al 39. 0-9 las 10 cartas de un palo, 10-19, las de otro, 20-29 otro y 30-39 el último palo. Usar dos barajas es aumentar el array al doble y proceder con la misma idea, solo que se consideran cartas iguales (x y n) si:  

Código [Seleccionar] Expandir

buleano = funcion Iguales(entero x, entero n)
  devolver ((x modulo 40) = (n modulo 40))
fin funcion
- Observa que la función SiguienteTurno, puede llevar más parámetros, por ejemplo para que el jugadordecida si quiere jugar su AS (como tu reclamas), pasando a la función el índice de la misma....
- Se supone que los turnos, son una vez cada uno. Si no es así, se deb modificar la devolución en la función 'SiguienteTurno'. Para el caso, (por simplicidad y claridad), tampoco se ha previsto el caso de que un jugador esté descartado y por tanto deba ceder el turno a otro.
- La función 'SiguienteTurno', simplemente está evaluando que carta juega el jugador que tiene el turno, y verifica si es un as en cuyo casoretira una carta a cada jugador (pero no se las asigna así mismo, es decir no se apodera de ellas), y da por hecho que jugar una carta supone perderla, descartando por tanto al jugador de esa carta...

...es realmente sencillo, espero que lo entiendas correctamente...