Mensajes

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;
}

Se requiere que el estudiante simule un juego de
cartas en C++, aplicando los conocimientos adquiridos en la clase.

El programa debe simular un juego de
cuatro jugadores, al cual llamaremos SACAITO, donde cada jugador juega en contra de los demás sacando una carta por turno de una pila de cartas hasta agotar la pila; al final quien sume más puntos gana el juego. Aplican las siguientes reglas:

•Al inicio del juego cada jugador toma una carta, aquel que tome la carta con mayor puntuación es quien sale en el primer turno.Luego de esto se debe barajar la pila de carta.

•El turno va de jugador en jugador, en un inicio hacia la derecha y luego de llegar al cuarto jugador, ese jugador (el cuarto) se convierte en el siguiente jugador y los turnos rotan hacia la izquierda. Esto quiere decir que el cuarto jugador de una ronda se convierte en el primero de la siguiente.

•En cada turno el jugador toma la siguiente carta de la pila y la coloca en su pila de cartas.

•Cuando la carta que toque sea "A" el jugador adquiere el poder de robar la última carta de las
pilas de los otros jugadores. El jugador puede guardar el poder para después o aplicarlo de inmediato.

•Al finalizar la pila de cartas, el jugador con mayor puntuación gana.

•Los valores de las cartas son su respectivo valor numérico o el equivalente para las letras: "J" = 11; "Q" = 12; "K"=13; la "A" no suma valor porque representa un poder de robo.

•Las cartas deben ser igual que en la realidad, donde hay cuatro cartas para cada valor y sólo hay
valores desde el 2-10; "J", "Q", "K", "A".

EL PR O G R AM A   DE BE  CUMPLIR LOS SIGUIENTE
S   R EQ UER IM IEN T O S:

•Cada jugador debe ser un nodode una lista circulardoblemente enlazada.

•Cada jugador debe tener una pila de cartas que va acumulando.

•El programa debe, en todo momento, mostrar el total de puntos de cada jugador.

•Al finalizar la partida debe imprimirlos puntos totales de cada
jugador y decir cuál es el
ganador.

•Al finalizar cada mano, el programa debe ordenarlos jugadores por orden descendente utilizando un algoritmo de ordenación básico.

•Cada carta debe ser un objeto cuyas propiedades, al menos, deberían ser: Nombre, Valor.

•El programa debe informar, en todo momento, lo que está sucediendo: jugador actual, carta
tomada de la pila, si el jugador tiene un poder disponible preguntar si lo quiere usar cada vez que le toque el turno, si usó el poder informar las cartas robadas, etc.