Buff.. Interesante pero complicado.
Tengo una duda. Si tengo una fila de por ejemplo dos piezas redondas y dos cuadradas, pero las cuatro son claras... ¿sería una combinación ganadora?
Es decir, ¿basta con que coincidan todas en una sola característica?
En ese caso podemos crear una clase Pieza donde cada característica sea un atributo.
En ese enunciado se mencionan 8 características, pero en realidad serían solo 4 porque son características opuestas.
Una pieza o es redonda, o es cuadrada, no puede ser ambas cosas a la vez.
O es grande, o es pequeña.
O es clara, o es oscura.
etc...
Así que la clase Pieza, para comenzar, solo tendría 4 atributos que pueden ser de tipo boolean.
public class Pieza {
public boolean esClara;
public boolean esGrande;
public boolean esRedonda;
public boolean esHueca;
public Pieza(boolean esClara, boolean esGrande, boolean esRedonda, boolean esHueca) {
this.esClara = esClara;
this.esGrande = esGrande;
this.esRedonda = esRedonda;
this.esHueca = esHueca;
}
}
Si por ejemplo el atributo esClara tiene valor true, pues que la pieza es clara. Si tiene valor false, es que es oscura.
Es muy simple, no tiene mayor misterio.
Ahora hay que pensar en como modelar una combinación de 4 piezas, y poder discernir si es una combinación GANADORA o no.
Será GANADORA si todas las piezas coinciden en al menos uno de esos cuatro atributos.
Podemos hacer una clase llamada Combinacion con un array de 4 piezas.
Este array lo recibe por el constructor. Luego según la necesidades del programa, se puede hacer que las piezas se reciban por algún setter, eso ya verás tú lo que necesites..
Una vez tenemos ese array, podemos hacer distintos métodos, uno por cada atributo, que se encarguen de comprobar si las piezas coinciden en ese atributo en concreto.
Serán métodos boolean, que devolverán true si todas coinciden en su atributo o false si no es así.
Un último método comprobará si alguno de estos métodos devuelve true, lo cuál significará que la combinación es GANADORA.
A esta clase le pongo un main() para poder testear combinaciones de piezas a a ver si funciona bien la clase:
public class Combinacion {
private Pieza[] piezas;
public Combinacion(Pieza[] piezas) {
this.piezas = piezas;
}
/**
* Indica si esta combinación de piezas es <u>Ganadora</u>.<br>
* Una combinación es <u>Ganadora</u> si todas las piezas tiene al menos
* una característica en común.
* @return <i>True</i> si es Ganadora, <i>False</i> en caso contrario.
*/
public boolean esGanadora() {
return compruebaPrimerAtrib() || compruebaSegundoAtrib()
|| compruebaTercerAtrib() || compruebaCuartoAtrib();
}
/**
* Comprueba si todas las piezas coinciden en el primer
* atributo, es decir, si todas son <b>CLARAS</b> o
* si todas son <b>OSCURAS</b>.
* @return <i>True</i> si todas coinciden en el primer
* atributo, <i>False</i> en caso contrario.
*/
private boolean compruebaPrimerAtrib() {
//La primera pieza establece el valor con el que debemos comparar.
boolean primera = piezas[0].esClara;
//Recorremos resto de piezas
for (int i = 1; i < piezas.length; i++)
if (piezas[i].esClara != primera)
return false; //Hemos encontrado una diferencia, retornamos false
/*
* Si el bucle FOR termina sin haber retornado false, es que
* todas las piezas coinciden en el primer atributo.
* Por tanto, retornamos true.
*/
return true;
}
/**
* Comprueba si todas las piezas coinciden en el segundo
* atributo, es decir, si todas son <b>GRANDES</b> o
* si todas son <b>PEQUEÑAS</b>.
* @return <i>True</i> si todas coinciden en el segundo
* atributo, <i>False</i> en caso contrario.
*/
private boolean compruebaSegundoAtrib() {
boolean primera = piezas[0].esGrande;
for (int i = 1; i < piezas.length; i++)
if (piezas[i].esGrande != primera)
return false;
return true;
}
/**
* Comprueba si todas las piezas coinciden en el tercer
* atributo, es decir, si todas son <b>REDONDAS</b> o
* si todas son <b>CUADRADAS</b>.
* @return <i>True</i> si todas coinciden en el tercer
* atributo, <i>False</i> en caso contrario.
*/
private boolean compruebaTercerAtrib() {
boolean primera = piezas[0].esRedonda;
for (int i = 1; i < piezas.length; i++)
if (piezas[i].esRedonda != primera)
return false;
return true;
}
/**
* Comprueba si todas las piezas coinciden en el cuarto
* atributo, es decir, si todas son <b>HUECAS</b> o
* si todas son <b>RELLENAS</b>.
* @return <i>True</i> si todas coinciden en el cuarto
* atributo, <i>False</i> en caso contrario.
*/
private boolean compruebaCuartoAtrib() {
boolean primera = piezas[0].esHueca;
for (int i = 1; i < piezas.length; i++)
if (piezas[i].esHueca != primera)
return false;
return true;
}
//Para testear combinaciones
public static void main(String[] args) {
//Array de piezas
Pieza[] pzs = new Pieza[4];
pzs[0] = new Pieza(true, false, false, true);
pzs[1] = new Pieza(false, false, false, true);
pzs[2] = new Pieza(true, true, false, true);
pzs[3] = new Pieza(true, false, true, false);
Combinacion combi = new Combinacion(pzs);
System.out.println(combi.esGanadora()?"Ganadora":"No ganadora");
}
}
En ese main he creado una combinación que NO es GANADORA, y así lo detecta el programa.
Si probamos a cambiarla por esta otra, donde todas son HUECAS, entonces sí declara la combinación como GANADORA:
Pieza[] pzs = new Pieza[4];
pzs[0] = new Pieza(true, false, false, true);
pzs[1] = new Pieza(false, false, false, true);
pzs[2] = new Pieza(true, true, false, true);
pzs[3] = new Pieza(true, false, true, true);
Creo que así hemos encontrado una forma de comparar piezas para decidir si una combinación de 4 de ellas, es ganadora.
Esto sería a nivel de "Modelo", es decir, modelando objetos que no se ven en pantalla.
Ya tendrás que adaptarlo a lo que tu estés haciendo a nivel de "Vista". No se como estarás representando las piezas en pantalla, aunque no importa demasiado, esta parte del "Modelo" vendría a ser igual.
Tema: Java juego con tablero quarto crear línea de cuatro piezas por turnos dos jugado (Leído 1886 veces)
RSS -
WAP2