Juego de Poker

Despues de un tiempo pensandolo, decidi subir el juego de poker que estoy haciendo en el tiempo que me sobra entre mis lecturas de C++ (Que ahora ocupan gran parte de mi tiempo porque sali de vacaciones y estoy aprovechando ^^) y las de GNU/Linux (jj), el codigo fuente es totalmente libre, asi que lo pueden utilizar, modificar, y hacerle lo que quieran. Esta version esta mucho mas documentada que la ultima que publique (Todavia me dan escalofrios cuando veo la entrada) ademas de que en la primera parte pongo muchos, pero muchos comentarios con recomendaciones. Tengan en cuenta que no solo gasto tiempo haciendo el juego (Aunque me encanta!), si no que tambien tengo que transformarlo en codigo HTML con colores ^^ que toma bastante mas tiempo que el desarrollo mismo (Uso emacs, nada de Kompozer u otros), asi que las actualizaciones al codigo tardan tiempo. Sin mas que decir, aqui esta el codigo:

// Fig. 5.24: fig05_24.cpp
// Programa para barajar y repartir cartas.
/* Algunas consideraciones que tienes que tomar son:
0. Este codigo es libre! Totalmente libre, lo puedes usar donde te plasca, lo puedes
modificar como te plasca, puedes hacerle todo lo que te plasca!

1.Los arreglos wstats (estadisticas del jugador) y pstats (estadisticas pc) funcionan asi:

Al principio son inicializados en 0, cuando se hace el primer analisis,
sus valores cambian de la siguiente forma:

    Xstats[0] = mayor numero de repeticiones
    Xstats[1] = Numero con mayor numero de repeticiones

Despues etan Xstats[2] y Xstats[3] que son lo mismo pero con los palos. Ahora,
esta parte (La de los palos) hay que mejorarla un poco, en la funcion comprueba
hay un comentario que dice donde hay que mejorarla.

2. Ya sabes como funcionan estos dos, asi que cuando quieras hacer un analisis
entre dos manos sabes que Xstats[0] son las repeticiones de la carta en Xstats[1]

3. paux y waux son arreglos con cartas de repuesto para el jugador (w) y la pc (p)

4. wwaux y ppaux contienen los palos de las cartas de repuesto

5. wcara y pcara van desde el valor 1 al 13, por lo que si quieres hacer algo como:
         cout << cara[wcara[contador]];
tienes que hacer un
       cout < pstats[5] )
      return 0;
      if ( wstats[5] == pstats[5] && wstats[5] != 0 ) {
         if ( wstats[6] > pstats[6] )
         return 0;
         if ( wstats[6] < pstats[6] )
         return 1;
         if ( wstats[6] == pstats[6])
         return 2;
         }
Para que compruebe las escaleras.

9. Las apuestas son algo muy dificil, para implementarlas necesitas de dos variables
wdinero (para el jugador) y pdinero (para la pc), ademas de que tienes que comprobarlas,
añadir instrucciones para apostar, etc. Recomiendo solucionar problemas de arriba antes
de ir con este.

10. Si haces algo, no te olvides de comentarlo, no vaya a ser que despues se te olvide para
que lo hiciste   

11. Para evaluar un full house es demasiado dificil/o no quiero pensar en este momento
sobre eso ^^,

12. Estas recomendaciones las dejo por si quieren modificar/desarrollar el juego por su cuenta, (Aunque tambien estan ahi porque yo no recuerdo a veces estas cosas). Las actualizaciones a este codigo toman tiempo, mas en la transformacion a HTML que en el desarrollo (:)), asi que hay que ser pacientes si les llega a (Por alguna razon) gustar.
           */
#include <iostream>
using std::cin;
using std::cout;
using std::left;
using std::right;
using std::endl;
#include <iomanip>

using std::setw;
#include <cstring>
#include <cstdlib>
#include <ctime>

// prototipos
void barajar( int [][ 13 ] ); //Baraja el arreglo
void repartir( const int [][ 13 ], int *, int *); //Reparte cartas
void comprueba( const int *, const int *, int *); //Devuelve las estadisticas de la mano
int ganadorw(const int * , const int *); //Define al ganador basado en las estadisticas
void despliega( const int *, const int *, const char **, const char **); //Despliega la mano
void cambiar( int *, int *, const int *, const int *, const int ); //Cambia cartas de la pc
int main()
{
   int ganador=0; //Quien sera el ganador?
   int contador=0; //Contador
   int cambiador;
    //Contiene todas las respuestas
   char yes=97;
   // inicializa el arreglo palo
   const char *palo[ 4 ] =
      { "Corazones", "Diamantes", "Treboles", "Espadas" };
    const char *posibles[ 5 ] = { "non" , "par", "trio" , "poker" , "trampa?" };
   // inicializa el arreglo cara
   const char *cara[ 13 ] =
      { "As", "Dos", "Tres", "Cuatro",
        "Cinco", "Seis", "Siete", "Ocho",
        "Nueve", "Diez", "Joto", "Quina", "Rey" };
   // inicializa arreglo baraja
   int baraja[ 4][ 13 ] = { 0 };
   //Declaraciones del jugador:
   int wcara[5]={0};
   int wpalo[5]={0};
   int wstats[4]={0};
   //Declaraciones de la pc:
   int ppalo[5]={0};
   int pcara[5]={0};
   int pstats[4]={0};
   srand( time( 0 ) );        // semilla del generador de números aleatorios
   int waux[5]={0}; //Cartas auxiliares del jugador
   int paux[5]={0}; //Cartas auxiliares de la pc
   int wwaux[5]={0}; //Palo de cartas auxiliares (de cambio) para el jugador
   int ppaux[5]={0}; //Palo de cartas auxiliares (de cambio) para la pc
   barajar( baraja ); //Baraja

   //Reparte
   repartir( baraja,wpalo, wcara  );
   repartir( baraja,ppalo, pcara );
   repartir( baraja, wwaux, waux );
   repartir( baraja, ppaux, paux ); 
   //Comentar la siguiente linea a menos de que estes modificando el programa:
   //despliega( pcara , ppalo, cara, palo );
   //Cambio de cartas
   cout << "Sus cartas son: ";
   despliega( wcara, wpalo, cara , palo );
   cout << "Desea cambiar sus cartas:(y/n/a) ";
   cin >> yes;
   switch( yes ) {
           case 'y':
           case 'Y':
                contador=0;
                cout << "Que cartas desea cambiar:(9=fin) ";
                while( contador  5 ) {
                       cin >> cambiador;
                       if ( cambiador == 9 )
                       break;
                       contador += 1;
                       if ( cambiador > 5 || cambiador < 1 ) {
                            cout << "\nNumero erroneo\nRango entre 1-5";
                            continue;
                            }
                       wcara[cambiador-1]=waux[cambiador-1];
                       wpalo[cambiador-1]=wwaux[cambiador-1];
                       }
                cout << "\nCambios finalizados, su nueva mano es: ";
                cout << endl;
                despliega( wcara, wpalo, cara , palo );
                break;
           case 'N':
           case 'n':
                cout << "\nNo se cambiaran sus cartas\n";
                break;
           case 'A':
           case 'a':
                cout << "\nCambiando cartas automaticamente...\n";
                cambiar( wcara , wpalo , waux, wwaux, wstats[1]);
                cout <<  "Cartas cambiadas automaticamente!\nSus nuevas cartas son:";
                despliega( wcara, wpalo, cara, palo);
           default:
                cout <<  "\nSeleccion invalida, seleccionando no...";
                break;
                }
   //Analisis
   comprueba( wpalo, wcara, wstats );
   comprueba( ppalo, pcara, pstats ); 

   //Cambio pc
   cambiar( pcara, ppalo, paux, ppaux, pstats[1] );

   //Analiza de nuevo a la pc, porque en la funcion cambiar se cambian cartas
   comprueba( ppalo, pcara, pstats );
   cout << "La pc tiene: ";
   despliega( pcara , ppalo, cara, palo );
   cout << endl << endl;
   ganador=ganadorw( wstats , pstats );
   switch( ganador ) {
           case 0:
                cout << "\nEl jugador gana! Con un " << posibles[wstats[0]-1]
                     << " de " << cara[wstats[1]-1];
                break;
           case 1:
                cout << "\nLa pc gana! Con un " << posibles[pstats[0]-1]
                     << " de " << cara[pstats[1]-1];
                break;
           case 2:
                cout << "\nEmpate?";
                break;
           default:
                cout << "\nEl programa no deberia llegar aqui..^^";
                break;
                }

   cout << endl;
   system("pause");
   return 0;  // indica terminación exitosa

} // fin de main

// baraja las cartas
void barajar( int wBaraja[][ 13 ] )
{
   int *puntero = &wBaraja[0][0];
   //Le asgina posiciones a todos los valores del arreglo mediante *puntero
   //De esta forma el arreglo debe quedar como arreglo[0]=0 [1]=1 [2]=2 y asi..
   for ( int contador = 0; contador < 52; contador++ )
   *( puntero + contador ) = contador + 1;
   int temp=0; //Para sostener un valor temporal
   int cand=0; //Para sostener un valor aleatorio
   //Recorre el arreglo intercambiando el elemento señalado con uno aleatorio
   for ( int contador = 0; contador < 52; contador++ ) {
       cand=1+rand()%51 ;
       temp=puntero[contador];
       puntero[contador] = puntero[cand];
       puntero[cand] = temp;
       }
} // fin de la función barajar

// reparte las cartas de la baraja
void repartir( const int wBaraja[][ 13 ], int *palo , int *cara )
{
   const static int cartas[13]={1,2,3,4,5,6,7,8,9,10,11,12,13};
   const static int qpalo[4]={1,2,3,4};
   static int carta=0;
   int cp=carta;
   const int *puntero=&wBaraja[0][0];
   // para cada una de las 52 cartas
   for (int contador = 0 ; carta < cp + 5; carta++, contador++ )
   for ( int carla = 0; carla < 52; carla++ )
       if (*(puntero + carla) == carta + 1 ) {
          /*Asignaciones justo aqui:: */
          *( palo + contador) = qpalo[carla % 4];
          *( cara + contador ) = cartas[carla % 13];
          }
} // fin de la función repartir

//Comprueba el numero de repeticiones de carta que se encuentra en el arreglo
void comprueba( const int *palo, const int *cara, int *stats ) {
     int mayor=0; //Para tener la mayor repeticion
     int repeticion=0; //Para controlar las repeticiones
     int pmayor=0; //Para contener la mayor repeticion (Respecto al palo)
     int prepeticion=0; //Para controlar repeteticiones
     int carta=0; //Para contener la mayor carta
     int ppalo=0; //Para contener el palo que mas se repite
     //Ciclo de analisis
     for ( int contador = 0; contador < 5; contador++ ) {
         for ( int contador2 = 0; contador2 < 5; contador2++ ) {
             //Analiza cada carta del arreglo con todas las demas buscando coincidencias
             if ( cara[contador] == cara[contador2] ) {
                  repeticion++;
                  if ( palo[contador] == palo[contador2] )
                  prepeticion++;
                  }
                  }
                  //Si el numero de repeticiones de la carta analizada es mayor
                  //Que el mayor numero de repeticiones registrado_
         if ( repeticion >= mayor && cara[contador] >= carta) {
              //Se asigna la repeticion de la carta a mayor
              mayor = repeticion;
              //Se asigna la carta que se repitio a la variable carta
              carta = cara[contador];
              //Se asigna la repeticion de palo a pmayor !Esto se deberia mejorar!
              pmayor=prepeticion;
              //Se asigna el palo a ppalo !Esto se deberia mejorar!
              ppalo = palo[contador ];
              }
         repeticion=0;
         prepeticion=0;
         }
   stats[0]=mayor; //Devuelve el numero de repeticiones
   stats[1]=carta; //Devuelve la carta mas grande
   stats[2]=pmayor; //Devuele el numero de veces que el palo se repitio
   stats[3]=ppalo; //Devuelve el palo que mas se repitio
}
//Funciones para definir al ganador
int ganadorw( const int *wstats , const int *pstats ) {
     if ( wstats[0] > pstats[0] )
     return 0;
     if ( pstats[0] > wstats[0] )
     return 1;
     if ( wstats[0] == pstats[0] ) {
          if ( wstats[1] > pstats[1] )
          return 0;
          if ( pstats[1] > wstats[1] )
          return 1;
          if ( pstats[1] == wstats[1] )
          return 2;
          }
          }
//Fin de funciones para definir al ganador
void despliega(const int *cara, const int *palo, const char **wcara, const char **wpalo) {
     cout << endl << endl;
     for ( int contador=0; contador < 5 ; contador++ ) {
         cout << std::right << setw(10 ) << contador+1 << "- " << wcara[cara[contador]-1] << " de "

              << wpalo[palo[contador] - 1];
         if ( contador % 2 == 0 )
         cout << endl;
         }
     cout << endl;
         }
//Cambia las cartas de la pc, utilizando pstats[1]
void cambiar( int *cara , int *palo, const int *paux,const int *ppaux, const int carta ) {
     for ( int contador=0; contador < 5; contador++ ) {
         if ( cara[contador] == carta )
         continue;
         else
         cara[contador]=paux[contador];
         palo[contador]=ppaux[contador];
         }
         }