Cdigo fuente

Carta.java

/* Clase con la que vamos a representar cada una de las cartas de la baraja */
public class Carta {
/* Constantes enteras que definen los palos y las cartas que no tienen valor
numerico */
public final static int ESPADAS = 0,
CORAZONES = 1,
DIAMANTES = 2,
PICAS = 3;
public final static int AS = 1,
JACK = 11,
QUEEN = 12,
KING = 13;
/* Las 2 propiedades de nuestra carta seran valor y palo.
Las definimos como privadas y a continuacion definimos los metodos para
obtenerlas */
private final int palo;
private final int valor;
/* Metodo constructor */
public Carta(int val, int pal) {
valor = val;
palo = pal;
}
/* Metodos que nos devuelven valor y palo como entero y como String */
public int getPalo() {
return palo;
}
public int getValor() {
return valor;
}
public String getPaloString() {
switch ( palo ) {}
}
case ESPADAS: return "Espadas";
case CORAZONES: return "Corazones";
case DIAMANTES: return "Diamantes";
case PICAS: return "Picas";
default:
return "??";
public String getValorString() {
switch ( valor ) {
case 1: return "As";
case 2: return "2";
case 3: return "3";
case 4: return "4";
case 5: return "5";
case 6: return "6";
case 7: return "7";
case 8: return "8";
case 9: return "9";
case 10: return "10";
case 11: return "J";
case 12: return "Q";
case 13: return "K";
default: return "??";
}
}
public String toString() {
return getValorString() + " de " + getPaloString();
}
}
Baraja.java

/* Clase que representara nuestra baraja de 52 cartas*/

public class Baraja {
// La baraja sera un array de Cartas
private static Carta[] baraja;
// Definimos un array de cartas vistas. En cada posicion del array tendremos
el numero de cartas, cuyo
// valor es dicha posicion, que hay descubiertas sobre la mesa o tiene la
banca
public int[] vistas;// Numero de cartas robadas
private int robadas;
// Metodo constructor. Recorremos todos los valores posibles y todos los
palos posibles
public Baraja() {
baraja = new Carta[52];
vistas = new int[13];
int creadas = 0;
for ( int palo = 0; palo <= 3; palo++ ) {
for ( int valor = 1; valor <= 13; valor++ ) {
baraja[creadas] = new Carta(valor,palo);
creadas++;
}
}
robadas = 0;
}
// Ordenamos la baraja en orden aleatorio
public void barajar() {
for ( int i = 51; i > 0; i-- ) {
int rand = (int)(Math.random()*(i+1));
Carta temp = baraja[i];
baraja[i] = baraja[rand];
baraja[rand] = temp;
}
robadas = 0;
}
// Numero de cartas que nos quedan en la baraja
public int restantes() {
return 52 - robadas;
}
// Cuando robamos una carta cogemos la primera del mazo y actualizamos el
array de cartas vistas
public Carta robar() {
if (robadas == 52)
barajar();
robadas++;
vistas[((baraja[robadas-1]).getValor())-1]++;
}}
return baraja[robadas 1];

Mano.java

/* Con esta clase vamos a representar las cartas que tiene un jugador en cierta
jugada y el dinero
que ha apostado en esa jugada */
import java.util.Vector;
public class Mano{
// Se trata de un vector y no un array porque el numero de cartas en la mano
es variable
private Vector mano;
int apuesta;
// Constructor
public Mano() {
mano = new Vector();
}
// Suelta todas las cartas
public void soltar() {
mano.removeAllElements();
}
// Aade una carta a su mano
public void cogerCarta(Carta c) {
if (c != null)
mano.addElement(c);
}
// Suelta una de sus cartas
public void dejarCarta(Carta c) {
mano.removeElement(c);
}
// Suelta la carta en la posicion marcada por pos
public void dejarCarta(int pos) {
if (pos >= 0 && pos < mano.size())
mano.removeElementAt(pos);
}
// Cuenta las cartas que tiene en la manopublic int contar() {
return mano.size();
}
// Nos dice la carta que tiene en la posicion pos
public Carta obtenerCarta(int pos) {
if (pos >= 0 && pos < mano.size())
return (Carta)mano.elementAt(pos);
else
return null;
}
// Cuenta los puntos que suman las cartas de nuestra mano
public int getBlackjackValor() {
int val;
boolean as;
int cartas;
val = 0;
as = false;
cartas = contar();
for ( int i = 0; i < cartas; i++ ) {
Carta carta;
int cartaVal;
carta = obtenerCarta(i);
cartaVal = carta.getValor();
if (cartaVal > 10) {
cartaVal = 10;
}
if (cartaVal == 1) {
as = true;
}
val = val + cartaVal;
}
/* El as en principio vale 1, pero si al cambiar su valor por 11
conseguimos un resultado
igual a 21 o menor lo cambiaremos*/
if ( as == true && val + 10 <= 21 )
val = val + 10;
}}
return val;

Blackjack.java

/* Clase principal que llevara el control del juego */

public class Blackjack {
// Metodo main
public static void main(String[] args) {
int saldo;
int[] resultados;
int[] saldos;
int numero,i;
Mano manoJugador[];
boolean primera=true;
boolean bancarrota[];
// Presentacion
TextIO.putln();
TextIO.putln("Bienvenido al juego de Blackjack.");
TextIO.putln();
TextIO.putln(" AUTORES");
TextIO.putln();
TextIO.putln("Ignacio Ribas Ramos");
TextIO.putln("Miguel Flecha Lozano");
TextIO.putln();
// Preguntamos por nmero de jugadores y por la cantidad con la que
empiezan
TextIO.put("Numero de jugadores:");
numero = TextIO.getlnInt();
TextIO.put("Con que cantidad empezara cada jugador (pesos)?");
saldo = TextIO.getlnInt();
// Inicializamos los arrays que vamos a utilizar
saldos=new int[numero];
manoJugador=new Mano[numero];
resultados=new int[numero+1];
bancarrota=new boolean[numero];for(i=0;i<numero;i++){
saldos[i]=saldo;
bancarrota[i]=false;
}
// Comienza el bucle...
while (true) {
// Le preguntamos a cada jugador cuanto dinero desea apostar
for(int j=0;j<numero;j++){
// Creamos la mano
manoJugador[j]= new Mano();
if(saldos[j]<=0) bancarrota[j]=true;
TextIO.putln();
TextIO.putln("JUGADOR NUMERO " + (j+1) +". Tiene " + saldos[j]
+ " pesos.");
if(!bancarrota[j]){
do {
TextIO.putln("Cuantos pesos quiere apostar? (0 para
salir)");
manoJugador[j].apuesta=TextIO.getlnInt();
if (manoJugador[j].apuesta < 0 || manoJugador[j].apuesta >
saldos[j])
TextIO.putln("Su apuesta debe estar entre 0 y " + saldos[j]
+'
.'
);
utilizamos el mismo array
queda sin dinero, para
// En caso de que el jugador no desee jugar ms
// de booleanos que usamos cuando un jugador se
// que la siguiente ronda no se le pregunte
if (manoJugador[j].apuesta == 0){
TextIO.putln();
TextIO.putln("ADIOS jugador "+(j+1));
bancarrota[j]=true;
}
} while (manoJugador[j].apuesta < 0 ||
manoJugador[j].apuesta > saldos[j]);
}
}// En caso de que no se hayan arruinado todos los jugadores
entramos al metodo jugar
if(!queda_alguno(bancarrota,numero)) resultados =
jugar(numero,manoJugador,bancarrota);
else{
TextIO.putln();
TextIO.putln("Todos los jugadores se han quedado sin
dinero o no hay mas jugadores");
TextIO.putln("Adioooos");
System.exit(-1);
}
// Al salir del metodo jugar comprobamos las puntuaciones ya
actualizamos los saldos
for(int j=0;j<numero;j++){
if((resultados[0]==2)||(resultados[0]==1)) saldos[j] = saldos[j] -
manoJugador[j].apuesta;
else{
switch (resultados[j+1]){
case -1: saldos[j] = saldos[j] -
manoJugador[j].apuesta;break;
case 1: saldos[j] = saldos[j] +
manoJugador[j].apuesta;break;
case 2: saldos[j] = saldos[j] +
2*manoJugador[j].apuesta;break;
default: saldos[j] = saldos[j]-manoJugador[j].apuesta;
}
}
}
}
}
// Metodo jugar que lleva el desarrollo principal de la partida
static int[] jugar(int jugadores,Mano[] manoJugador,boolean[] bancarrota) {
Baraja baraja;
Mano manoBanca;
boolean fin=false;
int i,j;// En resultados almacenamos lo que ha hecho cada jugador.
// 0 en un principio, -1 si se pasa y 1 si gana.
// La posicion 0 sera la de la banca y la posicion i la del jugador i
// Pondremos un 2 en caso de blackjack.
int resultados[];
resultados=new int[jugadores+1];
for (int m=0;m<=jugadores;m++){
resultados[m]=0;
}
baraja = new Baraja();
// Barajamos y repartimos
baraja.barajar();
// La banca roba sus cartas
manoBanca = new Mano();
manoBanca.cogerCarta( baraja.robar() );
manoBanca.cogerCarta( baraja.robar() );
TextIO.putln();
TextIO.putln();
for(i=0;i<jugadores;i++){
// Los jugadores van robando
manoJugador[i].cogerCarta( baraja.robar() );
manoJugador[i].cogerCarta( baraja.robar() );
// En caso de que el usuario consiga Blackjack (21 a la primera)
gana el doble de la apuesta
// y se acaba la ronda
if ((manoJugador[i].getBlackjackValor() == 21)&&(!bancarrota[i])) {
TextIO.putln("La banca tiene " +
manoBanca.obtenerCarta(0)
+ " y " + manoBanca.obtenerCarta(1) + ".");
TextIO.putln("El jugador "+(i+1)+" tiene " +
manoJugador[i].obtenerCarta(0)
+ " y " + manoJugador[i].obtenerCarta(1) + ".");
TextIO.putln();TextIO.putln("El jugador "+(i+1)+" tiene Blackjack y gana");
resultados[i+1]=2;
}
}
fin=true;
// Si la banca tiene BJ gana y se acaba la partida
if (manoBanca.getBlackjackValor() == 21) {
TextIO.putln("La banca tiene " + manoBanca.obtenerCarta(0)
+ " y " + manoBanca.obtenerCarta(1) + ".");
TextIO.putln();
TextIO.putln("La banca tiene Blackjack y gana.");
}
resultados[0]=2;
fin=true;
if (fin) return resultados;
// Si ninguno de los 2 tiene BJ seguimos con el juego
// Comienza la iteracion para cada uno de los jugadores
for(j=0;j<jugadores;j++){
banca
// Mostramos las cartas de los jugadores y una de las cartas de la
TextIO.putln("--------- JUGADOR "+(j+1)+" ---------");
TextIO.putln();
fin=false;
while (!bancarrota[j]) {
TextIO.putln();
TextIO.putln("Jugador "+(j+1)+".Sus cartas son:");
for ( i = 0; i < manoJugador[j].contar(); i++ )
TextIO.putln(" " + manoJugador[j].obtenerCarta(i));
TextIO.putln("Y suman un total de " +
manoJugador[j].getBlackjackValor()+" puntos.");
TextIO.putln();
TextIO.putln("La banca muestra " +
manoBanca.obtenerCarta(0));
TextIO.putln();
// Carta o se planta?TextIO.put("Carta (C) o se Planta (P)? ");
char accion;
do {
accion = Character.toUpperCase( TextIO.getlnChar() );
if (accion != '
C' && accion != '
P'
)
TextIO.put("Por favor responda C o P: ");
} while (accion != '
C' && accion != '
P'
);
// Si se planta salimos del bucle
if ( accion == '
P' ) {
TextIO.putln();
TextIO.putln("El jugador "+(j+1)+" se planta.");
TextIO.putln();
break;
}
// Si no se planta seguimos con una nueva carta
else {
Carta newCarta = baraja.robar();
manoJugador[j].cogerCarta(newCarta);
TextIO.putln();
TextIO.putln("Usted roba carta.");
TextIO.putln("Su carta es " + newCarta);
TextIO.putln("Y usted tiene " +
manoJugador[j].getBlackjackValor()+" puntos");
// Si se pasa de 21 puntos pierde y pone su resultado a -1
if (manoJugador[j].getBlackjackValor() > 21) {
TextIO.putln();
TextIO.putln("El jugador "+(j+1)+" se ha
pasado de 21. Ha perdido");
TextIO.putln();
resultados[j+1]=-1;
fin=true;
}
}
}
}
if (fin) break;
// Ahora le toca jugar a la banca
TextIO.putln();
TextIO.putln("Las cartas de la banca son ");
TextIO.putln(" " + manoBanca.obtenerCarta(0));
TextIO.putln(" " + manoBanca.obtenerCarta(1));while(true){
float beneficio=0;
float beneficio_hip=0;
float beneficio_aux=0;
float probabilidad=0;
// Primero comprobamos el beneficio que obtendriamos en la
situacion actual
for(i=0;i<jugadores;i++){
if(manoBanca.getBlackjackValor()>=manoJugador[i].getBlackjackValor())
beneficio=beneficio+manoJugador[i].apuesta;
else if(resultados[i+1]!=-1) beneficio=beneficio-
manoJugador[i].apuesta;
}
// Sabiendo las cartas que hay en la mesa calcularemos la
esperanza de sacar cada una de las
// posibles cartas y en funcion de eso el beneficio hipotetico que
obtendriamos.
for (j=1;j<14;j++){
Carta aux=new Carta(j,0);
manoBanca.cogerCarta(aux);
probabilidad=baraja.vistas[j-1]/baraja.restantes();
for(i=0;i<jugadores;i++){
if(manoBanca.getBlackjackValor()>=manoJugador[i].getBlackjackValor())
beneficio_aux=beneficio_aux+manoJugador[i].apuesta;
else if(resultados[i+1]!=-1)
beneficio_aux=beneficio_aux-manoJugador[i].apuesta;
}
}
beneficio_hip=beneficio_hip+beneficio_aux*probabilidad;
beneficio_aux=0;
manoBanca.dejarCarta(manoBanca.contar()-1);
// Si el beneficio hipotetico es mayor que el actual robamos carta
if(beneficio_hip>beneficio){
Carta newCarta = baraja.robar();TextIO.putln("La banca roba " + newCarta);
manoBanca.cogerCarta(newCarta);
if (manoBanca.getBlackjackValor() > 21) {
resultados[0]=-1;
break;
}
}else{
}
carta
}
break;
// Repetimos esto hasta que nos pasemos o decidamos no coger nueva
TextIO.putln("El total de la banca es de " +
manoBanca.getBlackjackValor()+" puntos");
// Vamos a comparar los puntos de cada uno para ver quien ha ganado
a quien y lo reflejamos
// en el array de resultados
for(i=0;i<jugadores;i++){
if((resultados[i+1]==-1)||(bancarrota[i])) continue;
if(resultados[0]==-1){
resultados[i+1]=1;
continue;
}
if(manoJugador[i].getBlackjackValor()>manoBanca.getBlackjackValor())
resultados[i+1]=1;
else resultados[i+1]=-1;
}
TextIO.putln();
TextIO.putln();
// Imprimimos por pantalla quien ha ganado a quien
for(i=1;i<=jugadores;i++){
if(!bancarrota[i-1]){
if(resultados[i]>resultados[0]) TextIO.putln("Jugador "+i+"
gana a la banca.");
else TextIO.putln("La banca gana al jugador "+i+".");
}
}return resultados;
}
dinero
// Este metodo comprueba si todos los jugadores se han quedado sin
static boolean queda_alguno(boolean bancarrota[],int numero){
boolean bancarrota_total=true;
for(int p=0;(p<numero)&&bancarrota_total;p++){
if(!bancarrota[p]){
bancarrota_total=false;
break;
}
}
return bancarrota_total;
}
}