Poker.java

public class Poker {
	
	// TH, TC, 5S, 5H, AD, AH, 2S  
	public String mejorJugada(Carta[] mano)
	{	
		//Verificamos cada tipo de jugada de poker
		if (escaleraReal(mano)) 
			return "La mano es una escalera real";
		if (escaleraColor(mano)) 
			return "La mano es una escalera color";
		if(esPoker(mano))
			return "La mano es Poker";
		if(fullHouse(mano))
			return "La mano es un Full House";
		if(color(mano))
			return "La mano es un Color";
		if(escalera(mano))
			return "La mano es una escalera";
		if(esTriple(mano))
			return "La mano es un Triple";
		if(esDobleDoble(mano))
			return "La mano es una doble pareja";
		if(esDoble(mano))
			return "La mano es una Pareja Doble";
		
		return "La mano solo posee carta alta ";
	}
	public boolean color(Carta[] cartas){
		//obtenemos el vector ordenado
		int ordenado[]=ordenarValor(cartas);
			//comprobamos si son del mismo palo
			char valor1= cartas[0].palo.charAt(0);
			char valor2= cartas[1].palo.charAt(0);
			char valor3= cartas[2].palo.charAt(0);
			char valor4= cartas[3].palo.charAt(0);
			char valor5= cartas[4].palo.charAt(0);
			if (valor1==valor2 &&  valor1==valor3 && valor4==valor1 && valor1==valor5) 
				return true;
		return false;
	}
	public boolean esDobleDoble(Carta [] carta){
		//obtenemos el vector ordenado
		int vec[]=ordenarValor(carta);
		//si son dos numeros iguales entonces es una pareja de dos
		if (vec[0]==vec[1] && vec[2]==vec[3] || vec[0]==vec[1] && vec[3]==vec[4] )   
			return true;
		if (vec[1]==vec[2] && vec[3]==vec[4] )   
			return true;
		return false;
	}
	public boolean esDoble(Carta [] carta){
		//obtenemos el vector ordenado
		int vec[]=ordenarValor(carta);
		//si son dos numeros iguales entonces es una pareja de dos
		if (vec[0]==vec[1] || vec[1]==vec[2] || vec[2]==vec[3] || vec[3]==vec[4])   
			return true;
		
		return false;
	}
	public boolean esTriple(Carta [] carta){
		//obtenemos el vector ordenado
		int vec[]=ordenarValor(carta);
		//si son tres numeros iguales entonces es un triple
		if (vec[0]==vec[1] && vec[1]==vec[2] || vec[1]==vec[2] && vec[2]==vec[3])   
				return true;
		if (vec[2]==vec[3] && vec[3]==vec[4])   
			return true;
		return false;
	}
	public boolean escalera(Carta [] carta){
		//obtenemos el vector ordenado
		int ordenado[]=ordenarValor(carta);
		//si son numeros sucesivos entonces es una escalera
		if (ordenado[0]+1==ordenado[1] && ordenado[1]+1==ordenado[2] && ordenado[2]+1==ordenado[3] && ordenado[3]+1==ordenado[4] )   
				return true;
		return false;
		
	}
	public boolean escaleraColor(Carta[] cartas){
		//obtenemos el vector ordenado
		int ordenado[]=ordenarValor(cartas);
		
		//si son numeros sucesivos entonces es una escalera
		if (ordenado[0]+1==ordenado[1] && ordenado[1]+1==ordenado[2] && ordenado[2]+1==ordenado[3] && ordenado[3]+1==ordenado[4] )   {
			//comprobamos si son del mismo palo
			char valor1= cartas[0].palo.charAt(0);
			char valor2= cartas[1].palo.charAt(0);
			char valor3= cartas[2].palo.charAt(0);
			char valor4= cartas[3].palo.charAt(0);
			char valor5= cartas[4].palo.charAt(0);
			if (valor1==valor2 &&  valor1==valor3 && valor4==valor1 && valor1==valor5) {
				return true;
			}
		}
		return false;
	}
	public boolean esPoker(Carta [] carta){
		//obtenemos el vector ordenado
		int vec[] = ordenarValor(carta);
		if (vec[0]==vec[1] && vec[0]==vec[2] && vec[0]==vec[3] || vec[1]==vec[2] && vec[1]==vec[3] && vec[1]==vec[4] ) {
			return true;
		}
		return false;
	}

	public boolean fullHouse(Carta[] mano){
		//obtenemos el vector ordenado
		int vec[] = ordenarValor(mano);
		if (vec[0]==vec[1] && vec[0]==vec[2] && vec[3]==vec[4] ) 
			return true;
		if (vec[0]==vec[1] && vec[2]==vec[3] && vec[3]==vec[4] ) 
			return true;
		return false;
	}
	/**
	 * 
	 * @param cartas
	 * @return retorna un vector ordenado por el valor del vector de cartas
	 */
	public int[] ordenarValor(Carta[] cartas){
		//ordenamos por palo
		int cambio=0;
		int ordenado[]=new int[5];
		for (int i = 0; i < cartas.length; i++) {
			char aux = cartas[i].valor.charAt(0);
			switch (aux) {
				case 'A':
					ordenado[i]=1;
					break;
				case 'J':
					ordenado[i]=11;
					break;
				case 'Q':
					ordenado[i]=12;
					break;
				case 'K':
					ordenado[i]=13;
					break;
				case 'T':
					ordenado[i]=10;
					break;
				default:
					ordenado[i]=Integer.parseInt(aux+"");
					break;
			}
		}
		//ahora ordenamos ese vector antes de retornarlo
		
		for (int i = 0; i < ordenado.length-1; i++) {	
			for (int j = 0; j < ordenado.length-1; j++) {
				if (ordenado[j]>ordenado[j+1]) {
					int aux = ordenado[j];
					ordenado[j]=ordenado[j+1];
					ordenado[j+1]=aux;
				}
			}
		}
		return ordenado;
	}
	public boolean escaleraReal(Carta[] cartas){
		//obtenemos el vector ordenado
		int ordenado[]=ordenarValor(cartas);
		if (ordenado[0]==1 && ordenado[1]==10 && ordenado[2]==11 && ordenado[3]==12 && ordenado[4]==13 ) {
			//si entra entonces es una escalera, comprobamos si son del mismo palo
			char valor1= cartas[0].palo.charAt(0);
			char valor2= cartas[1].palo.charAt(0);
			char valor3= cartas[2].palo.charAt(0);
			char valor4= cartas[3].palo.charAt(0);
			char valor5= cartas[4].palo.charAt(0);
			if (valor1==valor2 &&  valor1==valor3 && valor4==valor1 && valor1==valor5) {
				return true;
			}
		}
		return false;
	}

}