Deitel_C++_5.13 (Juego de Poker en C++)

Una Flor Imperial

Lo primero que debo hacer es ofrecer una disculpa por haber hecho un programa tan grande. Contiene mas de 1100 lineas de código y cuando lo imprimí me llevé 18 hojas. Sin embargo creo que no es posible hacerlo mas compacto, por lo menos no sin un grave deterioro de la simplicidad que tiene. Creo que se puede seguir muy bien a pesar de que casi no tiene comentarios. Está dividido en bloques que hacen una función muy precisa. Sólo, el ciclo main es un poco confuso. Lo que hace este programa es repartir dos manos y decidir cuál de ellas es la mejor. Revisé las funciones una por una para ver que realmente hacían su tarea. Puedo decir que salvo una, que evalúa un caso realmente raro, creo que las dos manos sean poquer o full, algo de verdad raro, todas funcionan bien. Sin embargo están advertidos acerca de esa funcion, que ahora no recuerdo porque fue hace mucho. En la práctica supongo que pueden pasar la vida jugando y no van a estar en una mesa en la que ustedes y alguien mas tengan un full, pero si hubiera de usarse este programa, digamos para un casino, debería revisarse de manera exhaustiva. Yo lo hice, y no detecte más error que ese, pero desde luego puede haber más. La manera de evaluarlas es enviarles casos solo a las funciones. Por ejemplo para una flor imperial hice un programa independiente llamado flor imperial que únicamente analizaba esos casos. Debo decir que me sorprendió cuando empezaron a salir flores imperiales en menos de un millón de manos, algunas en 600 mil, si no me falla la memoria. Yo esperaba que fueran más raras porque había visto en wikipedia las posibles combinaciones que no incluían el hecho de que una flor imperial es la misma de 5! maneras diferentes ( la probabilidad de que una mano sea flor imperial es 4*5!*47!/52!). Este programa no juega poquer, sólo evalúa manos, hacer que juegue es el siguiente ejercicio, pero con esta base es mas fácil resolverlo.

 #include <iostream>
 using namespace::std;

 #include <cstdlib>
 #include <ctime>

 const int manos = 2; //Este programa solo reparete dos manos
 const int Numero_Palos = 4;
 const int Cartas_de_Palo = 13;

 const int n = Cartas_de_Palo + 1;

 void Barajar( int[][n], int[], int[] );
 void Repartir( int[][n] );
 int Analizar( int[][n], int[], int[] );
 int Corrida( int[]);
 int Flor_Imperial( int[]);
 int Desempate1( int[], int[]);
 int Desempate2( int[], int[]);
 int Desempate3( int[], int[]);
 int Desempate4( int[], int[]);
 int Desempate5( int[], int[]);
 int Desempate6( int[], int[]);
 int Desempate7( int[], int[]);
 int Desempate8( int[], int[]);
 int Desempate9( int[], int[]);
 //Las funciones Corrida y Flor_Imperial son llamadas por la funcion Analizar


 int main()
 { // Inicia main
 int centinela = 0;


 // while ( 0 == centinela )
  //{ //Abre while
 int contador_de_manos = 1;
 int valor = 0;
 int Valores_Manos[ manos + 1 ] = { 0};
 // en el arreglo valores se guardaran los valores de las manos
 int mano1[Numero_Palos + 1] = {0};
 int mano2[Numero_Palos + 1] = {0};

 cout << "\nEl numero de manos a repartir es: " << manos << endl;

 srand(time(0));

 while ( contador_de_manos <= manos )
 { // Abre while
 int cartas[Numero_Palos + 1][n] = { {0, 0} };
 int xF[53] = {0};
 int xN[53] = { 0 };



 Barajar( cartas, xF, xN );
 cout << "\nEsta es la mano del jugador " << contador_de_manos <<" : ";
 cout << endl;
 Repartir( cartas );
 //Esta funcion debe repartir 5 cartas del arreglo cartas
 // solo hay que imprimir los numeros 1 a 5 ;

 if ( 1 == contador_de_manos )
 {
 for (int cont = 1; cont <= 5; cont++)
 mano1[cont] = xN[cont];
 }

 else
 {
 for (int conta = 1; conta <= 5; conta++)
 mano2[conta] = xN[conta];
 }
 valor = Analizar( cartas, xF, xN );
 Valores_Manos[ contador_de_manos ] = valor;

 contador_de_manos++;

 } // Cierra while

 int mayor;
 int ganador;

 // Aqui se desempata para el caso de la carta mas alta
 if ( Valores_Manos[1] == Valores_Manos[2] )
 { // Abre if

 switch (Valores_Manos[1])

 {

 // Desempata carta mas alta
 case 1:
 {
 ganador = Desempate1( mano1, mano2);
 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;

 // Desempata pares
 case 2:
 {
 ganador = Desempate2(mano1, mano2);

 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;


 // Desempata dos pares
 case 3:

 {
 ganador = Desempate3(mano1, mano2);

 centinela = 1;
 // La linea de arriba estaba comentada

 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;


 // Desempata tercias
 case 4:

 {
 ganador = Desempate4(mano1, mano2);
 centinela = 1;
 // La linea de arriba estaba comentada

 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;


 case 5:
 // Desempata escaleras

 {
 ganador = Desempate5(mano1, mano2);


 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;



 // Desempata color

 case 6:
 {
 ganador = Desempate1(mano1, mano2);


 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }
 break;


 // Desempata full

 case 7:
 { // Abre case 7
 ganador = Desempate7(mano1, mano2);
 centinela = 1;

 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 }

 break;


 case 8: // Desempata poquer
 { // Abre case 8
 ganador = Desempate8(mano1, mano2);


 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }
 } // Cierra case 8

 break;


 case 9: // Desempata escaleras de color

 { // Abre case 9;
 ganador = Desempate9( mano1, mano2);

 if ( 1 == ganador )
 cout <<"\nLa mano del jugador 1 es mejor que la del jugador 2." <<endl;
 else
 {
 if ( 2 == ganador)
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1." <<endl;
 else
 if ( 0 == ganador)
 cout << "\nLas manos tienen cartas del mismo numero. " <<endl;
 }

 } // Cierra case 9

 break;

 case 10:

 { // Abre case 10

 cout << "\nHAY DOS FLORES IMPERIALES!" <<endl << endl;

 } // Cierra case 10
 default:
 break;


 } // Cierra switch
 } // Cierra if del caso en el que las manos son iguales
 // (del mismo tipo)


 else
 { //Abre else
 if ( Valores_Manos[1] > Valores_Manos[2] )
 cout << "\nLa mano del jugador 1 es mejor que la del jugador 2."<<endl;
 else
 cout <<"\nLa mano del jugador 2 es mejor que la del jugador 1."<< endl;
 } //Cierra else


 // } // Cierra while de centinela
 //comento esta linea
 return 0;
 } // Cierra main


 // Esta funcion define las variables y llama a las funciones
 // barajar y repartir

 //////////////////////////////////////////////////////////////////
 // Inicia la funcion barajar
 /////////////////////////////////////////////////////////////////

 void Barajar(int Mazo[][14], int xFiguras[], int xNumeros[] )

 { // Abre barajar

 int contador;
 int tipo_carta;
 int numero_carta;

 for ( contador = 1; contador <= 52; contador++ )
 { //Abre for
 // El numero de cartas a llenar es 52, las entradas de la variable
 // mazo.
 do{ //Abre do
 tipo_carta = 1 + rand() % 4; //Se elige al azar la columna y la
 numero_carta = 1 + rand() % 13; //fila del arreglo mazo en donde
 // se pondra el numero siguiente
 } while( 0 != Mazo[tipo_carta][numero_carta] ); //Cierra do
 //Con la condicion del while se cuida que no se llene una casilla
 // ya llenada


 if ( 0 == Mazo[tipo_carta][numero_carta] )
 // Este if es porque es muy probable que la fila y columna elegida
 // ya este llena, sobre todo para los numeros finales
 { // Abre if
 Mazo[tipo_carta][numero_carta] = contador;
 xFiguras[contador] = tipo_carta;
 xNumeros[contador] = numero_carta;
 } //Cierra if
 } //Cierra for

 return;
 } // Cierra barajar




 /////////////////////////////////////////////////////////////////
 // Inicia la funcion repartir
 ////////////////////////////////////////////////////////////////

 void Repartir( int barajadas[][14] )

 { // Abre Repartir
 const char *Numero[14] = { "error", "As", "Dos", "Tres", "Cuatro", "Cinco",
 "seis", "siete", "ocho", "Nueve", "Diez",
 "Sota", "Reina", "Rey"};

 const char *Palos[5] = { "error", "Corazones", "Treboles", "Espadas",
 "Diamantes"};

 //cout << "\nSu mano es la siguiente:\n " << endl;


 for ( int r = 1; r <= 5; r++ )
 // Se repartiran 5 cartas

 { //Abre for
 for ( int y = 1; y <= 4; y++ )
 {
 for ( int z = 1; z <= 13; z++ )
 { //Abre for doble anidado
 if ( r == barajadas[y][z])
 cout << Numero[z] << " de " << Palos[y] << endl;

 } // Cierra for doble anidado
 } //Cierra for anidado
 } //Cierra for
 } // Cierra Repartir



 ////////////////////////////////////////////////////////////////////////
 // Inicia la funcion analizar
 ///////////////////////////////////////////////////////////////////////


 int Analizar( int xcartas[][14], int Fig[], int Num[] )

 { //Abre Analizar

 int temp = Fig[1];
 int iguales = 1;
 int corrida = 0;
 int valor = 1; //El valor de la mano es 1, siempre habra una carta
 // de mayor valor;

 //Aqui se analizan los numeros

 int temp2[14] = {0 };
 for ( int s = 1; s <= 5; s++ )
 { // Abre for
 temp2[Num[s]]++;

 } //Cierra for


 int contador_pares = 0;
 int contador_tercia = 0;
 int contador_poquer = 0;

 for ( int w = 1; w <= 14; w++ )
 { //Abre for
 if ( 2 == temp2[w] )
 contador_pares++;

 if ( 3 == temp2[w] )
 contador_tercia = 1;

 if ( 4 == temp2[w] )
 {
 contador_poquer = 1;
 }

 } //Cierra for

 if ( 0 != contador_pares )
 {
 cout <<"\nUsted tiene " << (1 == contador_pares? " 1 par " :
 " dos pares") << endl;
 if ( 1 == contador_pares)
 valor = 2;
 else
 valor = 3;
 }

 if ( 1 == contador_tercia )
 { // Abre if
 cout <<(0 != contador_pares? "y 1 tercia ( Un full). " :
 "\nUsted tiene una tercia. ");
 if ( 1 == contador_pares )
 valor = 7;
 else
 valor = 4;
 } // Cierra if

 if ( 1 == contador_poquer )
 {
 cout <<"\nUsted tiene un poquer. " << endl;
 valor = 8;
 }



 //En este ciclo for se analizan las figuras


 for ( int i = 2; i <= 5; i ++ )
 { // Abre for
 if ( Fig[ i ] != temp )
 { // Abre if
 iguales = -1;
 } // Cierra if
 } // Cierra for

 /////////////////////////////////////////////////////////////////////
 // Despues de haber analizado el color, se usa esa informacion

 if ( 1 == iguales )
 { //Abre if de iguales

 corrida = Corrida( Num );
 // La funcion corrida verifica que los numeros sean consecutivos
 int flor; // Se verifica que haya flor imperial
 if ( 0 == corrida )
 { // Abre if anidado
 flor = Flor_Imperial(Num);
 if ( 0 == flor )
 { //Abre if doble anidado
 cout <<"\n\nUsted tiene un flux!" << endl;
 valor = 6;
 } //Cierra if doble anidado
 else
 { // Abre else doble anidado
 cout <<"\n\nUSTED TIENE UNA FLOR IMPERIAL!" << endl << endl;
 valor = 10;
 } // Cierra else doble anidado
 } // Cierra if anidado

 else // Abre else anidado
 {
 cout << "\nUsted tiene una escalera de color!" << endl;
 valor = 9;
 } //Cierra else anidado


 } // Cierra if de colore iguales




 else
 { //Analiza escalera para el caso de colores distintos
 int escalera;
 escalera = Corrida( Num);

 if ( 1 == escalera )
 { // Abre if anidado
 cout << "\nUsted tiene una escalera. " << endl;
 valor = 5;
 } // cierra if anidado
 } // Cierra else

 cout << "\nEl valor de su mano es: " << valor << endl;
 return valor;
 } //Cierra Analizar

 ///////////////////////////////////////////////////////////////////
 // Inicia la funcion corrida, esta funcion se llama por la funcion
 // Analizar
 //////////////////////////////////////////////////////////////////

 int Corrida( int X[])

 { // Abre la funcion Corrida

 int temporal;
 for ( int l = 1; l < 5; l++)
 { //Abre for
 for ( int d = 1; d < 5; d++ )

 { // Abre for anidado
 if ( X[d + 1] < X[d] )
 { //Abre if
 temporal = X[d];
 X[d] = X[d + 1];
 X[d + 1] = temporal;
 } //Cierra if
 } //Cierra for anidado
 } //Cierra for

 int ordenados = 0;

 for ( int t = 1; t < 5; t++ )
 { //Abre for
 if ( X[t + 1] == X[t] + 1 )
 { //Abre if
 //cout << X[t] << " ";
 ordenados++;
 } // Cierra if
 } //Cierra for

 //cout << X[5] << endl;
 if ( 4 != ordenados )

 return 0;

 else

 return 1;
 }



 //////////////////////////////////////////////////////////////////////////
 /// Se define la funcion Flor_Imperial
 /////////////////////////////////////////////////////////////////////////


 int Flor_Imperial( int Y[] )
 { //Abre la funcion
 int tempor;
 for ( int f = 1; f < 5; f++)
 { //Abre for
 for ( int d = 1; d < 5; d++ )

 { // Abre for anidado
 if ( Y[d + 1] < Y[d] )
 { //Abre if
 tempor = Y[d];
 Y[d] = Y[d + 1];
 Y[d + 1] = tempor;
 } //Cierra if
 } //Cierra for anidado
 } //Cierra for

 // El doble ciclo for anterior ordeno de menor a mayor el arreglo
 // de numeros de las cartas

 int variable = 10;
 int cambio = 0;

 if ( 1 != Y[1] )
 return 0;

 else
 { // Abre else

 for ( int z = 2; z <= 5; z++ )
 { //Abre for
 if ( Y[z] != variable )
 {
 cambio = 1;
 }
 variable++;
 } //Cierra for
 } // Cierra else

 if ( 0 != cambio )
 return 0;
 else
 return 1;
 } // Cierra la funcion



 /////////////////////////////////////////////////////////////////////
 // Inicia Desempate1
 ////////////////////////////////////////////////////////////////////

 // Desempata en caso de carta mas alta

 int Desempate1( int Mano1[], int Mano2[])

 { //Abre desempate




 int hold;
 int temporal;
 for ( int x = 1; x < 5; x++)

 {

 for (int j = 1; j < 5; j++ )
 if ( Mano1[j] > Mano1[j + 1])
 {
 hold = Mano1[j];
 Mano1[j] = Mano1[j + 1];
 Mano1[j + 1] = hold;
 }

 for (int t = 1; t < 5; t++ )
 if ( Mano2[t] > Mano2[t + 1])
 {
 temporal = Mano2[t];
 Mano2[t] = Mano2[t + 1];
 Mano2[t + 1] = temporal;
 }
 }

 for (int d = 1; d <= 5; d++ )
 cout << Mano1[d] << " " << Mano2[d] <<endl;

 int no_as = 1;

 if( 1 == Mano1[1])
 {
 if( 1 != Mano2[1])
 return 1;
 else
 no_as = 1;
 }



 if( 1 == Mano2[1])
 {
 if( 1 != Mano1[1])
 return 2;
 else
 no_as = 1;
 }


 if ( 1 == no_as )
 {
 for ( int h = 5; h >= 1; h--)
 {
 if ( Mano1[h] > Mano2[h])
 {
 cout <<"\nRetorna 1" << endl;
 return 1;
 }
 else
 {
 if ( Mano1[h] < Mano2[h] )
 {
 cout << "\nRetorna 2." << endl;
 return 2;
 }
 }

 }

 cout << "\nRetorna 0." << endl;
 return 0;
 }



 } //Cierra desempate1



 /////////////////////////////////////////////////////////////////
 // Inicia Desempate2
 ////////////////////////////////////////////////////////////////

 // Desempata el caso de manos con un par cada una


 int Desempate2( int Mano1[], int Mano2[])
 {

 int par1 = 0;
 int par2 = 0;

 for ( int r = 1; r <= 4; r++ )
 for ( int s = r + 1; s <= 5; s++)
 {
 if (Mano1[r] == Mano1[s])
 par1 = Mano1[s];


 if (Mano2[r] == Mano2[s])
 par2 = Mano2[s];

 }

 if ( par1 > par2 )
 {
 if ( 1 == par2)
 return 2;
 else
 return 1;
 }
 else
 {
 if ( par1 < par2 )
 {
 if ( 1 == par1 )
 return 1;
 else
 return 2;
 }
 else
 return Desempate1(Mano1, Mano2);
 }


 }


 ////////////////////////////////////////////////////////////////////
 // Inicia Desempate3
 //////////////////////////////////////////////////////////////////////

 //Desempata en caso de manos con dos pares cada una



 int Desempate3( int Mano1[], int Mano2[])

 {

 // Aqui se buscan los pares de la mano1

 int par1 = 0;
 int par2 = 0;
 for ( int i = 1; i <= 4; i++)
 { // Abre for
 for ( int y = i + 1; y <= 5; y++)

 { // Abre for anidado
 if ( (Mano1[i] == Mano1[y]) && (0 == par1) )
 { // Abre if
 par1 = Mano1[i];
 } // Cierra if

 if ( (0 != par1) && (Mano1[i] == Mano1[y] && (Mano1[y] != par1)) )
 { // Abre if
 par2 = Mano1[i];
 } // Cierra if

 } // Cierra for anidado
 } // Cierra for


 // Aqui se determina el mayor par de la mano1

 int mayor1 = 0;
 int mayor1a = 0;

 if ( par1 > par2)
 { // Abre if
 mayor1 = par1;
 mayor1a = par2;
 } // Cierra if

 else // En el caso de que par2 sea mayor que o igual a par1
 {
 mayor1 = par2;
 mayor1a = par1;
 }



 // Aqui se determinan los pares de la mano2




 int par1m2 = 0;
 int par2m2 = 0;

 for ( int i = 1; i <= 4; i++)
 { // Abre for
 for ( int y = i + 1; y <= 5; y++)

 { // Abre for anidado
 if ( Mano2[i] == Mano2[y] && 0 == par1m2 )
 { // Abre if
 par1m2 = Mano2[i];
 } // Cierra if

 if ( (0 != par1m2) && ((Mano2[i] == Mano2[y]) && (Mano2[y] != par1m2)) )
 { // Abre if
 par2m2 = Mano2[i];
 } // Cierra if

 } // Cierra for anidado
 } // Cierra for



 // Aqui se determina el mayor de los pares de la mano 2



 int mayor2 = 0;
 int mayor2a = 0;

 if ( par1m2 > par2m2)
 { // Abre if
 mayor2 = par1m2;
 mayor2a = par2m2;
 } // Cierra if

 else // En el caso de que par2 sea mayor que o igual a par1
 { // Abre else
 mayor2 = par2m2;
 mayor2a = par1m2;
 } // Cierra else


 // Aqui se envia el mayor valor o se llama a desempate a la funcion
 // Desempate1

 // Aqui se ve el caso de que haya pares de ases

 if ( (1 == mayor1a) || (1 == mayor2a) )
 { // Abre if para par de ases
 cout <<"\nReconoce que hay un par de ases. " <<endl;

 if ( (1 == mayor1a) && (1 != mayor2a) )
 return 1;
 }
 else
 { // Abre else
 if ( (1 != mayor1a) && (1 == mayor2a) )
 return 2;
 } // Cierra if para par de ases



 if ( mayor1 > mayor2 )

 return 1;

 else
 { // Abre else
 if ( mayor2 > mayor1 )
 return 2;

 else // En caso de que los pares mayores sean iguales
 // Solo se consideran los casos en los que los pares menores son
 // diferentes, si son iguales se pasa a la ultima instruccion que
 // llama al desempate por la carta mas alta.
 { // Abre else
 if ( mayor1a > mayor2a)
 return 1;
 else
 {
 if ( mayor2a > mayor1a )
 return 2;
 }
 } // cierra else
 return Desempate1(Mano1, Mano2);

 } // Cierra else


 }




 //////////////////////////////////////////////////////////////////////
 // Inicia funcion Desempate4
 /////////////////////////////////////////////////////////////////////

 // Se desempatan las tercias

 int Desempate4( int Mano1[], int Mano2[])

 {
 // Aqui se determina el valor de las tercias

 int par1 = 0;
 int par2 = 0;

 for ( int i = 1; i <= 4; i++)
 { // Abre for
 for ( int y = i + 1; y <= 5; y++)

 { // Abre for anidado
 if ( Mano1[i] == Mano1[y] )
 { // Abre if
 par1 = Mano1[i];
 } // Cierra if

 if ( Mano2[i] == Mano2[y] )
 { // Abre if
 par2 = Mano2[i];
 } // Cierra if


 if (par1 > par2)
 return 1;
 else
 return 2;
 } // Cierra for anidado
 } // Cierra for


 return 1;

 }


 ////////////////////////////////////////////////////////////////////////
 // Inicia la funcion desempate 5
 ////////////////////////////////////////////////////////////////////////

 // Desempata corrida

 int Desempate5( int Mano1[], int Mano2[])

 {
 return Desempate1( Mano1, Mano2);
 }



 ////////////////////////////////////////////////////////////////////////
 // Inicia la funcion Desempate6
 /////////////////////////////////////////////////////////////////////////

 // Desempata color
 int Desempate6( int Mano1[], int Mano2[])
 { // Abre Desempate6

 return Desempate1(Mano1, Mano2);

 } // Cierra Desempate6


 ////////////////////////////////////////////////////////////////////////
 // Inicia la funcion desempate7
 ///////////////////////////////////////////////////////////////////////


 // Desempata full

 int Desempate7( int Mano1[], int Mano2[])
 { // Inicia la funcion Desempate7

 int parmano1 = 0; // No es necesario conocer los pares
 int parmano2 = 0;
 int terciamano1= 0;
 int terciamano2 = 0;

 // Aqui se se ordenan las manos para tomar los valores mas chicos
 int hold;
 int temporal;
 for ( int x = 1; x < 5; x++)

 {

 for (int j = 1; j < 5; j++ )
 if ( Mano1[j] > Mano1[j + 1])
 {
 hold = Mano1[j];
 Mano1[j] = Mano1[j + 1];
 Mano1[j + 1] = hold;
 }

 for (int t = 1; t < 5; t++ )
 if ( Mano2[t] > Mano2[t + 1])
 {
 temporal = Mano2[t];
 Mano2[t] = Mano2[t + 1];
 Mano2[t + 1] = temporal;
 }
 }

 // Aqui se consdera el caso en el que la tercia es menor y esta
 // por lo tanto al principio de Mano1
 if ( Mano1[1] == Mano1[3] )
 { // Abre if
 terciamano1 = Mano1[1];
 parmano1 = Mano1[4]; // El par es Mano1[4] y Mano1[5]
 } // Cierra if

 else
 { // Abre else para el caso en el que los primeros tres numeros
 // ordenados no son iguales
 terciamano1 = Mano1[4];
 parmano1 = Mano1[1];

 } // Cierra else



 if ( Mano2[1] == Mano2[3] )
 { // Abre if
 terciamano2 = Mano2[1];
 parmano2 = Mano2[4]; // El par es Mano1[4] y Mano1[5]
 } // Cierra if

 else
 { // Abre else para el caso en el que los primeros tres numeros
 // ordenados no son iguales
 terciamano2 = Mano2[4];
 parmano2 = Mano2[1];

 } // Cierra else


 // Aqui se desempatan las tercias

 if ( 1 == terciamano1 )
 { // Abre if de parmano1 = 1
 if ( 1 != terciamano2 )
 {
 return 1;
 }
 } // Cierra if de parmano1 = 1


 if ( 1 == terciamano2 )
 { // Abre if de parmano1 = 1
 if ( 1 != terciamano1 )
 {
 return 2;
 }
 } // Cierra if de parmano1 = 1


 // Si ninguna de las tercias es de ases se llega a esta etapa,
 // donde se considera la mayor tercia

 if ( terciamano1 > terciamano2 )
 return 1; // La terciamano1 es la mayor
 if ( terciamano2 > terciamano1 )
 return 2;

 // En este punto debe de haber retornado un valor, ya que las tercias
 // no pueden ser iguales

 } // Cierra la funcion Desempate7



 ////////////////////////////////////////////////////////////////////
 // Inicia la funcion Desempate8
 //////////////////////////////////////////////////////////////////////



 int Desempate8( int Mano1[], int Mano2[])
 { // Abre Desempate8

 return Desempate1(Mano1, Mano2);

 } // Cierra Desempate8



 //////////////////////////////////////////////////////////////////////
 // Inicia Desempate9
 /////////////////////////////////////////////////////////////////////

 int Desempate9( int Mano1[], int Mano2[])
 {
 return Desempate1( Mano1, Mano2 );
 }